// Code generated by MockGen. DO NOT EDIT.
// Source: client.go

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

import (
	io "io"
	reflect "reflect"

	credentials "github.com/aws/aws-sdk-go/aws/credentials"
	ec2 "github.com/aws/aws-sdk-go/service/ec2"
	iam "github.com/aws/aws-sdk-go/service/iam"
	gomock "github.com/golang/mock/gomock"
	v1 "github.com/openshift-online/ocm-sdk-go/clustersmgmt/v1"
)

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

// AddRoleTag mocks base method.
func (m *MockClient) AddRoleTag(roleName, key, value string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddRoleTag", roleName, key, value)
	ret0, _ := ret[0].(error)
	return ret0
}

// AddRoleTag indicates an expected call of AddRoleTag.
func (mr *MockClientMockRecorder) AddRoleTag(roleName, key, value interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddRoleTag", reflect.TypeOf((*MockClient)(nil).AddRoleTag), roleName, key, value)
}

// AttachRolePolicy mocks base method.
func (m *MockClient) AttachRolePolicy(roleName, policyARN string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AttachRolePolicy", roleName, policyARN)
	ret0, _ := ret[0].(error)
	return ret0
}

// AttachRolePolicy indicates an expected call of AttachRolePolicy.
func (mr *MockClientMockRecorder) AttachRolePolicy(roleName, policyARN interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachRolePolicy", reflect.TypeOf((*MockClient)(nil).AttachRolePolicy), roleName, policyARN)
}

// CheckAdminUserExists mocks base method.
func (m *MockClient) CheckAdminUserExists(userName string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CheckAdminUserExists", userName)
	ret0, _ := ret[0].(error)
	return ret0
}

// CheckAdminUserExists indicates an expected call of CheckAdminUserExists.
func (mr *MockClientMockRecorder) CheckAdminUserExists(userName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckAdminUserExists", reflect.TypeOf((*MockClient)(nil).CheckAdminUserExists), userName)
}

// CheckAdminUserNotExisting mocks base method.
func (m *MockClient) CheckAdminUserNotExisting(userName string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CheckAdminUserNotExisting", userName)
	ret0, _ := ret[0].(error)
	return ret0
}

// CheckAdminUserNotExisting indicates an expected call of CheckAdminUserNotExisting.
func (mr *MockClientMockRecorder) CheckAdminUserNotExisting(userName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckAdminUserNotExisting", reflect.TypeOf((*MockClient)(nil).CheckAdminUserNotExisting), userName)
}

