mock_client.go

// Licensed to Elasticsearch B.V. under one or more contributor
// license agreements. See the NOTICE file distributed with
// this work for additional information regarding copyright
// ownership. Elasticsearch B.V. licenses this file to you under
// the Apache License, Version 2.0 (the "License"); you may
// not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing,
// software distributed under the License is distributed on an
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied.  See the License for the
// specific language governing permissions and limitations
// under the License.

// Code generated by mockery v2.37.1. DO NOT EDIT.

package iam

import (
	context "context"

	serviceiam "github.com/aws/aws-sdk-go-v2/service/iam"
	mock "github.com/stretchr/testify/mock"
)

// MockClient is an autogenerated mock type for the Client type
type MockClient struct {
	mock.Mock
}

type MockClient_Expecter struct {
	mock *mock.Mock
}

func (_m *MockClient) EXPECT() *MockClient_Expecter {
	return &MockClient_Expecter{mock: &_m.Mock}
}

// GenerateCredentialReport provides a mock function with given fields: ctx, params, optFns
func (_m *MockClient) GenerateCredentialReport(ctx context.Context, params *serviceiam.GenerateCredentialReportInput, optFns ...func(*serviceiam.Options)) (*serviceiam.GenerateCredentialReportOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *serviceiam.GenerateCredentialReportOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *serviceiam.GenerateCredentialReportInput, ...func(*serviceiam.Options)) (*serviceiam.GenerateCredentialReportOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *serviceiam.GenerateCredentialReportInput, ...func(*serviceiam.Options)) *serviceiam.GenerateCredentialReportOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*serviceiam.GenerateCredentialReportOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *serviceiam.GenerateCredentialReportInput, ...func(*serviceiam.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockClient_GenerateCredentialReport_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GenerateCredentialReport'
type MockClient_GenerateCredentialReport_Call struct {
	*mock.Call
}

// GenerateCredentialReport is a helper method to define mock.On call
//   - ctx context.Context
//   - params *serviceiam.GenerateCredentialReportInput
//   - optFns ...func(*serviceiam.Options)
func (_e *MockClient_Expecter) GenerateCredentialReport(ctx interface{}, params interface{}, optFns ...interface{}) *MockClient_GenerateCredentialReport_Call {
	return &MockClient_GenerateCredentialReport_Call{Call: _e.mock.On("GenerateCredentialReport",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *MockClient_GenerateCredentialReport_Call) Run(run func(ctx context.Context, params *serviceiam.GenerateCredentialReportInput, optFns ...func(*serviceiam.Options))) *MockClient_GenerateCredentialReport_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*serviceiam.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*serviceiam.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*serviceiam.GenerateCredentialReportInput), variadicArgs...)
	})
	return _c
}

func (_c *MockClient_GenerateCredentialReport_Call) Return(_a0 *serviceiam.GenerateCredentialReportOutput, _a1 error) *MockClient_GenerateCredentialReport_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClient_GenerateCredentialReport_Call) RunAndReturn(run func(context.Context, *serviceiam.GenerateCredentialReportInput, ...func(*serviceiam.Options)) (*serviceiam.GenerateCredentialReportOutput, error)) *MockClient_GenerateCredentialReport_Call {
	_c.Call.Return(run)
	return _c
}

// GetAccessKeyLastUsed provides a mock function with given fields: ctx, params, optFns
func (_m *MockClient) GetAccessKeyLastUsed(ctx context.Context, params *serviceiam.GetAccessKeyLastUsedInput, optFns ...func(*serviceiam.Options)) (*serviceiam.GetAccessKeyLastUsedOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *serviceiam.GetAccessKeyLastUsedOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *serviceiam.GetAccessKeyLastUsedInput, ...func(*serviceiam.Options)) (*serviceiam.GetAccessKeyLastUsedOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *serviceiam.GetAccessKeyLastUsedInput, ...func(*serviceiam.Options)) *serviceiam.GetAccessKeyLastUsedOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*serviceiam.GetAccessKeyLastUsedOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *serviceiam.GetAccessKeyLastUsedInput, ...func(*serviceiam.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockClient_GetAccessKeyLastUsed_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAccessKeyLastUsed'
type MockClient_GetAccessKeyLastUsed_Call struct {
	*mock.Call
}

// GetAccessKeyLastUsed is a helper method to define mock.On call
//   - ctx context.Context
//   - params *serviceiam.GetAccessKeyLastUsedInput
//   - optFns ...func(*serviceiam.Options)
func (_e *MockClient_Expecter) GetAccessKeyLastUsed(ctx interface{}, params interface{}, optFns ...interface{}) *MockClient_GetAccessKeyLastUsed_Call {
	return &MockClient_GetAccessKeyLastUsed_Call{Call: _e.mock.On("GetAccessKeyLastUsed",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *MockClient_GetAccessKeyLastUsed_Call) Run(run func(ctx context.Context, params *serviceiam.GetAccessKeyLastUsedInput, optFns ...func(*serviceiam.Options))) *MockClient_GetAccessKeyLastUsed_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*serviceiam.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*serviceiam.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*serviceiam.GetAccessKeyLastUsedInput), variadicArgs...)
	})
	return _c
}

func (_c *MockClient_GetAccessKeyLastUsed_Call) Return(_a0 *serviceiam.GetAccessKeyLastUsedOutput, _a1 error) *MockClient_GetAccessKeyLastUsed_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClient_GetAccessKeyLastUsed_Call) RunAndReturn(run func(context.Context, *serviceiam.GetAccessKeyLastUsedInput, ...func(*serviceiam.Options)) (*serviceiam.GetAccessKeyLastUsedOutput, error)) *MockClient_GetAccessKeyLastUsed_Call {
	_c.Call.Return(run)
	return _c
}

