func (_m *MockKMSAPI) DisableKeyRequest(_param0 *kms.DisableKeyInput) (*request.Request, *kms.DisableKeyOutput) {
	ret := _m.ctrl.Call(_m, "DisableKeyRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*kms.DisableKeyOutput)
	return ret0, ret1
}
DisableKeyRequest mocks base method
package mockaws
import (
	aws "github.com/aws/aws-sdk-go/aws"
	request "github.com/aws/aws-sdk-go/aws/request"
	kms "github.com/aws/aws-sdk-go/service/kms"
	gomock "github.com/golang/mock/gomock"
	reflect "reflect"
)
type MockKMSAPI struct {
	ctrl     *gomock.Controller
	recorder *MockKMSAPIMockRecorder
}
type MockKMSAPIMockRecorder struct {
	mock *MockKMSAPI
}
func NewMockKMSAPI(ctrl *gomock.Controller) *MockKMSAPI {
	mock := &MockKMSAPI{ctrl: ctrl}
	mock.recorder = &MockKMSAPIMockRecorder{mock}
	return mock
}
func (_m *MockKMSAPI) EXPECT() *MockKMSAPIMockRecorder {
	return _m.recorder
}
func (_m *MockKMSAPI) CancelKeyDeletion(_param0 *kms.CancelKeyDeletionInput) (*kms.CancelKeyDeletionOutput, error) {
	ret := _m.ctrl.Call(_m, "CancelKeyDeletion", _param0)
	ret0, _ := ret[0].(*kms.CancelKeyDeletionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (_mr *MockKMSAPIMockRecorder) CancelKeyDeletion(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "CancelKeyDeletion", reflect.TypeOf((*MockKMSAPI)(nil).CancelKeyDeletion), arg0)
}
func (_m *MockKMSAPI) CancelKeyDeletionWithContext(_param0 aws.Context, _param1 *kms.CancelKeyDeletionInput, _param2 ...request.Option) (*kms.CancelKeyDeletionOutput, error) {
	_s := []interface{}{_param0, _param1}
	for _, _x := range _param2 {
		_s = append(_s, _x)
	}
	ret := _m.ctrl.Call(_m, "CancelKeyDeletionWithContext", _s...)
	ret0, _ := ret[0].(*kms.CancelKeyDeletionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (_mr *MockKMSAPIMockRecorder) CancelKeyDeletionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	_s := append([]interface{}{arg0, arg1}, arg2...)
	return _mr.mock.ctrl.RecordCall(_mr.mock, "CancelKeyDeletionWithContext", reflect.TypeOf((*MockKMSAPI)(nil).CancelKeyDeletionWithContext), _s...)
}
func (_m *MockKMSAPI) CancelKeyDeletionRequest(_param0 *kms.CancelKeyDeletionInput) (*request.Request, *kms.CancelKeyDeletionOutput) {
	ret := _m.ctrl.Call(_m, "CancelKeyDeletionRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*kms.CancelKeyDeletionOutput)
	return ret0, ret1
}
func (_mr *MockKMSAPIMockRecorder) CancelKeyDeletionRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "CancelKeyDeletionRequest", reflect.TypeOf((*MockKMSAPI)(nil).CancelKeyDeletionRequest), arg0)
}
func (_m *MockKMSAPI) CreateAlias(_param0 *kms.CreateAliasInput) (*kms.CreateAliasOutput, error) {
	ret := _m.ctrl.Call(_m, "CreateAlias", _param0)
	ret0, _ := ret[0].(*kms.CreateAliasOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (_mr *MockKMSAPIMockRecorder) CreateAlias(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "CreateAlias", reflect.TypeOf((*MockKMSAPI)(nil).CreateAlias), arg0)
}
func (_m *MockKMSAPI) CreateAliasWithContext(_param0 aws.Context, _param1 *kms.CreateAliasInput, _param2 ...request.Option) (*kms.CreateAliasOutput, error) {
	_s := []interface{}{_param0, _param1}
	for _, _x := range _param2 {
		_s = append(_s, _x)
	}
	ret := _m.ctrl.Call(_m, "CreateAliasWithContext", _s...)
	ret0, _ := ret[0].(*kms.CreateAliasOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (_mr *MockKMSAPIMockRecorder) CreateAliasWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	_s := append([]interface{}{arg0, arg1}, arg2...)
	return _mr.mock.ctrl.RecordCall(_mr.mock, "CreateAliasWithContext", reflect.TypeOf((*MockKMSAPI)(nil).CreateAliasWithContext), _s...)
}
func (_m *MockKMSAPI) CreateAliasRequest(_param0 *kms.CreateAliasInput) (*request.Request, *kms.CreateAliasOutput) {
	ret := _m.ctrl.Call(_m, "CreateAliasRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*kms.CreateAliasOutput)
	return ret0, ret1
}
func (_mr *MockKMSAPIMockRecorder) CreateAliasRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "CreateAliasRequest", reflect.TypeOf((*MockKMSAPI)(nil).CreateAliasRequest), arg0)
}
func (_m *MockKMSAPI) CreateGrant(_param0 *kms.CreateGrantInput) (*kms.CreateGrantOutput, error) {
	ret := _m.ctrl.Call(_m, "CreateGrant", _param0)
	ret0, _ := ret[0].(*kms.CreateGrantOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (_mr *MockKMSAPIMockRecorder) CreateGrant(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "CreateGrant", reflect.TypeOf((*MockKMSAPI)(nil).CreateGrant), arg0)
}
func (_m *MockKMSAPI) CreateGrantWithContext(_param0 aws.Context, _param1 *kms.CreateGrantInput, _param2 ...request.Option) (*kms.CreateGrantOutput, error) {
	_s := []interface{}{_param0, _param1}
	for _, _x := range _param2 {
		_s = append(_s, _x)
	}
	ret := _m.ctrl.Call(_m, "CreateGrantWithContext", _s...)
	ret0, _ := ret[0].(*kms.CreateGrantOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (_mr *MockKMSAPIMockRecorder) CreateGrantWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	_s := append([]interface{}{arg0, arg1}, arg2...)
	return _mr.mock.ctrl.RecordCall(_mr.mock, "CreateGrantWithContext", reflect.TypeOf((*MockKMSAPI)(nil).CreateGrantWithContext), _s...)
}
func (_m *MockKMSAPI) CreateGrantRequest(_param0 *kms.CreateGrantInput) (*request.Request, *kms.CreateGrantOutput) {
	ret := _m.ctrl.Call(_m, "CreateGrantRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*kms.CreateGrantOutput)
	return ret0, ret1
}
func (_mr *MockKMSAPIMockRecorder) CreateGrantRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "CreateGrantRequest", reflect.TypeOf((*MockKMSAPI)(nil).CreateGrantRequest), arg0)
}
func (_m *MockKMSAPI) CreateKey(_param0 *kms.CreateKeyInput) (*kms.CreateKeyOutput, error) {
	ret := _m.ctrl.Call(_m, "CreateKey", _param0)
	ret0, _ := ret[0].(*kms.CreateKeyOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (_mr *MockKMSAPIMockRecorder) CreateKey(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "CreateKey", reflect.TypeOf((*MockKMSAPI)(nil).CreateKey), arg0)
}
func (_m *MockKMSAPI) CreateKeyWithContext(_param0 aws.Context, _param1 *kms.CreateKeyInput, _param2 ...request.Option) (*kms.CreateKeyOutput, error) {
	_s := []interface{}{_param0, _param1}
	for _, _x := range _param2 {
		_s = append(_s, _x)
	}
	ret := _m.ctrl.Call(_m, "CreateKeyWithContext", _s...)
	ret0, _ := ret[0].(*kms.CreateKeyOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (_mr *MockKMSAPIMockRecorder) CreateKeyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	_s := append([]interface{}{arg0, arg1}, arg2...)
	return _mr.mock.ctrl.RecordCall(_mr.mock, "CreateKeyWithContext", reflect.TypeOf((*MockKMSAPI)(nil).CreateKeyWithContext), _s...)
}
func (_m *MockKMSAPI) CreateKeyRequest(_param0 *kms.CreateKeyInput) (*request.Request, *kms.CreateKeyOutput) {
	ret := _m.ctrl.Call(_m, "CreateKeyRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*kms.CreateKeyOutput)
	return ret0, ret1
}
func (_mr *MockKMSAPIMockRecorder) CreateKeyRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "CreateKeyRequest", reflect.TypeOf((*MockKMSAPI)(nil).CreateKeyRequest), arg0)
}
func (_m *MockKMSAPI) Decrypt(_param0 *kms.DecryptInput) (*kms.DecryptOutput, error) {
	ret := _m.ctrl.Call(_m, "Decrypt", _param0)
	ret0, _ := ret[0].(*kms.DecryptOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (_mr *MockKMSAPIMockRecorder) Decrypt(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "Decrypt", reflect.TypeOf((*MockKMSAPI)(nil).Decrypt), arg0)
}
func (_m *MockKMSAPI) DecryptWithContext(_param0 aws.Context, _param1 *kms.DecryptInput, _param2 ...request.Option) (*kms.DecryptOutput, error) {
	_s := []interface{}{_param0, _param1}
	for _, _x := range _param2 {
		_s = append(_s, _x)
	}
	ret := _m.ctrl.Call(_m, "DecryptWithContext", _s...)
	ret0, _ := ret[0].(*kms.DecryptOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (_mr *MockKMSAPIMockRecorder) DecryptWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	_s := append([]interface{}{arg0, arg1}, arg2...)
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DecryptWithContext", reflect.TypeOf((*MockKMSAPI)(nil).DecryptWithContext), _s...)
}
func (_m *MockKMSAPI) DecryptRequest(_param0 *kms.DecryptInput) (*request.Request, *kms.DecryptOutput) {
	ret := _m.ctrl.Call(_m, "DecryptRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*kms.DecryptOutput)
	return ret0, ret1
}
func (_mr *MockKMSAPIMockRecorder) DecryptRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DecryptRequest", reflect.TypeOf((*MockKMSAPI)(nil).DecryptRequest), arg0)
}
func (_m *MockKMSAPI) DeleteAlias(_param0 *kms.DeleteAliasInput) (*kms.DeleteAliasOutput, error) {
	ret := _m.ctrl.Call(_m, "DeleteAlias", _param0)
	ret0, _ := ret[0].(*kms.DeleteAliasOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (_mr *MockKMSAPIMockRecorder) DeleteAlias(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteAlias", reflect.TypeOf((*MockKMSAPI)(nil).DeleteAlias), arg0)
}
func (_m *MockKMSAPI) DeleteAliasWithContext(_param0 aws.Context, _param1 *kms.DeleteAliasInput, _param2 ...request.Option) (*kms.DeleteAliasOutput, error) {
	_s := []interface{}{_param0, _param1}
	for _, _x := range _param2 {
		_s = append(_s, _x)
	}
	ret := _m.ctrl.Call(_m, "DeleteAliasWithContext", _s...)
	ret0, _ := ret[0].(*kms.DeleteAliasOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (_mr *MockKMSAPIMockRecorder) DeleteAliasWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	_s := append([]interface{}{arg0, arg1}, arg2...)
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteAliasWithContext", reflect.TypeOf((*MockKMSAPI)(nil).DeleteAliasWithContext), _s...)
}
func (_m *MockKMSAPI) DeleteAliasRequest(_param0 *kms.DeleteAliasInput) (*request.Request, *kms.DeleteAliasOutput) {
	ret := _m.ctrl.Call(_m, "DeleteAliasRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*kms.DeleteAliasOutput)
	return ret0, ret1
}
func (_mr *MockKMSAPIMockRecorder) DeleteAliasRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteAliasRequest", reflect.TypeOf((*MockKMSAPI)(nil).DeleteAliasRequest), arg0)
}
func (_m *MockKMSAPI) DeleteImportedKeyMaterial(_param0 *kms.DeleteImportedKeyMaterialInput) (*kms.DeleteImportedKeyMaterialOutput, error) {
	ret := _m.ctrl.Call(_m, "DeleteImportedKeyMaterial", _param0)
	ret0, _ := ret[0].(*kms.DeleteImportedKeyMaterialOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (_mr *MockKMSAPIMockRecorder) DeleteImportedKeyMaterial(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteImportedKeyMaterial", reflect.TypeOf((*MockKMSAPI)(nil).DeleteImportedKeyMaterial), arg0)
}
func (_m *MockKMSAPI) DeleteImportedKeyMaterialWithContext(_param0 aws.Context, _param1 *kms.DeleteImportedKeyMaterialInput, _param2 ...request.Option) (*kms.DeleteImportedKeyMaterialOutput, error) {
	_s := []interface{}{_param0, _param1}
	for _, _x := range _param2 {
		_s = append(_s, _x)
	}
	ret := _m.ctrl.Call(_m, "DeleteImportedKeyMaterialWithContext", _s...)
	ret0, _ := ret[0].(*kms.DeleteImportedKeyMaterialOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (_mr *MockKMSAPIMockRecorder) DeleteImportedKeyMaterialWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	_s := append([]interface{}{arg0, arg1}, arg2...)
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteImportedKeyMaterialWithContext", reflect.TypeOf((*MockKMSAPI)(nil).DeleteImportedKeyMaterialWithContext), _s...)
}
func (_m *MockKMSAPI) DeleteImportedKeyMaterialRequest(_param0 *kms.DeleteImportedKeyMaterialInput) (*request.Request, *kms.DeleteImportedKeyMaterialOutput) {
	ret := _m.ctrl.Call(_m, "DeleteImportedKeyMaterialRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*kms.DeleteImportedKeyMaterialOutput)
	return ret0, ret1
}
func (_mr *MockKMSAPIMockRecorder) DeleteImportedKeyMaterialRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteImportedKeyMaterialRequest", reflect.TypeOf((*MockKMSAPI)(nil).DeleteImportedKeyMaterialRequest), arg0)
}
func (_m *MockKMSAPI) DescribeKey(_param0 *kms.DescribeKeyInput) (*kms.DescribeKeyOutput, error) {
	ret := _m.ctrl.Call(_m, "DescribeKey", _param0)
	ret0, _ := ret[0].(*kms.DescribeKeyOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (_mr *MockKMSAPIMockRecorder) DescribeKey(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DescribeKey", reflect.TypeOf((*MockKMSAPI)(nil).DescribeKey), arg0)
}
func (_m *MockKMSAPI) DescribeKeyWithContext(_param0 aws.Context, _param1 *kms.DescribeKeyInput, _param2 ...request.Option) (*kms.DescribeKeyOutput, error) {
	_s := []interface{}{_param0, _param1}
	for _, _x := range _param2 {
		_s = append(_s, _x)
	}
	ret := _m.ctrl.Call(_m, "DescribeKeyWithContext", _s...)
	ret0, _ := ret[0].(*kms.DescribeKeyOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (_mr *MockKMSAPIMockRecorder) DescribeKeyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	_s := append([]interface{}{arg0, arg1}, arg2...)
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DescribeKeyWithContext", reflect.TypeOf((*MockKMSAPI)(nil).DescribeKeyWithContext), _s...)
}
func (_m *MockKMSAPI) DescribeKeyRequest(_param0 *kms.DescribeKeyInput) (*request.Request, *kms.DescribeKeyOutput) {
	ret := _m.ctrl.Call(_m, "DescribeKeyRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*kms.DescribeKeyOutput)
	return ret0, ret1
}
func (_mr *MockKMSAPIMockRecorder) DescribeKeyRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DescribeKeyRequest", reflect.TypeOf((*MockKMSAPI)(nil).DescribeKeyRequest), arg0)
}
func (_m *MockKMSAPI) DisableKey(_param0 *kms.DisableKeyInput) (*kms.DisableKeyOutput, error) {
	ret := _m.ctrl.Call(_m, "DisableKey", _param0)
	ret0, _ := ret[0].(*kms.DisableKeyOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (_mr *MockKMSAPIMockRecorder) DisableKey(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DisableKey", reflect.TypeOf((*MockKMSAPI)(nil).DisableKey), arg0)
}
func (_m *MockKMSAPI) DisableKeyWithContext(_param0 aws.Context, _param1 *kms.DisableKeyInput, _param2 ...request.Option) (*kms.DisableKeyOutput, error) {
	_s := []interface{}{_param0, _param1}
	for _, _x := range _param2 {
		_s = append(_s, _x)
	}
	ret := _m.ctrl.Call(_m, "DisableKeyWithContext", _s...)
	ret0, _ := ret[0].(*kms.DisableKeyOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (_mr *MockKMSAPIMockRecorder) DisableKeyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	_s := append([]interface{}{arg0, arg1}, arg2...)
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DisableKeyWithContext", reflect.TypeOf((*MockKMSAPI)(nil).DisableKeyWithContext), _s...)
}