// CheckRoleExists mocks base method.
func (m *MockClient) CheckRoleExists(roleName string) (bool, string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CheckRoleExists", roleName)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(string)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// CheckRoleExists indicates an expected call of CheckRoleExists.
func (mr *MockClientMockRecorder) CheckRoleExists(roleName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckRoleExists", reflect.TypeOf((*MockClient)(nil).CheckRoleExists), roleName)
}

// CheckStackReadyOrNotExisting mocks base method.
func (m *MockClient) CheckStackReadyOrNotExisting(stackName string) (bool, *string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CheckStackReadyOrNotExisting", stackName)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(*string)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// CheckStackReadyOrNotExisting indicates an expected call of CheckStackReadyOrNotExisting.
func (mr *MockClientMockRecorder) CheckStackReadyOrNotExisting(stackName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckStackReadyOrNotExisting", reflect.TypeOf((*MockClient)(nil).CheckStackReadyOrNotExisting), stackName)
}

// CreateOpenIDConnectProvider mocks base method.
func (m *MockClient) CreateOpenIDConnectProvider(issuerURL, thumbprint, clusterID string) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateOpenIDConnectProvider", issuerURL, thumbprint, clusterID)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateOpenIDConnectProvider indicates an expected call of CreateOpenIDConnectProvider.
func (mr *MockClientMockRecorder) CreateOpenIDConnectProvider(issuerURL, thumbprint, clusterID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateOpenIDConnectProvider", reflect.TypeOf((*MockClient)(nil).CreateOpenIDConnectProvider), issuerURL, thumbprint, clusterID)
}

// CreateS3Bucket mocks base method.
func (m *MockClient) CreateS3Bucket(bucketName, region string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateS3Bucket", bucketName, region)
	ret0, _ := ret[0].(error)
	return ret0
}

// CreateS3Bucket indicates an expected call of CreateS3Bucket.
func (mr *MockClientMockRecorder) CreateS3Bucket(bucketName, region interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateS3Bucket", reflect.TypeOf((*MockClient)(nil).CreateS3Bucket), bucketName, region)
}

// CreateSecretInSecretsManager mocks base method.
func (m *MockClient) CreateSecretInSecretsManager(name, secret string) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateSecretInSecretsManager", name, secret)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateSecretInSecretsManager indicates an expected call of CreateSecretInSecretsManager.
func (mr *MockClientMockRecorder) CreateSecretInSecretsManager(name, secret interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSecretInSecretsManager", reflect.TypeOf((*MockClient)(nil).CreateSecretInSecretsManager), name, secret)
}

// DeleteAccountRole mocks base method.
func (m *MockClient) DeleteAccountRole(roleName string, managedPolicies bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteAccountRole", roleName, managedPolicies)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteAccountRole indicates an expected call of DeleteAccountRole.
func (mr *MockClientMockRecorder) DeleteAccountRole(roleName, managedPolicies interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAccountRole", reflect.TypeOf((*MockClient)(nil).DeleteAccountRole), roleName, managedPolicies)
}

// DeleteInlineRolePolicies mocks base method.
func (m *MockClient) DeleteInlineRolePolicies(roleName string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteInlineRolePolicies", roleName)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteInlineRolePolicies indicates an expected call of DeleteInlineRolePolicies.
func (mr *MockClientMockRecorder) DeleteInlineRolePolicies(roleName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteInlineRolePolicies", reflect.TypeOf((*MockClient)(nil).DeleteInlineRolePolicies), roleName)
}

// DeleteOCMRole mocks base method.
func (m *MockClient) DeleteOCMRole(roleARN string, managedPolicies bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteOCMRole", roleARN, managedPolicies)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteOCMRole indicates an expected call of DeleteOCMRole.
func (mr *MockClientMockRecorder) DeleteOCMRole(roleARN, managedPolicies interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteOCMRole", reflect.TypeOf((*MockClient)(nil).DeleteOCMRole), roleARN, managedPolicies)
}

// DeleteOpenIDConnectProvider mocks base method.
func (m *MockClient) DeleteOpenIDConnectProvider(providerURL string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteOpenIDConnectProvider", providerURL)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteOpenIDConnectProvider indicates an expected call of DeleteOpenIDConnectProvider.
func (mr *MockClientMockRecorder) DeleteOpenIDConnectProvider(providerURL interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteOpenIDConnectProvider", reflect.TypeOf((*MockClient)(nil).DeleteOpenIDConnectProvider), providerURL)
}

// DeleteOperatorRole mocks base method.
func (m *MockClient) DeleteOperatorRole(roles string, managedPolicies bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteOperatorRole", roles, managedPolicies)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteOperatorRole indicates an expected call of DeleteOperatorRole.
func (mr *MockClientMockRecorder) DeleteOperatorRole(roles, managedPolicies interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteOperatorRole", reflect.TypeOf((*MockClient)(nil).DeleteOperatorRole), roles, managedPolicies)
}

// DeleteOsdCcsAdminUser mocks base method.
func (m *MockClient) DeleteOsdCcsAdminUser(stackName string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteOsdCcsAdminUser", stackName)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteOsdCcsAdminUser indicates an expected call of DeleteOsdCcsAdminUser.
func (mr *MockClientMockRecorder) DeleteOsdCcsAdminUser(stackName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteOsdCcsAdminUser", reflect.TypeOf((*MockClient)(nil).DeleteOsdCcsAdminUser), stackName)
}

// DeleteS3Bucket mocks base method.
func (m *MockClient) DeleteS3Bucket(bucketName string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteS3Bucket", bucketName)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteS3Bucket indicates an expected call of DeleteS3Bucket.
func (mr *MockClientMockRecorder) DeleteS3Bucket(bucketName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteS3Bucket", reflect.TypeOf((*MockClient)(nil).DeleteS3Bucket), bucketName)
}

// DeleteSecretInSecretsManager mocks base method.
func (m *MockClient) DeleteSecretInSecretsManager(secretArn string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteSecretInSecretsManager", secretArn)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteSecretInSecretsManager indicates an expected call of DeleteSecretInSecretsManager.
func (mr *MockClientMockRecorder) DeleteSecretInSecretsManager(secretArn interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSecretInSecretsManager", reflect.TypeOf((*MockClient)(nil).DeleteSecretInSecretsManager), secretArn)
}

// DeleteUserRole mocks base method.
func (m *MockClient) DeleteUserRole(roleName string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteUserRole", roleName)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteUserRole indicates an expected call of DeleteUserRole.
func (mr *MockClientMockRecorder) DeleteUserRole(roleName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteUserRole", reflect.TypeOf((*MockClient)(nil).DeleteUserRole), roleName)
}

// DescribeAvailabilityZones mocks base method.
func (m *MockClient) DescribeAvailabilityZones() ([]string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeAvailabilityZones")
	ret0, _ := ret[0].([]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DetachRolePolicies mocks base method.
func (m *MockClient) DetachRolePolicies(roleName string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DetachRolePolicies", roleName)
	ret0, _ := ret[0].(error)
	return ret0
}

// DetachRolePolicies indicates an expected call of DetachRolePolicies.
func (mr *MockClientMockRecorder) DetachRolePolicies(roleName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachRolePolicies", reflect.TypeOf((*MockClient)(nil).DetachRolePolicies), roleName)
}

// EnsureOsdCcsAdminUser mocks base method.
func (m *MockClient) EnsureOsdCcsAdminUser(stackName, adminUserName, awsRegion string) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EnsureOsdCcsAdminUser", stackName, adminUserName, awsRegion)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// EnsureOsdCcsAdminUser indicates an expected call of EnsureOsdCcsAdminUser.
func (mr *MockClientMockRecorder) EnsureOsdCcsAdminUser(stackName, adminUserName, awsRegion interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnsureOsdCcsAdminUser", reflect.TypeOf((*MockClient)(nil).EnsureOsdCcsAdminUser), stackName, adminUserName, awsRegion)
}

// EnsurePolicy mocks base method.
func (m *MockClient) EnsurePolicy(policyArn, document, version string, tagList map[string]string, path string) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EnsurePolicy", policyArn, document, version, tagList, path)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// EnsurePolicy indicates an expected call of EnsurePolicy.
func (mr *MockClientMockRecorder) EnsurePolicy(policyArn, document, version, tagList, path interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnsurePolicy", reflect.TypeOf((*MockClient)(nil).EnsurePolicy), policyArn, document, version, tagList, path)
}

// EnsureRole mocks base method.
func (m *MockClient) EnsureRole(name, policy, permissionsBoundary, version string, tagList map[string]string, path string, managedPolicies bool) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EnsureRole", name, policy, permissionsBoundary, version, tagList, path, managedPolicies)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// EnsureRole indicates an expected call of EnsureRole.
func (mr *MockClientMockRecorder) EnsureRole(name, policy, permissionsBoundary, version, tagList, path, managedPolicies interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnsureRole", reflect.TypeOf((*MockClient)(nil).EnsureRole), name, policy, permissionsBoundary, version, tagList, path, managedPolicies)
}

// FetchPublicSubnetMap mocks base method.
func (m *MockClient) FetchPublicSubnetMap(subnets []*ec2.Subnet) (map[string]bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FetchPublicSubnetMap", subnets)
	ret0, _ := ret[0].(map[string]bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FetchPublicSubnetMap indicates an expected call of FetchPublicSubnetMap.
func (mr *MockClientMockRecorder) FetchPublicSubnetMap(subnets interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchPublicSubnetMap", reflect.TypeOf((*MockClient)(nil).FetchPublicSubnetMap), subnets)
}

// FilterVPCsPrivateSubnets mocks base method.
func (m *MockClient) FilterVPCsPrivateSubnets(subnets []*ec2.Subnet) ([]*ec2.Subnet, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FilterVPCsPrivateSubnets", subnets)
	ret0, _ := ret[0].([]*ec2.Subnet)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FilterVPCsPrivateSubnets indicates an expected call of FilterVPCsPrivateSubnets.
func (mr *MockClientMockRecorder) FilterVPCsPrivateSubnets(subnets interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FilterVPCsPrivateSubnets", reflect.TypeOf((*MockClient)(nil).FilterVPCsPrivateSubnets), subnets)
}

// FindPolicyARN mocks base method.
func (m *MockClient) FindPolicyARN(operator Operator, version string) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FindPolicyARN", operator, version)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FindPolicyARN indicates an expected call of FindPolicyARN.
func (mr *MockClientMockRecorder) FindPolicyARN(operator, version interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindPolicyARN", reflect.TypeOf((*MockClient)(nil).FindPolicyARN), operator, version)
}

// FindRoleARNs mocks base method.
func (m *MockClient) FindRoleARNs(roleType, version string) ([]string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FindRoleARNs", roleType, version)
	ret0, _ := ret[0].([]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FindRoleARNs indicates an expected call of FindRoleARNs.
func (mr *MockClientMockRecorder) FindRoleARNs(roleType, version interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindRoleARNs", reflect.TypeOf((*MockClient)(nil).FindRoleARNs), roleType, version)
}

// FindRoleARNsClassic mocks base method.
func (m *MockClient) FindRoleARNsClassic(roleType, version string) ([]string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FindRoleARNsClassic", roleType, version)
	ret0, _ := ret[0].([]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FindRoleARNsClassic indicates an expected call of FindRoleARNsClassic.
func (mr *MockClientMockRecorder) FindRoleARNsClassic(roleType, version interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindRoleARNsClassic", reflect.TypeOf((*MockClient)(nil).FindRoleARNsClassic), roleType, version)
}

// FindRoleARNsHostedCp mocks base method.
func (m *MockClient) FindRoleARNsHostedCp(roleType, version string) ([]string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FindRoleARNsHostedCp", roleType, version)
	ret0, _ := ret[0].([]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FindRoleARNsHostedCp indicates an expected call of FindRoleARNsHostedCp.
func (mr *MockClientMockRecorder) FindRoleARNsHostedCp(roleType, version interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindRoleARNsHostedCp", reflect.TypeOf((*MockClient)(nil).FindRoleARNsHostedCp), roleType, version)
}

// ForceEnsurePolicy mocks base method.
func (m *MockClient) ForceEnsurePolicy(policyArn, document, version string, tagList map[string]string, path string) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ForceEnsurePolicy", policyArn, document, version, tagList, path)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ForceEnsurePolicy indicates an expected call of ForceEnsurePolicy.
func (mr *MockClientMockRecorder) ForceEnsurePolicy(policyArn, document, version, tagList, path interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ForceEnsurePolicy", reflect.TypeOf((*MockClient)(nil).ForceEnsurePolicy), policyArn, document, version, tagList, path)
}

// GetAWSAccessKeys mocks base method.
func (m *MockClient) GetAWSAccessKeys() (*AccessKey, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAWSAccessKeys")
	ret0, _ := ret[0].(*AccessKey)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetAccountRoleARN mocks base method.
func (m *MockClient) GetAccountRoleARN(prefix, roleType string) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAccountRoleARN", prefix, roleType)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAccountRoleARN indicates an expected call of GetAccountRoleARN.
func (mr *MockClientMockRecorder) GetAccountRoleARN(prefix, roleType interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAccountRoleARN", reflect.TypeOf((*MockClient)(nil).GetAccountRoleARN), prefix, roleType)
}

// GetAccountRoleByArn mocks base method.
func (m *MockClient) GetAccountRoleByArn(roleArn string) (*Role, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAccountRoleByArn", roleArn)
	ret0, _ := ret[0].(*Role)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAccountRoleByArn indicates an expected call of GetAccountRoleByArn.
func (mr *MockClientMockRecorder) GetAccountRoleByArn(roleArn interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAccountRoleByArn", reflect.TypeOf((*MockClient)(nil).GetAccountRoleByArn), roleArn)
}

// GetAccountRoleForCurrentEnv mocks base method.
func (m *MockClient) GetAccountRoleForCurrentEnv(env, roleName string) (Role, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAccountRoleForCurrentEnv", env, roleName)
	ret0, _ := ret[0].(Role)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAccountRoleForCurrentEnv indicates an expected call of GetAccountRoleForCurrentEnv.
func (mr *MockClientMockRecorder) GetAccountRoleForCurrentEnv(env, roleName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAccountRoleForCurrentEnv", reflect.TypeOf((*MockClient)(nil).GetAccountRoleForCurrentEnv), env, roleName)
}

// GetAccountRoleForCurrentEnvWithPrefix mocks base method.
func (m *MockClient) GetAccountRoleForCurrentEnvWithPrefix(env, rolePrefix string, accountRolesMap map[string]AccountRole) ([]Role, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAccountRoleForCurrentEnvWithPrefix", env, rolePrefix, accountRolesMap)
	ret0, _ := ret[0].([]Role)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAccountRoleForCurrentEnvWithPrefix indicates an expected call of GetAccountRoleForCurrentEnvWithPrefix.
func (mr *MockClientMockRecorder) GetAccountRoleForCurrentEnvWithPrefix(env, rolePrefix, accountRolesMap interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAccountRoleForCurrentEnvWithPrefix", reflect.TypeOf((*MockClient)(nil).GetAccountRoleForCurrentEnvWithPrefix), env, rolePrefix, accountRolesMap)
}

// GetAccountRolePolicies mocks base method.
func (m *MockClient) GetAccountRolePolicies(roles []string) (map[string][]PolicyDetail, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAccountRolePolicies", roles)
	ret0, _ := ret[0].(map[string][]PolicyDetail)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAccountRolePolicies indicates an expected call of GetAccountRolePolicies.
func (mr *MockClientMockRecorder) GetAccountRolePolicies(roles interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAccountRolePolicies", reflect.TypeOf((*MockClient)(nil).GetAccountRolePolicies), roles)
}

// GetAccountRoleVersion mocks base method.
func (m *MockClient) GetAccountRoleVersion(roleName string) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAccountRoleVersion", roleName)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAccountRoleVersion indicates an expected call of GetAccountRoleVersion.
func (mr *MockClientMockRecorder) GetAccountRoleVersion(roleName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAccountRoleVersion", reflect.TypeOf((*MockClient)(nil).GetAccountRoleVersion), roleName)
}

// GetAccountRolesForCurrentEnv mocks base method.
func (m *MockClient) GetAccountRolesForCurrentEnv(env, accountID string) ([]Role, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAccountRolesForCurrentEnv", env, accountID)
	ret0, _ := ret[0].([]Role)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAccountRolesForCurrentEnv indicates an expected call of GetAccountRolesForCurrentEnv.
func (mr *MockClientMockRecorder) GetAccountRolesForCurrentEnv(env, accountID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAccountRolesForCurrentEnv", reflect.TypeOf((*MockClient)(nil).GetAccountRolesForCurrentEnv), env, accountID)
}

// GetAttachedPolicy mocks base method.
func (m *MockClient) GetAttachedPolicy(role *string) ([]PolicyDetail, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAttachedPolicy", role)
	ret0, _ := ret[0].([]PolicyDetail)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAttachedPolicy indicates an expected call of GetAttachedPolicy.
func (mr *MockClientMockRecorder) GetAttachedPolicy(role interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAttachedPolicy", reflect.TypeOf((*MockClient)(nil).GetAttachedPolicy), role)
}

// GetAvailabilityZoneType mocks base method.
func (m *MockClient) GetAvailabilityZoneType(availabilityZoneName string) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAvailabilityZoneType", availabilityZoneName)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAvailabilityZoneType indicates an expected call of GetAvailabilityZoneType.
func (mr *MockClientMockRecorder) GetAvailabilityZoneType(availabilityZoneName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAvailabilityZoneType", reflect.TypeOf((*MockClient)(nil).GetAvailabilityZoneType), availabilityZoneName)
}

// GetClusterRegionTagForUser mocks base method.
func (m *MockClient) GetClusterRegionTagForUser(username string) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetClusterRegionTagForUser", username)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetClusterRegionTagForUser indicates an expected call of GetClusterRegionTagForUser.
func (mr *MockClientMockRecorder) GetClusterRegionTagForUser(username interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetClusterRegionTagForUser", reflect.TypeOf((*MockClient)(nil).GetClusterRegionTagForUser), username)
}

// GetCreator mocks base method.
func (m *MockClient) GetCreator() (*Creator, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetCreator")
	ret0, _ := ret[0].(*Creator)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetDefaultPolicyDocument mocks base method.
func (m *MockClient) GetDefaultPolicyDocument(policyArn string) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetDefaultPolicyDocument", policyArn)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetDefaultPolicyDocument indicates an expected call of GetDefaultPolicyDocument.
func (mr *MockClientMockRecorder) GetDefaultPolicyDocument(policyArn interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDefaultPolicyDocument", reflect.TypeOf((*MockClient)(nil).GetDefaultPolicyDocument), policyArn)
}

// GetIAMCredentials mocks base method.
func (m *MockClient) GetIAMCredentials() (credentials.Value, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetIAMCredentials")
	ret0, _ := ret[0].(credentials.Value)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetInstanceProfilesForRole mocks base method.
func (m *MockClient) GetInstanceProfilesForRole(role string) ([]string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetInstanceProfilesForRole", role)
	ret0, _ := ret[0].([]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetInstanceProfilesForRole indicates an expected call of GetInstanceProfilesForRole.
func (mr *MockClientMockRecorder) GetInstanceProfilesForRole(role interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInstanceProfilesForRole", reflect.TypeOf((*MockClient)(nil).GetInstanceProfilesForRole), role)
}

// GetLocalAWSAccessKeys mocks base method.
func (m *MockClient) GetLocalAWSAccessKeys() (*AccessKey, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetLocalAWSAccessKeys")
	ret0, _ := ret[0].(*AccessKey)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetOpenIDConnectProviderByClusterIdTag mocks base method.
func (m *MockClient) GetOpenIDConnectProviderByClusterIdTag(clusterID string) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetOpenIDConnectProviderByClusterIdTag", clusterID)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetOpenIDConnectProviderByClusterIdTag indicates an expected call of GetOpenIDConnectProviderByClusterIdTag.
func (mr *MockClientMockRecorder) GetOpenIDConnectProviderByClusterIdTag(clusterID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOpenIDConnectProviderByClusterIdTag", reflect.TypeOf((*MockClient)(nil).GetOpenIDConnectProviderByClusterIdTag), clusterID)
}

// GetOpenIDConnectProviderByOidcEndpointUrl mocks base method.
func (m *MockClient) GetOpenIDConnectProviderByOidcEndpointUrl(oidcEndpointUrl string) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetOpenIDConnectProviderByOidcEndpointUrl", oidcEndpointUrl)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetOpenIDConnectProviderByOidcEndpointUrl indicates an expected call of GetOpenIDConnectProviderByOidcEndpointUrl.
func (mr *MockClientMockRecorder) GetOpenIDConnectProviderByOidcEndpointUrl(oidcEndpointUrl interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOpenIDConnectProviderByOidcEndpointUrl", reflect.TypeOf((*MockClient)(nil).GetOpenIDConnectProviderByOidcEndpointUrl), oidcEndpointUrl)
}

// GetOperatorRolesFromAccountByClusterID mocks base method.
func (m *MockClient) GetOperatorRolesFromAccountByClusterID(clusterID string, credRequests map[string]*v1.STSOperator) ([]string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetOperatorRolesFromAccountByClusterID", clusterID, credRequests)
	ret0, _ := ret[0].([]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetOperatorRolesFromAccountByClusterID indicates an expected call of GetOperatorRolesFromAccountByClusterID.
func (mr *MockClientMockRecorder) GetOperatorRolesFromAccountByClusterID(clusterID, credRequests interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOperatorRolesFromAccountByClusterID", reflect.TypeOf((*MockClient)(nil).GetOperatorRolesFromAccountByClusterID), clusterID, credRequests)
}

// GetOperatorRolesFromAccountByPrefix mocks base method.
func (m *MockClient) GetOperatorRolesFromAccountByPrefix(prefix string, credRequest map[string]*v1.STSOperator) ([]string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetOperatorRolesFromAccountByPrefix", prefix, credRequest)
	ret0, _ := ret[0].([]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetOperatorRolesFromAccountByPrefix indicates an expected call of GetOperatorRolesFromAccountByPrefix.
func (mr *MockClientMockRecorder) GetOperatorRolesFromAccountByPrefix(prefix, credRequest interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOperatorRolesFromAccountByPrefix", reflect.TypeOf((*MockClient)(nil).GetOperatorRolesFromAccountByPrefix), prefix, credRequest)
}

// GetPolicies mocks base method.
func (m *MockClient) GetPolicies(roles []string) (map[string][]string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPolicies", roles)
	ret0, _ := ret[0].(map[string][]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetPolicies indicates an expected call of GetPolicies.
func (mr *MockClientMockRecorder) GetPolicies(roles interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPolicies", reflect.TypeOf((*MockClient)(nil).GetPolicies), roles)
}

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

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

// GetRoleARNPath mocks base method.
func (m *MockClient) GetRoleARNPath(prefix string) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRoleARNPath", prefix)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetRoleARNPath indicates an expected call of GetRoleARNPath.
func (mr *MockClientMockRecorder) GetRoleARNPath(prefix interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRoleARNPath", reflect.TypeOf((*MockClient)(nil).GetRoleARNPath), prefix)
}

// GetRoleByARN mocks base method.
func (m *MockClient) GetRoleByARN(roleARN string) (*iam.Role, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRoleByARN", roleARN)
	ret0, _ := ret[0].(*iam.Role)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetRoleByARN indicates an expected call of GetRoleByARN.
func (mr *MockClientMockRecorder) GetRoleByARN(roleARN interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRoleByARN", reflect.TypeOf((*MockClient)(nil).GetRoleByARN), roleARN)
}

// GetSecurityGroupIds mocks base method.
func (m *MockClient) GetSecurityGroupIds(vpcId string) ([]*ec2.SecurityGroup, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSecurityGroupIds", vpcId)
	ret0, _ := ret[0].([]*ec2.SecurityGroup)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetSecurityGroupIds indicates an expected call of GetSecurityGroupIds.
func (mr *MockClientMockRecorder) GetSecurityGroupIds(vpcId interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSecurityGroupIds", reflect.TypeOf((*MockClient)(nil).GetSecurityGroupIds), vpcId)
}

// GetSubnetAvailabilityZone mocks base method.
func (m *MockClient) GetSubnetAvailabilityZone(subnetID string) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSubnetAvailabilityZone", subnetID)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetSubnetAvailabilityZone indicates an expected call of GetSubnetAvailabilityZone.
func (mr *MockClientMockRecorder) GetSubnetAvailabilityZone(subnetID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSubnetAvailabilityZone", reflect.TypeOf((*MockClient)(nil).GetSubnetAvailabilityZone), subnetID)
}

// GetVPCPrivateSubnets mocks base method.
func (m *MockClient) GetVPCPrivateSubnets(subnetID string) ([]*ec2.Subnet, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetVPCPrivateSubnets", subnetID)
	ret0, _ := ret[0].([]*ec2.Subnet)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetVPCPrivateSubnets indicates an expected call of GetVPCPrivateSubnets.
func (mr *MockClientMockRecorder) GetVPCPrivateSubnets(subnetID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVPCPrivateSubnets", reflect.TypeOf((*MockClient)(nil).GetVPCPrivateSubnets), subnetID)
}

// GetVPCSubnets mocks base method.
func (m *MockClient) GetVPCSubnets(subnetID string) ([]*ec2.Subnet, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetVPCSubnets", subnetID)
	ret0, _ := ret[0].([]*ec2.Subnet)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetVPCSubnets indicates an expected call of GetVPCSubnets.
func (mr *MockClientMockRecorder) GetVPCSubnets(subnetID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVPCSubnets", reflect.TypeOf((*MockClient)(nil).GetVPCSubnets), subnetID)
}

// HasHostedCPPolicies mocks base method.
func (m *MockClient) HasHostedCPPolicies(roleARN string) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HasHostedCPPolicies", roleARN)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// HasHostedCPPolicies indicates an expected call of HasHostedCPPolicies.
func (mr *MockClientMockRecorder) HasHostedCPPolicies(roleARN interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HasHostedCPPolicies", reflect.TypeOf((*MockClient)(nil).HasHostedCPPolicies), roleARN)
}

// HasManagedPolicies mocks base method.
func (m *MockClient) HasManagedPolicies(roleARN string) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HasManagedPolicies", roleARN)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// HasManagedPolicies indicates an expected call of HasManagedPolicies.
func (mr *MockClientMockRecorder) HasManagedPolicies(roleARN interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HasManagedPolicies", reflect.TypeOf((*MockClient)(nil).HasManagedPolicies), roleARN)
}

// HasOpenIDConnectProvider mocks base method.
func (m *MockClient) HasOpenIDConnectProvider(issuerURL, accountID string) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HasOpenIDConnectProvider", issuerURL, accountID)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// HasOpenIDConnectProvider indicates an expected call of HasOpenIDConnectProvider.
func (mr *MockClientMockRecorder) HasOpenIDConnectProvider(issuerURL, accountID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HasOpenIDConnectProvider", reflect.TypeOf((*MockClient)(nil).HasOpenIDConnectProvider), issuerURL, accountID)
}

// HasPermissionsBoundary mocks base method.
func (m *MockClient) HasPermissionsBoundary(roleName string) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HasPermissionsBoundary", roleName)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// HasPermissionsBoundary indicates an expected call of HasPermissionsBoundary.
func (mr *MockClientMockRecorder) HasPermissionsBoundary(roleName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HasPermissionsBoundary", reflect.TypeOf((*MockClient)(nil).HasPermissionsBoundary), roleName)
}

// IsAdminRole mocks base method.
func (m *MockClient) IsAdminRole(roleName string) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IsAdminRole", roleName)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// IsAdminRole indicates an expected call of IsAdminRole.
func (mr *MockClientMockRecorder) IsAdminRole(roleName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsAdminRole", reflect.TypeOf((*MockClient)(nil).IsAdminRole), roleName)
}

// IsLocalAvailabilityZone mocks base method.
func (m *MockClient) IsLocalAvailabilityZone(availabilityZoneName string) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IsLocalAvailabilityZone", availabilityZoneName)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// IsLocalAvailabilityZone indicates an expected call of IsLocalAvailabilityZone.
func (mr *MockClientMockRecorder) IsLocalAvailabilityZone(availabilityZoneName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsLocalAvailabilityZone", reflect.TypeOf((*MockClient)(nil).IsLocalAvailabilityZone), availabilityZoneName)
}

// IsPolicyCompatible mocks base method.
func (m *MockClient) IsPolicyCompatible(policyArn, version string) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IsPolicyCompatible", policyArn, version)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// IsPolicyCompatible indicates an expected call of IsPolicyCompatible.
func (mr *MockClientMockRecorder) IsPolicyCompatible(policyArn, version interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsPolicyCompatible", reflect.TypeOf((*MockClient)(nil).IsPolicyCompatible), policyArn, version)
}

// IsPolicyExists mocks base method.
func (m *MockClient) IsPolicyExists(policyARN string) (*iam.GetPolicyOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IsPolicyExists", policyARN)
	ret0, _ := ret[0].(*iam.GetPolicyOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// IsPolicyExists indicates an expected call of IsPolicyExists.
func (mr *MockClientMockRecorder) IsPolicyExists(policyARN interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsPolicyExists", reflect.TypeOf((*MockClient)(nil).IsPolicyExists), policyARN)
}

// IsRolePolicyExists mocks base method.
func (m *MockClient) IsRolePolicyExists(roleName, policyName string) (*iam.GetRolePolicyOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IsRolePolicyExists", roleName, policyName)
	ret0, _ := ret[0].(*iam.GetRolePolicyOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// IsRolePolicyExists indicates an expected call of IsRolePolicyExists.
func (mr *MockClientMockRecorder) IsRolePolicyExists(roleName, policyName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsRolePolicyExists", reflect.TypeOf((*MockClient)(nil).IsRolePolicyExists), roleName, policyName)
}

// IsUpgradedNeededForAccountRolePolicies mocks base method.
func (m *MockClient) IsUpgradedNeededForAccountRolePolicies(rolePrefix, version string) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IsUpgradedNeededForAccountRolePolicies", rolePrefix, version)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// IsUpgradedNeededForAccountRolePolicies indicates an expected call of IsUpgradedNeededForAccountRolePolicies.
func (mr *MockClientMockRecorder) IsUpgradedNeededForAccountRolePolicies(rolePrefix, version interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsUpgradedNeededForAccountRolePolicies", reflect.TypeOf((*MockClient)(nil).IsUpgradedNeededForAccountRolePolicies), rolePrefix, version)
}

// IsUpgradedNeededForAccountRolePoliciesUsingCluster mocks base method.
func (m *MockClient) IsUpgradedNeededForAccountRolePoliciesUsingCluster(clusterID *v1.Cluster, version string) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IsUpgradedNeededForAccountRolePoliciesUsingCluster", clusterID, version)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// IsUpgradedNeededForAccountRolePoliciesUsingCluster indicates an expected call of IsUpgradedNeededForAccountRolePoliciesUsingCluster.
func (mr *MockClientMockRecorder) IsUpgradedNeededForAccountRolePoliciesUsingCluster(clusterID, version interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsUpgradedNeededForAccountRolePoliciesUsingCluster", reflect.TypeOf((*MockClient)(nil).IsUpgradedNeededForAccountRolePoliciesUsingCluster), clusterID, version)
}

// IsUpgradedNeededForOperatorRolePoliciesUsingCluster mocks base method.
func (m *MockClient) IsUpgradedNeededForOperatorRolePoliciesUsingCluster(cluster *v1.Cluster, accountID, version string, credRequests map[string]*v1.STSOperator, operatorRolePolicyPrefix string) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IsUpgradedNeededForOperatorRolePoliciesUsingCluster", cluster, accountID, version, credRequests, operatorRolePolicyPrefix)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// IsUpgradedNeededForOperatorRolePoliciesUsingCluster indicates an expected call of IsUpgradedNeededForOperatorRolePoliciesUsingCluster.
func (mr *MockClientMockRecorder) IsUpgradedNeededForOperatorRolePoliciesUsingCluster(cluster, accountID, version, credRequests, operatorRolePolicyPrefix interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsUpgradedNeededForOperatorRolePoliciesUsingCluster", reflect.TypeOf((*MockClient)(nil).IsUpgradedNeededForOperatorRolePoliciesUsingCluster), cluster, accountID, version, credRequests, operatorRolePolicyPrefix)
}

// IsUpgradedNeededForOperatorRolePoliciesUsingPrefix mocks base method.
func (m *MockClient) IsUpgradedNeededForOperatorRolePoliciesUsingPrefix(rolePrefix, accountID, version string, credRequests map[string]*v1.STSOperator, path string) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IsUpgradedNeededForOperatorRolePoliciesUsingPrefix", rolePrefix, accountID, version, credRequests, path)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// IsUpgradedNeededForOperatorRolePoliciesUsingPrefix indicates an expected call of IsUpgradedNeededForOperatorRolePoliciesUsingPrefix.
func (mr *MockClientMockRecorder) IsUpgradedNeededForOperatorRolePoliciesUsingPrefix(rolePrefix, accountID, version, credRequests, path interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsUpgradedNeededForOperatorRolePoliciesUsingPrefix", reflect.TypeOf((*MockClient)(nil).IsUpgradedNeededForOperatorRolePoliciesUsingPrefix), rolePrefix, accountID, version, credRequests, path)
}

// IsUserRole mocks base method.
func (m *MockClient) IsUserRole(roleName *string) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IsUserRole", roleName)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// IsUserRole indicates an expected call of IsUserRole.
func (mr *MockClientMockRecorder) IsUserRole(roleName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsUserRole", reflect.TypeOf((*MockClient)(nil).IsUserRole), roleName)
}

// ListAccountRoles mocks base method.
func (m *MockClient) ListAccountRoles(version string) ([]Role, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListAccountRoles", version)
	ret0, _ := ret[0].([]Role)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListAccountRoles indicates an expected call of ListAccountRoles.
func (mr *MockClientMockRecorder) ListAccountRoles(version interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAccountRoles", reflect.TypeOf((*MockClient)(nil).ListAccountRoles), version)
}

// ListOCMRoles mocks base method.
func (m *MockClient) ListOCMRoles() ([]Role, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListOCMRoles")
	ret0, _ := ret[0].([]Role)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListOidcProviders mocks base method.
func (m *MockClient) ListOidcProviders(targetClusterId string, config *v1.OidcConfig) ([]OidcProviderOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListOidcProviders", targetClusterId, config)
	ret0, _ := ret[0].([]OidcProviderOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListOidcProviders indicates an expected call of ListOidcProviders.
func (mr *MockClientMockRecorder) ListOidcProviders(targetClusterId, config interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListOidcProviders", reflect.TypeOf((*MockClient)(nil).ListOidcProviders), targetClusterId, config)
}

// ListOperatorRoles mocks base method.
func (m *MockClient) ListOperatorRoles(version, clusterID string) (map[string][]OperatorRoleDetail, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListOperatorRoles", version, clusterID)
	ret0, _ := ret[0].(map[string][]OperatorRoleDetail)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListOperatorRoles indicates an expected call of ListOperatorRoles.
func (mr *MockClientMockRecorder) ListOperatorRoles(version, clusterID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListOperatorRoles", reflect.TypeOf((*MockClient)(nil).ListOperatorRoles), version, clusterID)
}

// ListSubnets mocks base method.
func (m *MockClient) ListSubnets(subnetIds ...string) ([]*ec2.Subnet, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{}
	for _, a := range subnetIds {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListSubnets", varargs...)
	ret0, _ := ret[0].([]*ec2.Subnet)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListSubnets indicates an expected call of ListSubnets.
func (mr *MockClientMockRecorder) ListSubnets(subnetIds ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListSubnets", reflect.TypeOf((*MockClient)(nil).ListSubnets), subnetIds...)
}

// ListUserRoles mocks base method.
func (m *MockClient) ListUserRoles() ([]Role, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListUserRoles")
	ret0, _ := ret[0].([]Role)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// PutPublicReadObjectInS3Bucket mocks base method.
func (m *MockClient) PutPublicReadObjectInS3Bucket(bucketName string, body io.ReadSeeker, key string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutPublicReadObjectInS3Bucket", bucketName, body, key)
	ret0, _ := ret[0].(error)
	return ret0
}

// PutPublicReadObjectInS3Bucket indicates an expected call of PutPublicReadObjectInS3Bucket.
func (mr *MockClientMockRecorder) PutPublicReadObjectInS3Bucket(bucketName, body, key interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutPublicReadObjectInS3Bucket", reflect.TypeOf((*MockClient)(nil).PutPublicReadObjectInS3Bucket), bucketName, body, key)
}

// PutRolePolicy mocks base method.
func (m *MockClient) PutRolePolicy(roleName, policyName, policy string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutRolePolicy", roleName, policyName, policy)
	ret0, _ := ret[0].(error)
	return ret0
}

// PutRolePolicy indicates an expected call of PutRolePolicy.
func (mr *MockClientMockRecorder) PutRolePolicy(roleName, policyName, policy interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutRolePolicy", reflect.TypeOf((*MockClient)(nil).PutRolePolicy), roleName, policyName, policy)
}

// TagUserRegion mocks base method.
func (m *MockClient) TagUserRegion(username, region string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TagUserRegion", username, region)
	ret0, _ := ret[0].(error)
	return ret0
}

// TagUserRegion indicates an expected call of TagUserRegion.
func (mr *MockClientMockRecorder) TagUserRegion(username, region interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TagUserRegion", reflect.TypeOf((*MockClient)(nil).TagUserRegion), username, region)
}

// UpdateTag mocks base method.
func (m *MockClient) UpdateTag(roleName, defaultPolicyVersion string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateTag", roleName, defaultPolicyVersion)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateTag indicates an expected call of UpdateTag.
func (mr *MockClientMockRecorder) UpdateTag(roleName, defaultPolicyVersion interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTag", reflect.TypeOf((*MockClient)(nil).UpdateTag), roleName, defaultPolicyVersion)
}

// ValidateAccountRoleVersionCompatibility mocks base method.
func (m *MockClient) ValidateAccountRoleVersionCompatibility(roleName, roleType, minVersion string) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ValidateAccountRoleVersionCompatibility", roleName, roleType, minVersion)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ValidateAccountRoleVersionCompatibility indicates an expected call of ValidateAccountRoleVersionCompatibility.
func (mr *MockClientMockRecorder) ValidateAccountRoleVersionCompatibility(roleName, roleType, minVersion interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValidateAccountRoleVersionCompatibility", reflect.TypeOf((*MockClient)(nil).ValidateAccountRoleVersionCompatibility), roleName, roleType, minVersion)
}

// ValidateAccountRolesManagedPolicies mocks base method.
func (m *MockClient) ValidateAccountRolesManagedPolicies(prefix string, policies map[string]*v1.AWSSTSPolicy) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ValidateAccountRolesManagedPolicies", prefix, policies)
	ret0, _ := ret[0].(error)
	return ret0
}

// ValidateAccountRolesManagedPolicies indicates an expected call of ValidateAccountRolesManagedPolicies.
func (mr *MockClientMockRecorder) ValidateAccountRolesManagedPolicies(prefix, policies interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValidateAccountRolesManagedPolicies", reflect.TypeOf((*MockClient)(nil).ValidateAccountRolesManagedPolicies), prefix, policies)
}

// ValidateCredentials mocks base method.
func (m *MockClient) ValidateCredentials() (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ValidateCredentials")
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ValidateHCPAccountRolesManagedPolicies mocks base method.
func (m *MockClient) ValidateHCPAccountRolesManagedPolicies(prefix string, policies map[string]*v1.AWSSTSPolicy) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ValidateHCPAccountRolesManagedPolicies", prefix, policies)
	ret0, _ := ret[0].(error)
	return ret0
}

// ValidateHCPAccountRolesManagedPolicies indicates an expected call of ValidateHCPAccountRolesManagedPolicies.
func (mr *MockClientMockRecorder) ValidateHCPAccountRolesManagedPolicies(prefix, policies interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValidateHCPAccountRolesManagedPolicies", reflect.TypeOf((*MockClient)(nil).ValidateHCPAccountRolesManagedPolicies), prefix, policies)
}

// ValidateOperatorRolesManagedPolicies mocks base method.
func (m *MockClient) ValidateOperatorRolesManagedPolicies(cluster *v1.Cluster, operatorRoles map[string]*v1.STSOperator, policies map[string]*v1.AWSSTSPolicy, hostedCPPolicies bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ValidateOperatorRolesManagedPolicies", cluster, operatorRoles, policies, hostedCPPolicies)
	ret0, _ := ret[0].(error)
	return ret0
}

// ValidateOperatorRolesManagedPolicies indicates an expected call of ValidateOperatorRolesManagedPolicies.
func (mr *MockClientMockRecorder) ValidateOperatorRolesManagedPolicies(cluster, operatorRoles, policies, hostedCPPolicies interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValidateOperatorRolesManagedPolicies", reflect.TypeOf((*MockClient)(nil).ValidateOperatorRolesManagedPolicies), cluster, operatorRoles, policies, hostedCPPolicies)
}

// ValidateQuota mocks base method.
func (m *MockClient) ValidateQuota() (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ValidateQuota")
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ValidateRoleARNAccountIDMatchCallerAccountID mocks base method.
func (m *MockClient) ValidateRoleARNAccountIDMatchCallerAccountID(roleARN string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ValidateRoleARNAccountIDMatchCallerAccountID", roleARN)
	ret0, _ := ret[0].(error)
	return ret0
}

// ValidateRoleARNAccountIDMatchCallerAccountID indicates an expected call of ValidateRoleARNAccountIDMatchCallerAccountID.
func (mr *MockClientMockRecorder) ValidateRoleARNAccountIDMatchCallerAccountID(roleARN interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValidateRoleARNAccountIDMatchCallerAccountID", reflect.TypeOf((*MockClient)(nil).ValidateRoleARNAccountIDMatchCallerAccountID), roleARN)
}

// ValidateRoleNameAvailable mocks base method.
func (m *MockClient) ValidateRoleNameAvailable(name string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ValidateRoleNameAvailable", name)
	ret0, _ := ret[0].(error)
	return ret0
}

// ValidateRoleNameAvailable indicates an expected call of ValidateRoleNameAvailable.
func (mr *MockClientMockRecorder) ValidateRoleNameAvailable(name interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValidateRoleNameAvailable", reflect.TypeOf((*MockClient)(nil).ValidateRoleNameAvailable), name)
}

// ValidateSCP mocks base method.
func (m *MockClient) ValidateSCP(arg0 *string, arg1 map[string]*v1.AWSSTSPolicy) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ValidateSCP", arg0, arg1)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// MockAccessKeyGetter is a mock of AccessKeyGetter interface.
type MockAccessKeyGetter struct {
	ctrl     *gomock.Controller
	recorder *MockAccessKeyGetterMockRecorder
}

// MockAccessKeyGetterMockRecorder is the mock recorder for MockAccessKeyGetter.
type MockAccessKeyGetterMockRecorder struct {
	mock *MockAccessKeyGetter
}

// NewMockAccessKeyGetter creates a new mock instance.
func NewMockAccessKeyGetter(ctrl *gomock.Controller) *MockAccessKeyGetter {
	mock := &MockAccessKeyGetter{ctrl: ctrl}
	mock.recorder = &MockAccessKeyGetterMockRecorder{mock}
	return mock
}

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

// GetAWSAccessKeys mocks base method.
func (m *MockAccessKeyGetter) GetAWSAccessKeys() (*AccessKey, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAWSAccessKeys")
	ret0, _ := ret[0].(*AccessKey)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetLocalAWSAccessKeys mocks base method.
func (m *MockAccessKeyGetter) GetLocalAWSAccessKeys() (*AccessKey, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetLocalAWSAccessKeys")
	ret0, _ := ret[0].(*AccessKey)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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