// GetAccountPasswordPolicy provides a mock function with given fields: ctx, params, optFns
func (_m *MockClient) GetAccountPasswordPolicy(ctx context.Context, params *serviceiam.GetAccountPasswordPolicyInput, optFns ...func(*serviceiam.Options)) (*serviceiam.GetAccountPasswordPolicyOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *serviceiam.GetAccountPasswordPolicyOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *serviceiam.GetAccountPasswordPolicyInput, ...func(*serviceiam.Options)) (*serviceiam.GetAccountPasswordPolicyOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *serviceiam.GetAccountPasswordPolicyInput, ...func(*serviceiam.Options)) *serviceiam.GetAccountPasswordPolicyOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*serviceiam.GetAccountPasswordPolicyOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *serviceiam.GetAccountPasswordPolicyInput, ...func(*serviceiam.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockClient_GetAccountPasswordPolicy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAccountPasswordPolicy'
type MockClient_GetAccountPasswordPolicy_Call struct {
	*mock.Call
}

// GetAccountPasswordPolicy is a helper method to define mock.On call
//   - ctx context.Context
//   - params *serviceiam.GetAccountPasswordPolicyInput
//   - optFns ...func(*serviceiam.Options)
func (_e *MockClient_Expecter) GetAccountPasswordPolicy(ctx interface{}, params interface{}, optFns ...interface{}) *MockClient_GetAccountPasswordPolicy_Call {
	return &MockClient_GetAccountPasswordPolicy_Call{Call: _e.mock.On("GetAccountPasswordPolicy",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *MockClient_GetAccountPasswordPolicy_Call) Run(run func(ctx context.Context, params *serviceiam.GetAccountPasswordPolicyInput, optFns ...func(*serviceiam.Options))) *MockClient_GetAccountPasswordPolicy_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*serviceiam.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*serviceiam.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*serviceiam.GetAccountPasswordPolicyInput), variadicArgs...)
	})
	return _c
}

func (_c *MockClient_GetAccountPasswordPolicy_Call) Return(_a0 *serviceiam.GetAccountPasswordPolicyOutput, _a1 error) *MockClient_GetAccountPasswordPolicy_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClient_GetAccountPasswordPolicy_Call) RunAndReturn(run func(context.Context, *serviceiam.GetAccountPasswordPolicyInput, ...func(*serviceiam.Options)) (*serviceiam.GetAccountPasswordPolicyOutput, error)) *MockClient_GetAccountPasswordPolicy_Call {
	_c.Call.Return(run)
	return _c
}

// GetCredentialReport provides a mock function with given fields: ctx, params, optFns
func (_m *MockClient) GetCredentialReport(ctx context.Context, params *serviceiam.GetCredentialReportInput, optFns ...func(*serviceiam.Options)) (*serviceiam.GetCredentialReportOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *serviceiam.GetCredentialReportOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *serviceiam.GetCredentialReportInput, ...func(*serviceiam.Options)) (*serviceiam.GetCredentialReportOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *serviceiam.GetCredentialReportInput, ...func(*serviceiam.Options)) *serviceiam.GetCredentialReportOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*serviceiam.GetCredentialReportOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *serviceiam.GetCredentialReportInput, ...func(*serviceiam.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockClient_GetCredentialReport_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetCredentialReport'
type MockClient_GetCredentialReport_Call struct {
	*mock.Call
}

// GetCredentialReport is a helper method to define mock.On call
//   - ctx context.Context
//   - params *serviceiam.GetCredentialReportInput
//   - optFns ...func(*serviceiam.Options)
func (_e *MockClient_Expecter) GetCredentialReport(ctx interface{}, params interface{}, optFns ...interface{}) *MockClient_GetCredentialReport_Call {
	return &MockClient_GetCredentialReport_Call{Call: _e.mock.On("GetCredentialReport",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *MockClient_GetCredentialReport_Call) Run(run func(ctx context.Context, params *serviceiam.GetCredentialReportInput, optFns ...func(*serviceiam.Options))) *MockClient_GetCredentialReport_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*serviceiam.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*serviceiam.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*serviceiam.GetCredentialReportInput), variadicArgs...)
	})
	return _c
}

func (_c *MockClient_GetCredentialReport_Call) Return(_a0 *serviceiam.GetCredentialReportOutput, _a1 error) *MockClient_GetCredentialReport_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClient_GetCredentialReport_Call) RunAndReturn(run func(context.Context, *serviceiam.GetCredentialReportInput, ...func(*serviceiam.Options)) (*serviceiam.GetCredentialReportOutput, error)) *MockClient_GetCredentialReport_Call {
	_c.Call.Return(run)
	return _c
}

// GetPolicy provides a mock function with given fields: ctx, params, optFns
func (_m *MockClient) GetPolicy(ctx context.Context, params *serviceiam.GetPolicyInput, optFns ...func(*serviceiam.Options)) (*serviceiam.GetPolicyOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *serviceiam.GetPolicyOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *serviceiam.GetPolicyInput, ...func(*serviceiam.Options)) (*serviceiam.GetPolicyOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *serviceiam.GetPolicyInput, ...func(*serviceiam.Options)) *serviceiam.GetPolicyOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*serviceiam.GetPolicyOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *serviceiam.GetPolicyInput, ...func(*serviceiam.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockClient_GetPolicy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPolicy'
type MockClient_GetPolicy_Call struct {
	*mock.Call
}

// GetPolicy is a helper method to define mock.On call
//   - ctx context.Context
//   - params *serviceiam.GetPolicyInput
//   - optFns ...func(*serviceiam.Options)
func (_e *MockClient_Expecter) GetPolicy(ctx interface{}, params interface{}, optFns ...interface{}) *MockClient_GetPolicy_Call {
	return &MockClient_GetPolicy_Call{Call: _e.mock.On("GetPolicy",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *MockClient_GetPolicy_Call) Run(run func(ctx context.Context, params *serviceiam.GetPolicyInput, optFns ...func(*serviceiam.Options))) *MockClient_GetPolicy_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*serviceiam.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*serviceiam.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*serviceiam.GetPolicyInput), variadicArgs...)
	})
	return _c
}

func (_c *MockClient_GetPolicy_Call) Return(_a0 *serviceiam.GetPolicyOutput, _a1 error) *MockClient_GetPolicy_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClient_GetPolicy_Call) RunAndReturn(run func(context.Context, *serviceiam.GetPolicyInput, ...func(*serviceiam.Options)) (*serviceiam.GetPolicyOutput, error)) *MockClient_GetPolicy_Call {
	_c.Call.Return(run)
	return _c
}

// GetPolicyVersion provides a mock function with given fields: ctx, params, optFns
func (_m *MockClient) GetPolicyVersion(ctx context.Context, params *serviceiam.GetPolicyVersionInput, optFns ...func(*serviceiam.Options)) (*serviceiam.GetPolicyVersionOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *serviceiam.GetPolicyVersionOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *serviceiam.GetPolicyVersionInput, ...func(*serviceiam.Options)) (*serviceiam.GetPolicyVersionOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *serviceiam.GetPolicyVersionInput, ...func(*serviceiam.Options)) *serviceiam.GetPolicyVersionOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*serviceiam.GetPolicyVersionOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *serviceiam.GetPolicyVersionInput, ...func(*serviceiam.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockClient_GetPolicyVersion_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPolicyVersion'
type MockClient_GetPolicyVersion_Call struct {
	*mock.Call
}

// GetPolicyVersion is a helper method to define mock.On call
//   - ctx context.Context
//   - params *serviceiam.GetPolicyVersionInput
//   - optFns ...func(*serviceiam.Options)
func (_e *MockClient_Expecter) GetPolicyVersion(ctx interface{}, params interface{}, optFns ...interface{}) *MockClient_GetPolicyVersion_Call {
	return &MockClient_GetPolicyVersion_Call{Call: _e.mock.On("GetPolicyVersion",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *MockClient_GetPolicyVersion_Call) Run(run func(ctx context.Context, params *serviceiam.GetPolicyVersionInput, optFns ...func(*serviceiam.Options))) *MockClient_GetPolicyVersion_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*serviceiam.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*serviceiam.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*serviceiam.GetPolicyVersionInput), variadicArgs...)
	})
	return _c
}

func (_c *MockClient_GetPolicyVersion_Call) Return(_a0 *serviceiam.GetPolicyVersionOutput, _a1 error) *MockClient_GetPolicyVersion_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClient_GetPolicyVersion_Call) RunAndReturn(run func(context.Context, *serviceiam.GetPolicyVersionInput, ...func(*serviceiam.Options)) (*serviceiam.GetPolicyVersionOutput, error)) *MockClient_GetPolicyVersion_Call {
	_c.Call.Return(run)
	return _c
}

// GetRole provides a mock function with given fields: ctx, params, optFns
func (_m *MockClient) GetRole(ctx context.Context, params *serviceiam.GetRoleInput, optFns ...func(*serviceiam.Options)) (*serviceiam.GetRoleOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *serviceiam.GetRoleOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *serviceiam.GetRoleInput, ...func(*serviceiam.Options)) (*serviceiam.GetRoleOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *serviceiam.GetRoleInput, ...func(*serviceiam.Options)) *serviceiam.GetRoleOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*serviceiam.GetRoleOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *serviceiam.GetRoleInput, ...func(*serviceiam.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockClient_GetRole_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRole'
type MockClient_GetRole_Call struct {
	*mock.Call
}

// GetRole is a helper method to define mock.On call
//   - ctx context.Context
//   - params *serviceiam.GetRoleInput
//   - optFns ...func(*serviceiam.Options)
func (_e *MockClient_Expecter) GetRole(ctx interface{}, params interface{}, optFns ...interface{}) *MockClient_GetRole_Call {
	return &MockClient_GetRole_Call{Call: _e.mock.On("GetRole",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *MockClient_GetRole_Call) Run(run func(ctx context.Context, params *serviceiam.GetRoleInput, optFns ...func(*serviceiam.Options))) *MockClient_GetRole_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*serviceiam.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*serviceiam.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*serviceiam.GetRoleInput), variadicArgs...)
	})
	return _c
}

func (_c *MockClient_GetRole_Call) Return(_a0 *serviceiam.GetRoleOutput, _a1 error) *MockClient_GetRole_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClient_GetRole_Call) RunAndReturn(run func(context.Context, *serviceiam.GetRoleInput, ...func(*serviceiam.Options)) (*serviceiam.GetRoleOutput, error)) *MockClient_GetRole_Call {
	_c.Call.Return(run)
	return _c
}

// GetRolePolicy provides a mock function with given fields: ctx, params, optFns
func (_m *MockClient) GetRolePolicy(ctx context.Context, params *serviceiam.GetRolePolicyInput, optFns ...func(*serviceiam.Options)) (*serviceiam.GetRolePolicyOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *serviceiam.GetRolePolicyOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *serviceiam.GetRolePolicyInput, ...func(*serviceiam.Options)) (*serviceiam.GetRolePolicyOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *serviceiam.GetRolePolicyInput, ...func(*serviceiam.Options)) *serviceiam.GetRolePolicyOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*serviceiam.GetRolePolicyOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *serviceiam.GetRolePolicyInput, ...func(*serviceiam.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockClient_GetRolePolicy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRolePolicy'
type MockClient_GetRolePolicy_Call struct {
	*mock.Call
}

// GetRolePolicy is a helper method to define mock.On call
//   - ctx context.Context
//   - params *serviceiam.GetRolePolicyInput
//   - optFns ...func(*serviceiam.Options)
func (_e *MockClient_Expecter) GetRolePolicy(ctx interface{}, params interface{}, optFns ...interface{}) *MockClient_GetRolePolicy_Call {
	return &MockClient_GetRolePolicy_Call{Call: _e.mock.On("GetRolePolicy",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *MockClient_GetRolePolicy_Call) Run(run func(ctx context.Context, params *serviceiam.GetRolePolicyInput, optFns ...func(*serviceiam.Options))) *MockClient_GetRolePolicy_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*serviceiam.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*serviceiam.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*serviceiam.GetRolePolicyInput), variadicArgs...)
	})
	return _c
}

func (_c *MockClient_GetRolePolicy_Call) Return(_a0 *serviceiam.GetRolePolicyOutput, _a1 error) *MockClient_GetRolePolicy_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClient_GetRolePolicy_Call) RunAndReturn(run func(context.Context, *serviceiam.GetRolePolicyInput, ...func(*serviceiam.Options)) (*serviceiam.GetRolePolicyOutput, error)) *MockClient_GetRolePolicy_Call {
	_c.Call.Return(run)
	return _c
}

// GetUserPolicy provides a mock function with given fields: ctx, params, optFns
func (_m *MockClient) GetUserPolicy(ctx context.Context, params *serviceiam.GetUserPolicyInput, optFns ...func(*serviceiam.Options)) (*serviceiam.GetUserPolicyOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *serviceiam.GetUserPolicyOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *serviceiam.GetUserPolicyInput, ...func(*serviceiam.Options)) (*serviceiam.GetUserPolicyOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *serviceiam.GetUserPolicyInput, ...func(*serviceiam.Options)) *serviceiam.GetUserPolicyOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*serviceiam.GetUserPolicyOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *serviceiam.GetUserPolicyInput, ...func(*serviceiam.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockClient_GetUserPolicy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetUserPolicy'
type MockClient_GetUserPolicy_Call struct {
	*mock.Call
}

// GetUserPolicy is a helper method to define mock.On call
//   - ctx context.Context
//   - params *serviceiam.GetUserPolicyInput
//   - optFns ...func(*serviceiam.Options)
func (_e *MockClient_Expecter) GetUserPolicy(ctx interface{}, params interface{}, optFns ...interface{}) *MockClient_GetUserPolicy_Call {
	return &MockClient_GetUserPolicy_Call{Call: _e.mock.On("GetUserPolicy",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *MockClient_GetUserPolicy_Call) Run(run func(ctx context.Context, params *serviceiam.GetUserPolicyInput, optFns ...func(*serviceiam.Options))) *MockClient_GetUserPolicy_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*serviceiam.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*serviceiam.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*serviceiam.GetUserPolicyInput), variadicArgs...)
	})
	return _c
}

func (_c *MockClient_GetUserPolicy_Call) Return(_a0 *serviceiam.GetUserPolicyOutput, _a1 error) *MockClient_GetUserPolicy_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClient_GetUserPolicy_Call) RunAndReturn(run func(context.Context, *serviceiam.GetUserPolicyInput, ...func(*serviceiam.Options)) (*serviceiam.GetUserPolicyOutput, error)) *MockClient_GetUserPolicy_Call {
	_c.Call.Return(run)
	return _c
}

// ListAccessKeys provides a mock function with given fields: ctx, params, optFns
func (_m *MockClient) ListAccessKeys(ctx context.Context, params *serviceiam.ListAccessKeysInput, optFns ...func(*serviceiam.Options)) (*serviceiam.ListAccessKeysOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *serviceiam.ListAccessKeysOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *serviceiam.ListAccessKeysInput, ...func(*serviceiam.Options)) (*serviceiam.ListAccessKeysOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *serviceiam.ListAccessKeysInput, ...func(*serviceiam.Options)) *serviceiam.ListAccessKeysOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*serviceiam.ListAccessKeysOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *serviceiam.ListAccessKeysInput, ...func(*serviceiam.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockClient_ListAccessKeys_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListAccessKeys'
type MockClient_ListAccessKeys_Call struct {
	*mock.Call
}

// ListAccessKeys is a helper method to define mock.On call
//   - ctx context.Context
//   - params *serviceiam.ListAccessKeysInput
//   - optFns ...func(*serviceiam.Options)
func (_e *MockClient_Expecter) ListAccessKeys(ctx interface{}, params interface{}, optFns ...interface{}) *MockClient_ListAccessKeys_Call {
	return &MockClient_ListAccessKeys_Call{Call: _e.mock.On("ListAccessKeys",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *MockClient_ListAccessKeys_Call) Run(run func(ctx context.Context, params *serviceiam.ListAccessKeysInput, optFns ...func(*serviceiam.Options))) *MockClient_ListAccessKeys_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*serviceiam.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*serviceiam.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*serviceiam.ListAccessKeysInput), variadicArgs...)
	})
	return _c
}

func (_c *MockClient_ListAccessKeys_Call) Return(_a0 *serviceiam.ListAccessKeysOutput, _a1 error) *MockClient_ListAccessKeys_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClient_ListAccessKeys_Call) RunAndReturn(run func(context.Context, *serviceiam.ListAccessKeysInput, ...func(*serviceiam.Options)) (*serviceiam.ListAccessKeysOutput, error)) *MockClient_ListAccessKeys_Call {
	_c.Call.Return(run)
	return _c
}

// ListAttachedRolePolicies provides a mock function with given fields: ctx, params, optFns
func (_m *MockClient) ListAttachedRolePolicies(ctx context.Context, params *serviceiam.ListAttachedRolePoliciesInput, optFns ...func(*serviceiam.Options)) (*serviceiam.ListAttachedRolePoliciesOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *serviceiam.ListAttachedRolePoliciesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *serviceiam.ListAttachedRolePoliciesInput, ...func(*serviceiam.Options)) (*serviceiam.ListAttachedRolePoliciesOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *serviceiam.ListAttachedRolePoliciesInput, ...func(*serviceiam.Options)) *serviceiam.ListAttachedRolePoliciesOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*serviceiam.ListAttachedRolePoliciesOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *serviceiam.ListAttachedRolePoliciesInput, ...func(*serviceiam.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockClient_ListAttachedRolePolicies_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListAttachedRolePolicies'
type MockClient_ListAttachedRolePolicies_Call struct {
	*mock.Call
}

// ListAttachedRolePolicies is a helper method to define mock.On call
//   - ctx context.Context
//   - params *serviceiam.ListAttachedRolePoliciesInput
//   - optFns ...func(*serviceiam.Options)
func (_e *MockClient_Expecter) ListAttachedRolePolicies(ctx interface{}, params interface{}, optFns ...interface{}) *MockClient_ListAttachedRolePolicies_Call {
	return &MockClient_ListAttachedRolePolicies_Call{Call: _e.mock.On("ListAttachedRolePolicies",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *MockClient_ListAttachedRolePolicies_Call) Run(run func(ctx context.Context, params *serviceiam.ListAttachedRolePoliciesInput, optFns ...func(*serviceiam.Options))) *MockClient_ListAttachedRolePolicies_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*serviceiam.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*serviceiam.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*serviceiam.ListAttachedRolePoliciesInput), variadicArgs...)
	})
	return _c
}

func (_c *MockClient_ListAttachedRolePolicies_Call) Return(_a0 *serviceiam.ListAttachedRolePoliciesOutput, _a1 error) *MockClient_ListAttachedRolePolicies_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClient_ListAttachedRolePolicies_Call) RunAndReturn(run func(context.Context, *serviceiam.ListAttachedRolePoliciesInput, ...func(*serviceiam.Options)) (*serviceiam.ListAttachedRolePoliciesOutput, error)) *MockClient_ListAttachedRolePolicies_Call {
	_c.Call.Return(run)
	return _c
}

// ListAttachedUserPolicies provides a mock function with given fields: ctx, params, optFns
func (_m *MockClient) ListAttachedUserPolicies(ctx context.Context, params *serviceiam.ListAttachedUserPoliciesInput, optFns ...func(*serviceiam.Options)) (*serviceiam.ListAttachedUserPoliciesOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *serviceiam.ListAttachedUserPoliciesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *serviceiam.ListAttachedUserPoliciesInput, ...func(*serviceiam.Options)) (*serviceiam.ListAttachedUserPoliciesOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *serviceiam.ListAttachedUserPoliciesInput, ...func(*serviceiam.Options)) *serviceiam.ListAttachedUserPoliciesOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*serviceiam.ListAttachedUserPoliciesOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *serviceiam.ListAttachedUserPoliciesInput, ...func(*serviceiam.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockClient_ListAttachedUserPolicies_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListAttachedUserPolicies'
type MockClient_ListAttachedUserPolicies_Call struct {
	*mock.Call
}

// ListAttachedUserPolicies is a helper method to define mock.On call
//   - ctx context.Context
//   - params *serviceiam.ListAttachedUserPoliciesInput
//   - optFns ...func(*serviceiam.Options)
func (_e *MockClient_Expecter) ListAttachedUserPolicies(ctx interface{}, params interface{}, optFns ...interface{}) *MockClient_ListAttachedUserPolicies_Call {
	return &MockClient_ListAttachedUserPolicies_Call{Call: _e.mock.On("ListAttachedUserPolicies",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *MockClient_ListAttachedUserPolicies_Call) Run(run func(ctx context.Context, params *serviceiam.ListAttachedUserPoliciesInput, optFns ...func(*serviceiam.Options))) *MockClient_ListAttachedUserPolicies_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*serviceiam.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*serviceiam.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*serviceiam.ListAttachedUserPoliciesInput), variadicArgs...)
	})
	return _c
}

func (_c *MockClient_ListAttachedUserPolicies_Call) Return(_a0 *serviceiam.ListAttachedUserPoliciesOutput, _a1 error) *MockClient_ListAttachedUserPolicies_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClient_ListAttachedUserPolicies_Call) RunAndReturn(run func(context.Context, *serviceiam.ListAttachedUserPoliciesInput, ...func(*serviceiam.Options)) (*serviceiam.ListAttachedUserPoliciesOutput, error)) *MockClient_ListAttachedUserPolicies_Call {
	_c.Call.Return(run)
	return _c
}

// ListEntitiesForPolicy provides a mock function with given fields: ctx, params, optFns
func (_m *MockClient) ListEntitiesForPolicy(ctx context.Context, params *serviceiam.ListEntitiesForPolicyInput, optFns ...func(*serviceiam.Options)) (*serviceiam.ListEntitiesForPolicyOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *serviceiam.ListEntitiesForPolicyOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *serviceiam.ListEntitiesForPolicyInput, ...func(*serviceiam.Options)) (*serviceiam.ListEntitiesForPolicyOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *serviceiam.ListEntitiesForPolicyInput, ...func(*serviceiam.Options)) *serviceiam.ListEntitiesForPolicyOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*serviceiam.ListEntitiesForPolicyOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *serviceiam.ListEntitiesForPolicyInput, ...func(*serviceiam.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockClient_ListEntitiesForPolicy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListEntitiesForPolicy'
type MockClient_ListEntitiesForPolicy_Call struct {
	*mock.Call
}

// ListEntitiesForPolicy is a helper method to define mock.On call
//   - ctx context.Context
//   - params *serviceiam.ListEntitiesForPolicyInput
//   - optFns ...func(*serviceiam.Options)
func (_e *MockClient_Expecter) ListEntitiesForPolicy(ctx interface{}, params interface{}, optFns ...interface{}) *MockClient_ListEntitiesForPolicy_Call {
	return &MockClient_ListEntitiesForPolicy_Call{Call: _e.mock.On("ListEntitiesForPolicy",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *MockClient_ListEntitiesForPolicy_Call) Run(run func(ctx context.Context, params *serviceiam.ListEntitiesForPolicyInput, optFns ...func(*serviceiam.Options))) *MockClient_ListEntitiesForPolicy_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*serviceiam.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*serviceiam.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*serviceiam.ListEntitiesForPolicyInput), variadicArgs...)
	})
	return _c
}

func (_c *MockClient_ListEntitiesForPolicy_Call) Return(_a0 *serviceiam.ListEntitiesForPolicyOutput, _a1 error) *MockClient_ListEntitiesForPolicy_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClient_ListEntitiesForPolicy_Call) RunAndReturn(run func(context.Context, *serviceiam.ListEntitiesForPolicyInput, ...func(*serviceiam.Options)) (*serviceiam.ListEntitiesForPolicyOutput, error)) *MockClient_ListEntitiesForPolicy_Call {
	_c.Call.Return(run)
	return _c
}

// ListMFADevices provides a mock function with given fields: ctx, params, optFns
func (_m *MockClient) ListMFADevices(ctx context.Context, params *serviceiam.ListMFADevicesInput, optFns ...func(*serviceiam.Options)) (*serviceiam.ListMFADevicesOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *serviceiam.ListMFADevicesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *serviceiam.ListMFADevicesInput, ...func(*serviceiam.Options)) (*serviceiam.ListMFADevicesOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *serviceiam.ListMFADevicesInput, ...func(*serviceiam.Options)) *serviceiam.ListMFADevicesOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*serviceiam.ListMFADevicesOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *serviceiam.ListMFADevicesInput, ...func(*serviceiam.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockClient_ListMFADevices_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListMFADevices'
type MockClient_ListMFADevices_Call struct {
	*mock.Call
}

// ListMFADevices is a helper method to define mock.On call
//   - ctx context.Context
//   - params *serviceiam.ListMFADevicesInput
//   - optFns ...func(*serviceiam.Options)
func (_e *MockClient_Expecter) ListMFADevices(ctx interface{}, params interface{}, optFns ...interface{}) *MockClient_ListMFADevices_Call {
	return &MockClient_ListMFADevices_Call{Call: _e.mock.On("ListMFADevices",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *MockClient_ListMFADevices_Call) Run(run func(ctx context.Context, params *serviceiam.ListMFADevicesInput, optFns ...func(*serviceiam.Options))) *MockClient_ListMFADevices_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*serviceiam.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*serviceiam.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*serviceiam.ListMFADevicesInput), variadicArgs...)
	})
	return _c
}

func (_c *MockClient_ListMFADevices_Call) Return(_a0 *serviceiam.ListMFADevicesOutput, _a1 error) *MockClient_ListMFADevices_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClient_ListMFADevices_Call) RunAndReturn(run func(context.Context, *serviceiam.ListMFADevicesInput, ...func(*serviceiam.Options)) (*serviceiam.ListMFADevicesOutput, error)) *MockClient_ListMFADevices_Call {
	_c.Call.Return(run)
	return _c
}

// ListPolicies provides a mock function with given fields: ctx, params, optFns
func (_m *MockClient) ListPolicies(ctx context.Context, params *serviceiam.ListPoliciesInput, optFns ...func(*serviceiam.Options)) (*serviceiam.ListPoliciesOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *serviceiam.ListPoliciesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *serviceiam.ListPoliciesInput, ...func(*serviceiam.Options)) (*serviceiam.ListPoliciesOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *serviceiam.ListPoliciesInput, ...func(*serviceiam.Options)) *serviceiam.ListPoliciesOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*serviceiam.ListPoliciesOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *serviceiam.ListPoliciesInput, ...func(*serviceiam.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockClient_ListPolicies_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListPolicies'
type MockClient_ListPolicies_Call struct {
	*mock.Call
}

// ListPolicies is a helper method to define mock.On call
//   - ctx context.Context
//   - params *serviceiam.ListPoliciesInput
//   - optFns ...func(*serviceiam.Options)
func (_e *MockClient_Expecter) ListPolicies(ctx interface{}, params interface{}, optFns ...interface{}) *MockClient_ListPolicies_Call {
	return &MockClient_ListPolicies_Call{Call: _e.mock.On("ListPolicies",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *MockClient_ListPolicies_Call) Run(run func(ctx context.Context, params *serviceiam.ListPoliciesInput, optFns ...func(*serviceiam.Options))) *MockClient_ListPolicies_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*serviceiam.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*serviceiam.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*serviceiam.ListPoliciesInput), variadicArgs...)
	})
	return _c
}

func (_c *MockClient_ListPolicies_Call) Return(_a0 *serviceiam.ListPoliciesOutput, _a1 error) *MockClient_ListPolicies_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClient_ListPolicies_Call) RunAndReturn(run func(context.Context, *serviceiam.ListPoliciesInput, ...func(*serviceiam.Options)) (*serviceiam.ListPoliciesOutput, error)) *MockClient_ListPolicies_Call {
	_c.Call.Return(run)
	return _c
}

// ListRoles provides a mock function with given fields: ctx, params, optFns
func (_m *MockClient) ListRoles(ctx context.Context, params *serviceiam.ListRolesInput, optFns ...func(*serviceiam.Options)) (*serviceiam.ListRolesOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *serviceiam.ListRolesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *serviceiam.ListRolesInput, ...func(*serviceiam.Options)) (*serviceiam.ListRolesOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *serviceiam.ListRolesInput, ...func(*serviceiam.Options)) *serviceiam.ListRolesOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*serviceiam.ListRolesOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *serviceiam.ListRolesInput, ...func(*serviceiam.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockClient_ListRoles_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListRoles'
type MockClient_ListRoles_Call struct {
	*mock.Call
}

// ListRoles is a helper method to define mock.On call
//   - ctx context.Context
//   - params *serviceiam.ListRolesInput
//   - optFns ...func(*serviceiam.Options)
func (_e *MockClient_Expecter) ListRoles(ctx interface{}, params interface{}, optFns ...interface{}) *MockClient_ListRoles_Call {
	return &MockClient_ListRoles_Call{Call: _e.mock.On("ListRoles",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *MockClient_ListRoles_Call) Run(run func(ctx context.Context, params *serviceiam.ListRolesInput, optFns ...func(*serviceiam.Options))) *MockClient_ListRoles_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*serviceiam.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*serviceiam.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*serviceiam.ListRolesInput), variadicArgs...)
	})
	return _c
}

func (_c *MockClient_ListRoles_Call) Return(_a0 *serviceiam.ListRolesOutput, _a1 error) *MockClient_ListRoles_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClient_ListRoles_Call) RunAndReturn(run func(context.Context, *serviceiam.ListRolesInput, ...func(*serviceiam.Options)) (*serviceiam.ListRolesOutput, error)) *MockClient_ListRoles_Call {
	_c.Call.Return(run)
	return _c
}

// ListServerCertificates provides a mock function with given fields: ctx, params, optFns
func (_m *MockClient) ListServerCertificates(ctx context.Context, params *serviceiam.ListServerCertificatesInput, optFns ...func(*serviceiam.Options)) (*serviceiam.ListServerCertificatesOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *serviceiam.ListServerCertificatesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *serviceiam.ListServerCertificatesInput, ...func(*serviceiam.Options)) (*serviceiam.ListServerCertificatesOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *serviceiam.ListServerCertificatesInput, ...func(*serviceiam.Options)) *serviceiam.ListServerCertificatesOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*serviceiam.ListServerCertificatesOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *serviceiam.ListServerCertificatesInput, ...func(*serviceiam.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockClient_ListServerCertificates_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListServerCertificates'
type MockClient_ListServerCertificates_Call struct {
	*mock.Call
}

// ListServerCertificates is a helper method to define mock.On call
//   - ctx context.Context
//   - params *serviceiam.ListServerCertificatesInput
//   - optFns ...func(*serviceiam.Options)
func (_e *MockClient_Expecter) ListServerCertificates(ctx interface{}, params interface{}, optFns ...interface{}) *MockClient_ListServerCertificates_Call {
	return &MockClient_ListServerCertificates_Call{Call: _e.mock.On("ListServerCertificates",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *MockClient_ListServerCertificates_Call) Run(run func(ctx context.Context, params *serviceiam.ListServerCertificatesInput, optFns ...func(*serviceiam.Options))) *MockClient_ListServerCertificates_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*serviceiam.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*serviceiam.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*serviceiam.ListServerCertificatesInput), variadicArgs...)
	})
	return _c
}

func (_c *MockClient_ListServerCertificates_Call) Return(_a0 *serviceiam.ListServerCertificatesOutput, _a1 error) *MockClient_ListServerCertificates_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClient_ListServerCertificates_Call) RunAndReturn(run func(context.Context, *serviceiam.ListServerCertificatesInput, ...func(*serviceiam.Options)) (*serviceiam.ListServerCertificatesOutput, error)) *MockClient_ListServerCertificates_Call {
	_c.Call.Return(run)
	return _c
}

// ListUserPolicies provides a mock function with given fields: ctx, params, optFns
func (_m *MockClient) ListUserPolicies(ctx context.Context, params *serviceiam.ListUserPoliciesInput, optFns ...func(*serviceiam.Options)) (*serviceiam.ListUserPoliciesOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *serviceiam.ListUserPoliciesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *serviceiam.ListUserPoliciesInput, ...func(*serviceiam.Options)) (*serviceiam.ListUserPoliciesOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *serviceiam.ListUserPoliciesInput, ...func(*serviceiam.Options)) *serviceiam.ListUserPoliciesOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*serviceiam.ListUserPoliciesOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *serviceiam.ListUserPoliciesInput, ...func(*serviceiam.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockClient_ListUserPolicies_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListUserPolicies'
type MockClient_ListUserPolicies_Call struct {
	*mock.Call
}

// ListUserPolicies is a helper method to define mock.On call
//   - ctx context.Context
//   - params *serviceiam.ListUserPoliciesInput
//   - optFns ...func(*serviceiam.Options)
func (_e *MockClient_Expecter) ListUserPolicies(ctx interface{}, params interface{}, optFns ...interface{}) *MockClient_ListUserPolicies_Call {
	return &MockClient_ListUserPolicies_Call{Call: _e.mock.On("ListUserPolicies",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *MockClient_ListUserPolicies_Call) Run(run func(ctx context.Context, params *serviceiam.ListUserPoliciesInput, optFns ...func(*serviceiam.Options))) *MockClient_ListUserPolicies_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*serviceiam.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*serviceiam.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*serviceiam.ListUserPoliciesInput), variadicArgs...)
	})
	return _c
}

func (_c *MockClient_ListUserPolicies_Call) Return(_a0 *serviceiam.ListUserPoliciesOutput, _a1 error) *MockClient_ListUserPolicies_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClient_ListUserPolicies_Call) RunAndReturn(run func(context.Context, *serviceiam.ListUserPoliciesInput, ...func(*serviceiam.Options)) (*serviceiam.ListUserPoliciesOutput, error)) *MockClient_ListUserPolicies_Call {
	_c.Call.Return(run)
	return _c
}

// ListUsers provides a mock function with given fields: ctx, params, optFns
func (_m *MockClient) ListUsers(ctx context.Context, params *serviceiam.ListUsersInput, optFns ...func(*serviceiam.Options)) (*serviceiam.ListUsersOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *serviceiam.ListUsersOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *serviceiam.ListUsersInput, ...func(*serviceiam.Options)) (*serviceiam.ListUsersOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *serviceiam.ListUsersInput, ...func(*serviceiam.Options)) *serviceiam.ListUsersOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*serviceiam.ListUsersOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *serviceiam.ListUsersInput, ...func(*serviceiam.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockClient_ListUsers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListUsers'
type MockClient_ListUsers_Call struct {
	*mock.Call
}

// ListUsers is a helper method to define mock.On call
//   - ctx context.Context
//   - params *serviceiam.ListUsersInput
//   - optFns ...func(*serviceiam.Options)
func (_e *MockClient_Expecter) ListUsers(ctx interface{}, params interface{}, optFns ...interface{}) *MockClient_ListUsers_Call {
	return &MockClient_ListUsers_Call{Call: _e.mock.On("ListUsers",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *MockClient_ListUsers_Call) Run(run func(ctx context.Context, params *serviceiam.ListUsersInput, optFns ...func(*serviceiam.Options))) *MockClient_ListUsers_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*serviceiam.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*serviceiam.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*serviceiam.ListUsersInput), variadicArgs...)
	})
	return _c
}

func (_c *MockClient_ListUsers_Call) Return(_a0 *serviceiam.ListUsersOutput, _a1 error) *MockClient_ListUsers_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClient_ListUsers_Call) RunAndReturn(run func(context.Context, *serviceiam.ListUsersInput, ...func(*serviceiam.Options)) (*serviceiam.ListUsersOutput, error)) *MockClient_ListUsers_Call {
	_c.Call.Return(run)
	return _c
}

// ListVirtualMFADevices provides a mock function with given fields: ctx, params, optFns
func (_m *MockClient) ListVirtualMFADevices(ctx context.Context, params *serviceiam.ListVirtualMFADevicesInput, optFns ...func(*serviceiam.Options)) (*serviceiam.ListVirtualMFADevicesOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *serviceiam.ListVirtualMFADevicesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *serviceiam.ListVirtualMFADevicesInput, ...func(*serviceiam.Options)) (*serviceiam.ListVirtualMFADevicesOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *serviceiam.ListVirtualMFADevicesInput, ...func(*serviceiam.Options)) *serviceiam.ListVirtualMFADevicesOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*serviceiam.ListVirtualMFADevicesOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *serviceiam.ListVirtualMFADevicesInput, ...func(*serviceiam.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockClient_ListVirtualMFADevices_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListVirtualMFADevices'
type MockClient_ListVirtualMFADevices_Call struct {
	*mock.Call
}

// ListVirtualMFADevices is a helper method to define mock.On call
//   - ctx context.Context
//   - params *serviceiam.ListVirtualMFADevicesInput
//   - optFns ...func(*serviceiam.Options)
func (_e *MockClient_Expecter) ListVirtualMFADevices(ctx interface{}, params interface{}, optFns ...interface{}) *MockClient_ListVirtualMFADevices_Call {
	return &MockClient_ListVirtualMFADevices_Call{Call: _e.mock.On("ListVirtualMFADevices",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *MockClient_ListVirtualMFADevices_Call) Run(run func(ctx context.Context, params *serviceiam.ListVirtualMFADevicesInput, optFns ...func(*serviceiam.Options))) *MockClient_ListVirtualMFADevices_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*serviceiam.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*serviceiam.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*serviceiam.ListVirtualMFADevicesInput), variadicArgs...)
	})
	return _c
}

func (_c *MockClient_ListVirtualMFADevices_Call) Return(_a0 *serviceiam.ListVirtualMFADevicesOutput, _a1 error) *MockClient_ListVirtualMFADevices_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClient_ListVirtualMFADevices_Call) RunAndReturn(run func(context.Context, *serviceiam.ListVirtualMFADevicesInput, ...func(*serviceiam.Options)) (*serviceiam.ListVirtualMFADevicesOutput, error)) *MockClient_ListVirtualMFADevices_Call {
	_c.Call.Return(run)
	return _c
}

// NewMockClient creates a new instance of MockClient. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
// The first argument is typically a *testing.T value.
func NewMockClient(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockClient {
	mock := &MockClient{}
	mock.Mock.Test(t)

	t.Cleanup(func() { mock.AssertExpectations(t) })

	return mock
}