// Copyright 2015-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License"). You may
// not use this file except in compliance with the License. A copy of the
// License is located at
//
//     http://aws.amazon.com/apache2.0/
//
// or in the "license" file accompanying this file. This file 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 MockGen. DO NOT EDIT.
// Source: github.com/aws/aws-sdk-go/service/kms/kmsiface (interfaces: KMSAPI)

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

import (
	context "context"
	reflect "reflect"

	request "github.com/aws/aws-sdk-go/aws/request"
	kms "github.com/aws/aws-sdk-go/service/kms"
	gomock "github.com/golang/mock/gomock"
)

// MockKMSAPI is a mock of KMSAPI interface
type MockKMSAPI struct {
	ctrl     *gomock.Controller
	recorder *MockKMSAPIMockRecorder
}

// MockKMSAPIMockRecorder is the mock recorder for MockKMSAPI
type MockKMSAPIMockRecorder struct {
	mock *MockKMSAPI
}

// NewMockKMSAPI creates a new mock instance
func NewMockKMSAPI(ctrl *gomock.Controller) *MockKMSAPI {
	mock := &MockKMSAPI{ctrl: ctrl}
	mock.recorder = &MockKMSAPIMockRecorder{mock}
	return mock
}

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

// CancelKeyDeletion mocks base method
func (m *MockKMSAPI) CancelKeyDeletion(arg0 *kms.CancelKeyDeletionInput) (*kms.CancelKeyDeletionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CancelKeyDeletion", arg0)
	ret0, _ := ret[0].(*kms.CancelKeyDeletionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CancelKeyDeletionRequest mocks base method
func (m *MockKMSAPI) CancelKeyDeletionRequest(arg0 *kms.CancelKeyDeletionInput) (*request.Request, *kms.CancelKeyDeletionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CancelKeyDeletionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*kms.CancelKeyDeletionOutput)
	return ret0, ret1
}

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

// CancelKeyDeletionWithContext mocks base method
func (m *MockKMSAPI) CancelKeyDeletionWithContext(arg0 context.Context, arg1 *kms.CancelKeyDeletionInput, arg2 ...request.Option) (*kms.CancelKeyDeletionOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CancelKeyDeletionWithContext", varargs...)
	ret0, _ := ret[0].(*kms.CancelKeyDeletionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CancelKeyDeletionWithContext indicates an expected call of CancelKeyDeletionWithContext
func (mr *MockKMSAPIMockRecorder) CancelKeyDeletionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelKeyDeletionWithContext", reflect.TypeOf((*MockKMSAPI)(nil).CancelKeyDeletionWithContext), varargs...)
}

// ConnectCustomKeyStore mocks base method
func (m *MockKMSAPI) ConnectCustomKeyStore(arg0 *kms.ConnectCustomKeyStoreInput) (*kms.ConnectCustomKeyStoreOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ConnectCustomKeyStore", arg0)
	ret0, _ := ret[0].(*kms.ConnectCustomKeyStoreOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ConnectCustomKeyStoreRequest mocks base method
func (m *MockKMSAPI) ConnectCustomKeyStoreRequest(arg0 *kms.ConnectCustomKeyStoreInput) (*request.Request, *kms.ConnectCustomKeyStoreOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ConnectCustomKeyStoreRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*kms.ConnectCustomKeyStoreOutput)
	return ret0, ret1
}

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

// ConnectCustomKeyStoreWithContext mocks base method
func (m *MockKMSAPI) ConnectCustomKeyStoreWithContext(arg0 context.Context, arg1 *kms.ConnectCustomKeyStoreInput, arg2 ...request.Option) (*kms.ConnectCustomKeyStoreOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ConnectCustomKeyStoreWithContext", varargs...)
	ret0, _ := ret[0].(*kms.ConnectCustomKeyStoreOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ConnectCustomKeyStoreWithContext indicates an expected call of ConnectCustomKeyStoreWithContext
func (mr *MockKMSAPIMockRecorder) ConnectCustomKeyStoreWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConnectCustomKeyStoreWithContext", reflect.TypeOf((*MockKMSAPI)(nil).ConnectCustomKeyStoreWithContext), varargs...)
}

// CreateAlias mocks base method
func (m *MockKMSAPI) CreateAlias(arg0 *kms.CreateAliasInput) (*kms.CreateAliasOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateAlias", arg0)
	ret0, _ := ret[0].(*kms.CreateAliasOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateAliasRequest mocks base method
func (m *MockKMSAPI) CreateAliasRequest(arg0 *kms.CreateAliasInput) (*request.Request, *kms.CreateAliasOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateAliasRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*kms.CreateAliasOutput)
	return ret0, ret1
}

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

// CreateAliasWithContext mocks base method
func (m *MockKMSAPI) CreateAliasWithContext(arg0 context.Context, arg1 *kms.CreateAliasInput, arg2 ...request.Option) (*kms.CreateAliasOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateAliasWithContext", varargs...)
	ret0, _ := ret[0].(*kms.CreateAliasOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateAliasWithContext indicates an expected call of CreateAliasWithContext
func (mr *MockKMSAPIMockRecorder) CreateAliasWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateAliasWithContext", reflect.TypeOf((*MockKMSAPI)(nil).CreateAliasWithContext), varargs...)
}

// CreateCustomKeyStore mocks base method
func (m *MockKMSAPI) CreateCustomKeyStore(arg0 *kms.CreateCustomKeyStoreInput) (*kms.CreateCustomKeyStoreOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateCustomKeyStore", arg0)
	ret0, _ := ret[0].(*kms.CreateCustomKeyStoreOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateCustomKeyStoreRequest mocks base method
func (m *MockKMSAPI) CreateCustomKeyStoreRequest(arg0 *kms.CreateCustomKeyStoreInput) (*request.Request, *kms.CreateCustomKeyStoreOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateCustomKeyStoreRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*kms.CreateCustomKeyStoreOutput)
	return ret0, ret1
}

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

// CreateCustomKeyStoreWithContext mocks base method
func (m *MockKMSAPI) CreateCustomKeyStoreWithContext(arg0 context.Context, arg1 *kms.CreateCustomKeyStoreInput, arg2 ...request.Option) (*kms.CreateCustomKeyStoreOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateCustomKeyStoreWithContext", varargs...)
	ret0, _ := ret[0].(*kms.CreateCustomKeyStoreOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateCustomKeyStoreWithContext indicates an expected call of CreateCustomKeyStoreWithContext
func (mr *MockKMSAPIMockRecorder) CreateCustomKeyStoreWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCustomKeyStoreWithContext", reflect.TypeOf((*MockKMSAPI)(nil).CreateCustomKeyStoreWithContext), varargs...)
}

// CreateGrant mocks base method
func (m *MockKMSAPI) CreateGrant(arg0 *kms.CreateGrantInput) (*kms.CreateGrantOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateGrant", arg0)
	ret0, _ := ret[0].(*kms.CreateGrantOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateGrantRequest mocks base method
func (m *MockKMSAPI) CreateGrantRequest(arg0 *kms.CreateGrantInput) (*request.Request, *kms.CreateGrantOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateGrantRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*kms.CreateGrantOutput)
	return ret0, ret1
}

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

// CreateGrantWithContext mocks base method
func (m *MockKMSAPI) CreateGrantWithContext(arg0 context.Context, arg1 *kms.CreateGrantInput, arg2 ...request.Option) (*kms.CreateGrantOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateGrantWithContext", varargs...)
	ret0, _ := ret[0].(*kms.CreateGrantOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateGrantWithContext indicates an expected call of CreateGrantWithContext
func (mr *MockKMSAPIMockRecorder) CreateGrantWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateGrantWithContext", reflect.TypeOf((*MockKMSAPI)(nil).CreateGrantWithContext), varargs...)
}

// CreateKey mocks base method
func (m *MockKMSAPI) CreateKey(arg0 *kms.CreateKeyInput) (*kms.CreateKeyOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateKey", arg0)
	ret0, _ := ret[0].(*kms.CreateKeyOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateKeyRequest mocks base method
func (m *MockKMSAPI) CreateKeyRequest(arg0 *kms.CreateKeyInput) (*request.Request, *kms.CreateKeyOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateKeyRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*kms.CreateKeyOutput)
	return ret0, ret1
}

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

// CreateKeyWithContext mocks base method
func (m *MockKMSAPI) CreateKeyWithContext(arg0 context.Context, arg1 *kms.CreateKeyInput, arg2 ...request.Option) (*kms.CreateKeyOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateKeyWithContext", varargs...)
	ret0, _ := ret[0].(*kms.CreateKeyOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateKeyWithContext indicates an expected call of CreateKeyWithContext
func (mr *MockKMSAPIMockRecorder) CreateKeyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateKeyWithContext", reflect.TypeOf((*MockKMSAPI)(nil).CreateKeyWithContext), varargs...)
}

// Decrypt mocks base method
func (m *MockKMSAPI) Decrypt(arg0 *kms.DecryptInput) (*kms.DecryptOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Decrypt", arg0)
	ret0, _ := ret[0].(*kms.DecryptOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DecryptRequest mocks base method
func (m *MockKMSAPI) DecryptRequest(arg0 *kms.DecryptInput) (*request.Request, *kms.DecryptOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DecryptRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*kms.DecryptOutput)
	return ret0, ret1
}

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

// DecryptWithContext mocks base method
func (m *MockKMSAPI) DecryptWithContext(arg0 context.Context, arg1 *kms.DecryptInput, arg2 ...request.Option) (*kms.DecryptOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DecryptWithContext", varargs...)
	ret0, _ := ret[0].(*kms.DecryptOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DecryptWithContext indicates an expected call of DecryptWithContext
func (mr *MockKMSAPIMockRecorder) DecryptWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DecryptWithContext", reflect.TypeOf((*MockKMSAPI)(nil).DecryptWithContext), varargs...)
}

// DeleteAlias mocks base method
func (m *MockKMSAPI) DeleteAlias(arg0 *kms.DeleteAliasInput) (*kms.DeleteAliasOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteAlias", arg0)
	ret0, _ := ret[0].(*kms.DeleteAliasOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteAliasRequest mocks base method
func (m *MockKMSAPI) DeleteAliasRequest(arg0 *kms.DeleteAliasInput) (*request.Request, *kms.DeleteAliasOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteAliasRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*kms.DeleteAliasOutput)
	return ret0, ret1
}

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

// DeleteAliasWithContext mocks base method
func (m *MockKMSAPI) DeleteAliasWithContext(arg0 context.Context, arg1 *kms.DeleteAliasInput, arg2 ...request.Option) (*kms.DeleteAliasOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteAliasWithContext", varargs...)
	ret0, _ := ret[0].(*kms.DeleteAliasOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteAliasWithContext indicates an expected call of DeleteAliasWithContext
func (mr *MockKMSAPIMockRecorder) DeleteAliasWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAliasWithContext", reflect.TypeOf((*MockKMSAPI)(nil).DeleteAliasWithContext), varargs...)
}

// DeleteCustomKeyStore mocks base method
func (m *MockKMSAPI) DeleteCustomKeyStore(arg0 *kms.DeleteCustomKeyStoreInput) (*kms.DeleteCustomKeyStoreOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteCustomKeyStore", arg0)
	ret0, _ := ret[0].(*kms.DeleteCustomKeyStoreOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteCustomKeyStoreRequest mocks base method
func (m *MockKMSAPI) DeleteCustomKeyStoreRequest(arg0 *kms.DeleteCustomKeyStoreInput) (*request.Request, *kms.DeleteCustomKeyStoreOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteCustomKeyStoreRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*kms.DeleteCustomKeyStoreOutput)
	return ret0, ret1
}

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

// DeleteCustomKeyStoreWithContext mocks base method
func (m *MockKMSAPI) DeleteCustomKeyStoreWithContext(arg0 context.Context, arg1 *kms.DeleteCustomKeyStoreInput, arg2 ...request.Option) (*kms.DeleteCustomKeyStoreOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteCustomKeyStoreWithContext", varargs...)
	ret0, _ := ret[0].(*kms.DeleteCustomKeyStoreOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteCustomKeyStoreWithContext indicates an expected call of DeleteCustomKeyStoreWithContext
func (mr *MockKMSAPIMockRecorder) DeleteCustomKeyStoreWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCustomKeyStoreWithContext", reflect.TypeOf((*MockKMSAPI)(nil).DeleteCustomKeyStoreWithContext), varargs...)
}

// DeleteImportedKeyMaterial mocks base method
func (m *MockKMSAPI) DeleteImportedKeyMaterial(arg0 *kms.DeleteImportedKeyMaterialInput) (*kms.DeleteImportedKeyMaterialOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteImportedKeyMaterial", arg0)
	ret0, _ := ret[0].(*kms.DeleteImportedKeyMaterialOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteImportedKeyMaterialRequest mocks base method
func (m *MockKMSAPI) DeleteImportedKeyMaterialRequest(arg0 *kms.DeleteImportedKeyMaterialInput) (*request.Request, *kms.DeleteImportedKeyMaterialOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteImportedKeyMaterialRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*kms.DeleteImportedKeyMaterialOutput)
	return ret0, ret1
}

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

// DeleteImportedKeyMaterialWithContext mocks base method
func (m *MockKMSAPI) DeleteImportedKeyMaterialWithContext(arg0 context.Context, arg1 *kms.DeleteImportedKeyMaterialInput, arg2 ...request.Option) (*kms.DeleteImportedKeyMaterialOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteImportedKeyMaterialWithContext", varargs...)
	ret0, _ := ret[0].(*kms.DeleteImportedKeyMaterialOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteImportedKeyMaterialWithContext indicates an expected call of DeleteImportedKeyMaterialWithContext
func (mr *MockKMSAPIMockRecorder) DeleteImportedKeyMaterialWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteImportedKeyMaterialWithContext", reflect.TypeOf((*MockKMSAPI)(nil).DeleteImportedKeyMaterialWithContext), varargs...)
}

// DescribeCustomKeyStores mocks base method
func (m *MockKMSAPI) DescribeCustomKeyStores(arg0 *kms.DescribeCustomKeyStoresInput) (*kms.DescribeCustomKeyStoresOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeCustomKeyStores", arg0)
	ret0, _ := ret[0].(*kms.DescribeCustomKeyStoresOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeCustomKeyStoresRequest mocks base method
func (m *MockKMSAPI) DescribeCustomKeyStoresRequest(arg0 *kms.DescribeCustomKeyStoresInput) (*request.Request, *kms.DescribeCustomKeyStoresOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeCustomKeyStoresRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*kms.DescribeCustomKeyStoresOutput)
	return ret0, ret1
}

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

// DescribeCustomKeyStoresWithContext mocks base method
func (m *MockKMSAPI) DescribeCustomKeyStoresWithContext(arg0 context.Context, arg1 *kms.DescribeCustomKeyStoresInput, arg2 ...request.Option) (*kms.DescribeCustomKeyStoresOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeCustomKeyStoresWithContext", varargs...)
	ret0, _ := ret[0].(*kms.DescribeCustomKeyStoresOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeCustomKeyStoresWithContext indicates an expected call of DescribeCustomKeyStoresWithContext
func (mr *MockKMSAPIMockRecorder) DescribeCustomKeyStoresWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCustomKeyStoresWithContext", reflect.TypeOf((*MockKMSAPI)(nil).DescribeCustomKeyStoresWithContext), varargs...)
}

// DescribeKey mocks base method
func (m *MockKMSAPI) DescribeKey(arg0 *kms.DescribeKeyInput) (*kms.DescribeKeyOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeKey", arg0)
	ret0, _ := ret[0].(*kms.DescribeKeyOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeKeyRequest mocks base method
func (m *MockKMSAPI) DescribeKeyRequest(arg0 *kms.DescribeKeyInput) (*request.Request, *kms.DescribeKeyOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeKeyRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*kms.DescribeKeyOutput)
	return ret0, ret1
}

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

// DescribeKeyWithContext mocks base method
func (m *MockKMSAPI) DescribeKeyWithContext(arg0 context.Context, arg1 *kms.DescribeKeyInput, arg2 ...request.Option) (*kms.DescribeKeyOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeKeyWithContext", varargs...)
	ret0, _ := ret[0].(*kms.DescribeKeyOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeKeyWithContext indicates an expected call of DescribeKeyWithContext
func (mr *MockKMSAPIMockRecorder) DescribeKeyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeKeyWithContext", reflect.TypeOf((*MockKMSAPI)(nil).DescribeKeyWithContext), varargs...)
}

// DisableKey mocks base method
func (m *MockKMSAPI) DisableKey(arg0 *kms.DisableKeyInput) (*kms.DisableKeyOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DisableKey", arg0)
	ret0, _ := ret[0].(*kms.DisableKeyOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DisableKeyRequest mocks base method
func (m *MockKMSAPI) DisableKeyRequest(arg0 *kms.DisableKeyInput) (*request.Request, *kms.DisableKeyOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DisableKeyRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*kms.DisableKeyOutput)
	return ret0, ret1
}

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

// DisableKeyRotation mocks base method
func (m *MockKMSAPI) DisableKeyRotation(arg0 *kms.DisableKeyRotationInput) (*kms.DisableKeyRotationOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DisableKeyRotation", arg0)
	ret0, _ := ret[0].(*kms.DisableKeyRotationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DisableKeyRotationRequest mocks base method
func (m *MockKMSAPI) DisableKeyRotationRequest(arg0 *kms.DisableKeyRotationInput) (*request.Request, *kms.DisableKeyRotationOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DisableKeyRotationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*kms.DisableKeyRotationOutput)
	return ret0, ret1
}

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

// DisableKeyRotationWithContext mocks base method
func (m *MockKMSAPI) DisableKeyRotationWithContext(arg0 context.Context, arg1 *kms.DisableKeyRotationInput, arg2 ...request.Option) (*kms.DisableKeyRotationOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DisableKeyRotationWithContext", varargs...)
	ret0, _ := ret[0].(*kms.DisableKeyRotationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DisableKeyRotationWithContext indicates an expected call of DisableKeyRotationWithContext
func (mr *MockKMSAPIMockRecorder) DisableKeyRotationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableKeyRotationWithContext", reflect.TypeOf((*MockKMSAPI)(nil).DisableKeyRotationWithContext), varargs...)
}

// DisableKeyWithContext mocks base method
func (m *MockKMSAPI) DisableKeyWithContext(arg0 context.Context, arg1 *kms.DisableKeyInput, arg2 ...request.Option) (*kms.DisableKeyOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DisableKeyWithContext", varargs...)
	ret0, _ := ret[0].(*kms.DisableKeyOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DisableKeyWithContext indicates an expected call of DisableKeyWithContext
func (mr *MockKMSAPIMockRecorder) DisableKeyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableKeyWithContext", reflect.TypeOf((*MockKMSAPI)(nil).DisableKeyWithContext), varargs...)
}

// DisconnectCustomKeyStore mocks base method
func (m *MockKMSAPI) DisconnectCustomKeyStore(arg0 *kms.DisconnectCustomKeyStoreInput) (*kms.DisconnectCustomKeyStoreOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DisconnectCustomKeyStore", arg0)
	ret0, _ := ret[0].(*kms.DisconnectCustomKeyStoreOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DisconnectCustomKeyStoreRequest mocks base method
func (m *MockKMSAPI) DisconnectCustomKeyStoreRequest(arg0 *kms.DisconnectCustomKeyStoreInput) (*request.Request, *kms.DisconnectCustomKeyStoreOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DisconnectCustomKeyStoreRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*kms.DisconnectCustomKeyStoreOutput)
	return ret0, ret1
}

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

// DisconnectCustomKeyStoreWithContext mocks base method
func (m *MockKMSAPI) DisconnectCustomKeyStoreWithContext(arg0 context.Context, arg1 *kms.DisconnectCustomKeyStoreInput, arg2 ...request.Option) (*kms.DisconnectCustomKeyStoreOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DisconnectCustomKeyStoreWithContext", varargs...)
	ret0, _ := ret[0].(*kms.DisconnectCustomKeyStoreOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DisconnectCustomKeyStoreWithContext indicates an expected call of DisconnectCustomKeyStoreWithContext
func (mr *MockKMSAPIMockRecorder) DisconnectCustomKeyStoreWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisconnectCustomKeyStoreWithContext", reflect.TypeOf((*MockKMSAPI)(nil).DisconnectCustomKeyStoreWithContext), varargs...)
}

// EnableKey mocks base method
func (m *MockKMSAPI) EnableKey(arg0 *kms.EnableKeyInput) (*kms.EnableKeyOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EnableKey", arg0)
	ret0, _ := ret[0].(*kms.EnableKeyOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// EnableKeyRequest mocks base method
func (m *MockKMSAPI) EnableKeyRequest(arg0 *kms.EnableKeyInput) (*request.Request, *kms.EnableKeyOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EnableKeyRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*kms.EnableKeyOutput)
	return ret0, ret1
}

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

// EnableKeyRotation mocks base method
func (m *MockKMSAPI) EnableKeyRotation(arg0 *kms.EnableKeyRotationInput) (*kms.EnableKeyRotationOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EnableKeyRotation", arg0)
	ret0, _ := ret[0].(*kms.EnableKeyRotationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// EnableKeyRotationRequest mocks base method
func (m *MockKMSAPI) EnableKeyRotationRequest(arg0 *kms.EnableKeyRotationInput) (*request.Request, *kms.EnableKeyRotationOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EnableKeyRotationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*kms.EnableKeyRotationOutput)
	return ret0, ret1
}

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

// EnableKeyRotationWithContext mocks base method
func (m *MockKMSAPI) EnableKeyRotationWithContext(arg0 context.Context, arg1 *kms.EnableKeyRotationInput, arg2 ...request.Option) (*kms.EnableKeyRotationOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "EnableKeyRotationWithContext", varargs...)
	ret0, _ := ret[0].(*kms.EnableKeyRotationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// EnableKeyRotationWithContext indicates an expected call of EnableKeyRotationWithContext
func (mr *MockKMSAPIMockRecorder) EnableKeyRotationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableKeyRotationWithContext", reflect.TypeOf((*MockKMSAPI)(nil).EnableKeyRotationWithContext), varargs...)
}

// EnableKeyWithContext mocks base method
func (m *MockKMSAPI) EnableKeyWithContext(arg0 context.Context, arg1 *kms.EnableKeyInput, arg2 ...request.Option) (*kms.EnableKeyOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "EnableKeyWithContext", varargs...)
	ret0, _ := ret[0].(*kms.EnableKeyOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// EnableKeyWithContext indicates an expected call of EnableKeyWithContext
func (mr *MockKMSAPIMockRecorder) EnableKeyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableKeyWithContext", reflect.TypeOf((*MockKMSAPI)(nil).EnableKeyWithContext), varargs...)
}

// Encrypt mocks base method
func (m *MockKMSAPI) Encrypt(arg0 *kms.EncryptInput) (*kms.EncryptOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Encrypt", arg0)
	ret0, _ := ret[0].(*kms.EncryptOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// EncryptRequest mocks base method
func (m *MockKMSAPI) EncryptRequest(arg0 *kms.EncryptInput) (*request.Request, *kms.EncryptOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EncryptRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*kms.EncryptOutput)
	return ret0, ret1
}

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

// EncryptWithContext mocks base method
func (m *MockKMSAPI) EncryptWithContext(arg0 context.Context, arg1 *kms.EncryptInput, arg2 ...request.Option) (*kms.EncryptOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "EncryptWithContext", varargs...)
	ret0, _ := ret[0].(*kms.EncryptOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// EncryptWithContext indicates an expected call of EncryptWithContext
func (mr *MockKMSAPIMockRecorder) EncryptWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EncryptWithContext", reflect.TypeOf((*MockKMSAPI)(nil).EncryptWithContext), varargs...)
}

// GenerateDataKey mocks base method
func (m *MockKMSAPI) GenerateDataKey(arg0 *kms.GenerateDataKeyInput) (*kms.GenerateDataKeyOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GenerateDataKey", arg0)
	ret0, _ := ret[0].(*kms.GenerateDataKeyOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GenerateDataKeyPair mocks base method
func (m *MockKMSAPI) GenerateDataKeyPair(arg0 *kms.GenerateDataKeyPairInput) (*kms.GenerateDataKeyPairOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GenerateDataKeyPair", arg0)
	ret0, _ := ret[0].(*kms.GenerateDataKeyPairOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GenerateDataKeyPairRequest mocks base method
func (m *MockKMSAPI) GenerateDataKeyPairRequest(arg0 *kms.GenerateDataKeyPairInput) (*request.Request, *kms.GenerateDataKeyPairOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GenerateDataKeyPairRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*kms.GenerateDataKeyPairOutput)
	return ret0, ret1
}

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

// GenerateDataKeyPairWithContext mocks base method
func (m *MockKMSAPI) GenerateDataKeyPairWithContext(arg0 context.Context, arg1 *kms.GenerateDataKeyPairInput, arg2 ...request.Option) (*kms.GenerateDataKeyPairOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GenerateDataKeyPairWithContext", varargs...)
	ret0, _ := ret[0].(*kms.GenerateDataKeyPairOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GenerateDataKeyPairWithContext indicates an expected call of GenerateDataKeyPairWithContext
func (mr *MockKMSAPIMockRecorder) GenerateDataKeyPairWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GenerateDataKeyPairWithContext", reflect.TypeOf((*MockKMSAPI)(nil).GenerateDataKeyPairWithContext), varargs...)
}

// GenerateDataKeyPairWithoutPlaintext mocks base method
func (m *MockKMSAPI) GenerateDataKeyPairWithoutPlaintext(arg0 *kms.GenerateDataKeyPairWithoutPlaintextInput) (*kms.GenerateDataKeyPairWithoutPlaintextOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GenerateDataKeyPairWithoutPlaintext", arg0)
	ret0, _ := ret[0].(*kms.GenerateDataKeyPairWithoutPlaintextOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GenerateDataKeyPairWithoutPlaintextRequest mocks base method
func (m *MockKMSAPI) GenerateDataKeyPairWithoutPlaintextRequest(arg0 *kms.GenerateDataKeyPairWithoutPlaintextInput) (*request.Request, *kms.GenerateDataKeyPairWithoutPlaintextOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GenerateDataKeyPairWithoutPlaintextRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*kms.GenerateDataKeyPairWithoutPlaintextOutput)
	return ret0, ret1
}

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

// GenerateDataKeyPairWithoutPlaintextWithContext mocks base method
func (m *MockKMSAPI) GenerateDataKeyPairWithoutPlaintextWithContext(arg0 context.Context, arg1 *kms.GenerateDataKeyPairWithoutPlaintextInput, arg2 ...request.Option) (*kms.GenerateDataKeyPairWithoutPlaintextOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GenerateDataKeyPairWithoutPlaintextWithContext", varargs...)
	ret0, _ := ret[0].(*kms.GenerateDataKeyPairWithoutPlaintextOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GenerateDataKeyPairWithoutPlaintextWithContext indicates an expected call of GenerateDataKeyPairWithoutPlaintextWithContext
func (mr *MockKMSAPIMockRecorder) GenerateDataKeyPairWithoutPlaintextWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GenerateDataKeyPairWithoutPlaintextWithContext", reflect.TypeOf((*MockKMSAPI)(nil).GenerateDataKeyPairWithoutPlaintextWithContext), varargs...)
}

// GenerateDataKeyRequest mocks base method
func (m *MockKMSAPI) GenerateDataKeyRequest(arg0 *kms.GenerateDataKeyInput) (*request.Request, *kms.GenerateDataKeyOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GenerateDataKeyRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*kms.GenerateDataKeyOutput)
	return ret0, ret1
}

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

// GenerateDataKeyWithContext mocks base method
func (m *MockKMSAPI) GenerateDataKeyWithContext(arg0 context.Context, arg1 *kms.GenerateDataKeyInput, arg2 ...request.Option) (*kms.GenerateDataKeyOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GenerateDataKeyWithContext", varargs...)
	ret0, _ := ret[0].(*kms.GenerateDataKeyOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GenerateDataKeyWithContext indicates an expected call of GenerateDataKeyWithContext
func (mr *MockKMSAPIMockRecorder) GenerateDataKeyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GenerateDataKeyWithContext", reflect.TypeOf((*MockKMSAPI)(nil).GenerateDataKeyWithContext), varargs...)
}

// GenerateDataKeyWithoutPlaintext mocks base method
func (m *MockKMSAPI) GenerateDataKeyWithoutPlaintext(arg0 *kms.GenerateDataKeyWithoutPlaintextInput) (*kms.GenerateDataKeyWithoutPlaintextOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GenerateDataKeyWithoutPlaintext", arg0)
	ret0, _ := ret[0].(*kms.GenerateDataKeyWithoutPlaintextOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GenerateDataKeyWithoutPlaintextRequest mocks base method
func (m *MockKMSAPI) GenerateDataKeyWithoutPlaintextRequest(arg0 *kms.GenerateDataKeyWithoutPlaintextInput) (*request.Request, *kms.GenerateDataKeyWithoutPlaintextOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GenerateDataKeyWithoutPlaintextRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*kms.GenerateDataKeyWithoutPlaintextOutput)
	return ret0, ret1
}

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

// GenerateDataKeyWithoutPlaintextWithContext mocks base method
func (m *MockKMSAPI) GenerateDataKeyWithoutPlaintextWithContext(arg0 context.Context, arg1 *kms.GenerateDataKeyWithoutPlaintextInput, arg2 ...request.Option) (*kms.GenerateDataKeyWithoutPlaintextOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GenerateDataKeyWithoutPlaintextWithContext", varargs...)
	ret0, _ := ret[0].(*kms.GenerateDataKeyWithoutPlaintextOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GenerateDataKeyWithoutPlaintextWithContext indicates an expected call of GenerateDataKeyWithoutPlaintextWithContext
func (mr *MockKMSAPIMockRecorder) GenerateDataKeyWithoutPlaintextWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GenerateDataKeyWithoutPlaintextWithContext", reflect.TypeOf((*MockKMSAPI)(nil).GenerateDataKeyWithoutPlaintextWithContext), varargs...)
}

// GenerateRandom mocks base method
func (m *MockKMSAPI) GenerateRandom(arg0 *kms.GenerateRandomInput) (*kms.GenerateRandomOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GenerateRandom", arg0)
	ret0, _ := ret[0].(*kms.GenerateRandomOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GenerateRandomRequest mocks base method
func (m *MockKMSAPI) GenerateRandomRequest(arg0 *kms.GenerateRandomInput) (*request.Request, *kms.GenerateRandomOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GenerateRandomRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*kms.GenerateRandomOutput)
	return ret0, ret1
}

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

// GenerateRandomWithContext mocks base method
func (m *MockKMSAPI) GenerateRandomWithContext(arg0 context.Context, arg1 *kms.GenerateRandomInput, arg2 ...request.Option) (*kms.GenerateRandomOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GenerateRandomWithContext", varargs...)
	ret0, _ := ret[0].(*kms.GenerateRandomOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GenerateRandomWithContext indicates an expected call of GenerateRandomWithContext
func (mr *MockKMSAPIMockRecorder) GenerateRandomWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GenerateRandomWithContext", reflect.TypeOf((*MockKMSAPI)(nil).GenerateRandomWithContext), varargs...)
}

// GetKeyPolicy mocks base method
func (m *MockKMSAPI) GetKeyPolicy(arg0 *kms.GetKeyPolicyInput) (*kms.GetKeyPolicyOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetKeyPolicy", arg0)
	ret0, _ := ret[0].(*kms.GetKeyPolicyOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetKeyPolicyRequest mocks base method
func (m *MockKMSAPI) GetKeyPolicyRequest(arg0 *kms.GetKeyPolicyInput) (*request.Request, *kms.GetKeyPolicyOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetKeyPolicyRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*kms.GetKeyPolicyOutput)
	return ret0, ret1
}

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

// GetKeyPolicyWithContext mocks base method
func (m *MockKMSAPI) GetKeyPolicyWithContext(arg0 context.Context, arg1 *kms.GetKeyPolicyInput, arg2 ...request.Option) (*kms.GetKeyPolicyOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetKeyPolicyWithContext", varargs...)
	ret0, _ := ret[0].(*kms.GetKeyPolicyOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetKeyPolicyWithContext indicates an expected call of GetKeyPolicyWithContext
func (mr *MockKMSAPIMockRecorder) GetKeyPolicyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetKeyPolicyWithContext", reflect.TypeOf((*MockKMSAPI)(nil).GetKeyPolicyWithContext), varargs...)
}

// GetKeyRotationStatus mocks base method
func (m *MockKMSAPI) GetKeyRotationStatus(arg0 *kms.GetKeyRotationStatusInput) (*kms.GetKeyRotationStatusOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetKeyRotationStatus", arg0)
	ret0, _ := ret[0].(*kms.GetKeyRotationStatusOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetKeyRotationStatusRequest mocks base method
func (m *MockKMSAPI) GetKeyRotationStatusRequest(arg0 *kms.GetKeyRotationStatusInput) (*request.Request, *kms.GetKeyRotationStatusOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetKeyRotationStatusRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*kms.GetKeyRotationStatusOutput)
	return ret0, ret1
}

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

// GetKeyRotationStatusWithContext mocks base method
func (m *MockKMSAPI) GetKeyRotationStatusWithContext(arg0 context.Context, arg1 *kms.GetKeyRotationStatusInput, arg2 ...request.Option) (*kms.GetKeyRotationStatusOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetKeyRotationStatusWithContext", varargs...)
	ret0, _ := ret[0].(*kms.GetKeyRotationStatusOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetKeyRotationStatusWithContext indicates an expected call of GetKeyRotationStatusWithContext
func (mr *MockKMSAPIMockRecorder) GetKeyRotationStatusWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetKeyRotationStatusWithContext", reflect.TypeOf((*MockKMSAPI)(nil).GetKeyRotationStatusWithContext), varargs...)
}

// GetParametersForImport mocks base method
func (m *MockKMSAPI) GetParametersForImport(arg0 *kms.GetParametersForImportInput) (*kms.GetParametersForImportOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetParametersForImport", arg0)
	ret0, _ := ret[0].(*kms.GetParametersForImportOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetParametersForImportRequest mocks base method
func (m *MockKMSAPI) GetParametersForImportRequest(arg0 *kms.GetParametersForImportInput) (*request.Request, *kms.GetParametersForImportOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetParametersForImportRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*kms.GetParametersForImportOutput)
	return ret0, ret1
}

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

// GetParametersForImportWithContext mocks base method
func (m *MockKMSAPI) GetParametersForImportWithContext(arg0 context.Context, arg1 *kms.GetParametersForImportInput, arg2 ...request.Option) (*kms.GetParametersForImportOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetParametersForImportWithContext", varargs...)
	ret0, _ := ret[0].(*kms.GetParametersForImportOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetParametersForImportWithContext indicates an expected call of GetParametersForImportWithContext
func (mr *MockKMSAPIMockRecorder) GetParametersForImportWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetParametersForImportWithContext", reflect.TypeOf((*MockKMSAPI)(nil).GetParametersForImportWithContext), varargs...)
}

// GetPublicKey mocks base method
func (m *MockKMSAPI) GetPublicKey(arg0 *kms.GetPublicKeyInput) (*kms.GetPublicKeyOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPublicKey", arg0)
	ret0, _ := ret[0].(*kms.GetPublicKeyOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetPublicKeyRequest mocks base method
func (m *MockKMSAPI) GetPublicKeyRequest(arg0 *kms.GetPublicKeyInput) (*request.Request, *kms.GetPublicKeyOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPublicKeyRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*kms.GetPublicKeyOutput)
	return ret0, ret1
}

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

// GetPublicKeyWithContext mocks base method
func (m *MockKMSAPI) GetPublicKeyWithContext(arg0 context.Context, arg1 *kms.GetPublicKeyInput, arg2 ...request.Option) (*kms.GetPublicKeyOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetPublicKeyWithContext", varargs...)
	ret0, _ := ret[0].(*kms.GetPublicKeyOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetPublicKeyWithContext indicates an expected call of GetPublicKeyWithContext
func (mr *MockKMSAPIMockRecorder) GetPublicKeyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPublicKeyWithContext", reflect.TypeOf((*MockKMSAPI)(nil).GetPublicKeyWithContext), varargs...)
}

// ImportKeyMaterial mocks base method
func (m *MockKMSAPI) ImportKeyMaterial(arg0 *kms.ImportKeyMaterialInput) (*kms.ImportKeyMaterialOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ImportKeyMaterial", arg0)
	ret0, _ := ret[0].(*kms.ImportKeyMaterialOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ImportKeyMaterialRequest mocks base method
func (m *MockKMSAPI) ImportKeyMaterialRequest(arg0 *kms.ImportKeyMaterialInput) (*request.Request, *kms.ImportKeyMaterialOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ImportKeyMaterialRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*kms.ImportKeyMaterialOutput)
	return ret0, ret1
}

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

// ImportKeyMaterialWithContext mocks base method
func (m *MockKMSAPI) ImportKeyMaterialWithContext(arg0 context.Context, arg1 *kms.ImportKeyMaterialInput, arg2 ...request.Option) (*kms.ImportKeyMaterialOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ImportKeyMaterialWithContext", varargs...)
	ret0, _ := ret[0].(*kms.ImportKeyMaterialOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ImportKeyMaterialWithContext indicates an expected call of ImportKeyMaterialWithContext
func (mr *MockKMSAPIMockRecorder) ImportKeyMaterialWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportKeyMaterialWithContext", reflect.TypeOf((*MockKMSAPI)(nil).ImportKeyMaterialWithContext), varargs...)
}

// ListAliases mocks base method
func (m *MockKMSAPI) ListAliases(arg0 *kms.ListAliasesInput) (*kms.ListAliasesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListAliases", arg0)
	ret0, _ := ret[0].(*kms.ListAliasesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListAliasesPages mocks base method
func (m *MockKMSAPI) ListAliasesPages(arg0 *kms.ListAliasesInput, arg1 func(*kms.ListAliasesOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListAliasesPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListAliasesPagesWithContext mocks base method
func (m *MockKMSAPI) ListAliasesPagesWithContext(arg0 context.Context, arg1 *kms.ListAliasesInput, arg2 func(*kms.ListAliasesOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListAliasesPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListAliasesPagesWithContext indicates an expected call of ListAliasesPagesWithContext
func (mr *MockKMSAPIMockRecorder) ListAliasesPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAliasesPagesWithContext", reflect.TypeOf((*MockKMSAPI)(nil).ListAliasesPagesWithContext), varargs...)
}

// ListAliasesRequest mocks base method
func (m *MockKMSAPI) ListAliasesRequest(arg0 *kms.ListAliasesInput) (*request.Request, *kms.ListAliasesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListAliasesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*kms.ListAliasesOutput)
	return ret0, ret1
}

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

// ListAliasesWithContext mocks base method
func (m *MockKMSAPI) ListAliasesWithContext(arg0 context.Context, arg1 *kms.ListAliasesInput, arg2 ...request.Option) (*kms.ListAliasesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListAliasesWithContext", varargs...)
	ret0, _ := ret[0].(*kms.ListAliasesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListAliasesWithContext indicates an expected call of ListAliasesWithContext
func (mr *MockKMSAPIMockRecorder) ListAliasesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAliasesWithContext", reflect.TypeOf((*MockKMSAPI)(nil).ListAliasesWithContext), varargs...)
}

// ListGrants mocks base method
func (m *MockKMSAPI) ListGrants(arg0 *kms.ListGrantsInput) (*kms.ListGrantsResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListGrants", arg0)
	ret0, _ := ret[0].(*kms.ListGrantsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListGrantsPages mocks base method
func (m *MockKMSAPI) ListGrantsPages(arg0 *kms.ListGrantsInput, arg1 func(*kms.ListGrantsResponse, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListGrantsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListGrantsPagesWithContext mocks base method
func (m *MockKMSAPI) ListGrantsPagesWithContext(arg0 context.Context, arg1 *kms.ListGrantsInput, arg2 func(*kms.ListGrantsResponse, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListGrantsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListGrantsPagesWithContext indicates an expected call of ListGrantsPagesWithContext
func (mr *MockKMSAPIMockRecorder) ListGrantsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListGrantsPagesWithContext", reflect.TypeOf((*MockKMSAPI)(nil).ListGrantsPagesWithContext), varargs...)
}

// ListGrantsRequest mocks base method
func (m *MockKMSAPI) ListGrantsRequest(arg0 *kms.ListGrantsInput) (*request.Request, *kms.ListGrantsResponse) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListGrantsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*kms.ListGrantsResponse)
	return ret0, ret1
}

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

// ListGrantsWithContext mocks base method
func (m *MockKMSAPI) ListGrantsWithContext(arg0 context.Context, arg1 *kms.ListGrantsInput, arg2 ...request.Option) (*kms.ListGrantsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListGrantsWithContext", varargs...)
	ret0, _ := ret[0].(*kms.ListGrantsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListGrantsWithContext indicates an expected call of ListGrantsWithContext
func (mr *MockKMSAPIMockRecorder) ListGrantsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListGrantsWithContext", reflect.TypeOf((*MockKMSAPI)(nil).ListGrantsWithContext), varargs...)
}

// ListKeyPolicies mocks base method
func (m *MockKMSAPI) ListKeyPolicies(arg0 *kms.ListKeyPoliciesInput) (*kms.ListKeyPoliciesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListKeyPolicies", arg0)
	ret0, _ := ret[0].(*kms.ListKeyPoliciesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListKeyPoliciesPages mocks base method
func (m *MockKMSAPI) ListKeyPoliciesPages(arg0 *kms.ListKeyPoliciesInput, arg1 func(*kms.ListKeyPoliciesOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListKeyPoliciesPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListKeyPoliciesPagesWithContext mocks base method
func (m *MockKMSAPI) ListKeyPoliciesPagesWithContext(arg0 context.Context, arg1 *kms.ListKeyPoliciesInput, arg2 func(*kms.ListKeyPoliciesOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListKeyPoliciesPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListKeyPoliciesPagesWithContext indicates an expected call of ListKeyPoliciesPagesWithContext
func (mr *MockKMSAPIMockRecorder) ListKeyPoliciesPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListKeyPoliciesPagesWithContext", reflect.TypeOf((*MockKMSAPI)(nil).ListKeyPoliciesPagesWithContext), varargs...)
}

// ListKeyPoliciesRequest mocks base method
func (m *MockKMSAPI) ListKeyPoliciesRequest(arg0 *kms.ListKeyPoliciesInput) (*request.Request, *kms.ListKeyPoliciesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListKeyPoliciesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*kms.ListKeyPoliciesOutput)
	return ret0, ret1
}

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

// ListKeyPoliciesWithContext mocks base method
func (m *MockKMSAPI) ListKeyPoliciesWithContext(arg0 context.Context, arg1 *kms.ListKeyPoliciesInput, arg2 ...request.Option) (*kms.ListKeyPoliciesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListKeyPoliciesWithContext", varargs...)
	ret0, _ := ret[0].(*kms.ListKeyPoliciesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListKeyPoliciesWithContext indicates an expected call of ListKeyPoliciesWithContext
func (mr *MockKMSAPIMockRecorder) ListKeyPoliciesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListKeyPoliciesWithContext", reflect.TypeOf((*MockKMSAPI)(nil).ListKeyPoliciesWithContext), varargs...)
}

// ListKeys mocks base method
func (m *MockKMSAPI) ListKeys(arg0 *kms.ListKeysInput) (*kms.ListKeysOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListKeys", arg0)
	ret0, _ := ret[0].(*kms.ListKeysOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListKeysPages mocks base method
func (m *MockKMSAPI) ListKeysPages(arg0 *kms.ListKeysInput, arg1 func(*kms.ListKeysOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListKeysPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListKeysPagesWithContext mocks base method
func (m *MockKMSAPI) ListKeysPagesWithContext(arg0 context.Context, arg1 *kms.ListKeysInput, arg2 func(*kms.ListKeysOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListKeysPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListKeysPagesWithContext indicates an expected call of ListKeysPagesWithContext
func (mr *MockKMSAPIMockRecorder) ListKeysPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListKeysPagesWithContext", reflect.TypeOf((*MockKMSAPI)(nil).ListKeysPagesWithContext), varargs...)
}

// ListKeysRequest mocks base method
func (m *MockKMSAPI) ListKeysRequest(arg0 *kms.ListKeysInput) (*request.Request, *kms.ListKeysOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListKeysRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*kms.ListKeysOutput)
	return ret0, ret1
}

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

// ListKeysWithContext mocks base method
func (m *MockKMSAPI) ListKeysWithContext(arg0 context.Context, arg1 *kms.ListKeysInput, arg2 ...request.Option) (*kms.ListKeysOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListKeysWithContext", varargs...)
	ret0, _ := ret[0].(*kms.ListKeysOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListKeysWithContext indicates an expected call of ListKeysWithContext
func (mr *MockKMSAPIMockRecorder) ListKeysWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListKeysWithContext", reflect.TypeOf((*MockKMSAPI)(nil).ListKeysWithContext), varargs...)
}

// ListResourceTags mocks base method
func (m *MockKMSAPI) ListResourceTags(arg0 *kms.ListResourceTagsInput) (*kms.ListResourceTagsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListResourceTags", arg0)
	ret0, _ := ret[0].(*kms.ListResourceTagsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListResourceTagsRequest mocks base method
func (m *MockKMSAPI) ListResourceTagsRequest(arg0 *kms.ListResourceTagsInput) (*request.Request, *kms.ListResourceTagsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListResourceTagsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*kms.ListResourceTagsOutput)
	return ret0, ret1
}

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

// ListResourceTagsWithContext mocks base method
func (m *MockKMSAPI) ListResourceTagsWithContext(arg0 context.Context, arg1 *kms.ListResourceTagsInput, arg2 ...request.Option) (*kms.ListResourceTagsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListResourceTagsWithContext", varargs...)
	ret0, _ := ret[0].(*kms.ListResourceTagsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListResourceTagsWithContext indicates an expected call of ListResourceTagsWithContext
func (mr *MockKMSAPIMockRecorder) ListResourceTagsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListResourceTagsWithContext", reflect.TypeOf((*MockKMSAPI)(nil).ListResourceTagsWithContext), varargs...)
}

// ListRetirableGrants mocks base method
func (m *MockKMSAPI) ListRetirableGrants(arg0 *kms.ListRetirableGrantsInput) (*kms.ListGrantsResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListRetirableGrants", arg0)
	ret0, _ := ret[0].(*kms.ListGrantsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListRetirableGrantsRequest mocks base method
func (m *MockKMSAPI) ListRetirableGrantsRequest(arg0 *kms.ListRetirableGrantsInput) (*request.Request, *kms.ListGrantsResponse) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListRetirableGrantsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*kms.ListGrantsResponse)
	return ret0, ret1
}

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

// ListRetirableGrantsWithContext mocks base method
func (m *MockKMSAPI) ListRetirableGrantsWithContext(arg0 context.Context, arg1 *kms.ListRetirableGrantsInput, arg2 ...request.Option) (*kms.ListGrantsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListRetirableGrantsWithContext", varargs...)
	ret0, _ := ret[0].(*kms.ListGrantsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListRetirableGrantsWithContext indicates an expected call of ListRetirableGrantsWithContext
func (mr *MockKMSAPIMockRecorder) ListRetirableGrantsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListRetirableGrantsWithContext", reflect.TypeOf((*MockKMSAPI)(nil).ListRetirableGrantsWithContext), varargs...)
}

// PutKeyPolicy mocks base method
func (m *MockKMSAPI) PutKeyPolicy(arg0 *kms.PutKeyPolicyInput) (*kms.PutKeyPolicyOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutKeyPolicy", arg0)
	ret0, _ := ret[0].(*kms.PutKeyPolicyOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// PutKeyPolicyRequest mocks base method
func (m *MockKMSAPI) PutKeyPolicyRequest(arg0 *kms.PutKeyPolicyInput) (*request.Request, *kms.PutKeyPolicyOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutKeyPolicyRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*kms.PutKeyPolicyOutput)
	return ret0, ret1
}

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

// PutKeyPolicyWithContext mocks base method
func (m *MockKMSAPI) PutKeyPolicyWithContext(arg0 context.Context, arg1 *kms.PutKeyPolicyInput, arg2 ...request.Option) (*kms.PutKeyPolicyOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PutKeyPolicyWithContext", varargs...)
	ret0, _ := ret[0].(*kms.PutKeyPolicyOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PutKeyPolicyWithContext indicates an expected call of PutKeyPolicyWithContext
func (mr *MockKMSAPIMockRecorder) PutKeyPolicyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutKeyPolicyWithContext", reflect.TypeOf((*MockKMSAPI)(nil).PutKeyPolicyWithContext), varargs...)
}

// ReEncrypt mocks base method
func (m *MockKMSAPI) ReEncrypt(arg0 *kms.ReEncryptInput) (*kms.ReEncryptOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReEncrypt", arg0)
	ret0, _ := ret[0].(*kms.ReEncryptOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ReEncryptRequest mocks base method
func (m *MockKMSAPI) ReEncryptRequest(arg0 *kms.ReEncryptInput) (*request.Request, *kms.ReEncryptOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReEncryptRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*kms.ReEncryptOutput)
	return ret0, ret1
}

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

// ReEncryptWithContext mocks base method
func (m *MockKMSAPI) ReEncryptWithContext(arg0 context.Context, arg1 *kms.ReEncryptInput, arg2 ...request.Option) (*kms.ReEncryptOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ReEncryptWithContext", varargs...)
	ret0, _ := ret[0].(*kms.ReEncryptOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ReEncryptWithContext indicates an expected call of ReEncryptWithContext
func (mr *MockKMSAPIMockRecorder) ReEncryptWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReEncryptWithContext", reflect.TypeOf((*MockKMSAPI)(nil).ReEncryptWithContext), varargs...)
}

// RetireGrant mocks base method
func (m *MockKMSAPI) RetireGrant(arg0 *kms.RetireGrantInput) (*kms.RetireGrantOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RetireGrant", arg0)
	ret0, _ := ret[0].(*kms.RetireGrantOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RetireGrantRequest mocks base method
func (m *MockKMSAPI) RetireGrantRequest(arg0 *kms.RetireGrantInput) (*request.Request, *kms.RetireGrantOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RetireGrantRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*kms.RetireGrantOutput)
	return ret0, ret1
}

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

// RetireGrantWithContext mocks base method
func (m *MockKMSAPI) RetireGrantWithContext(arg0 context.Context, arg1 *kms.RetireGrantInput, arg2 ...request.Option) (*kms.RetireGrantOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RetireGrantWithContext", varargs...)
	ret0, _ := ret[0].(*kms.RetireGrantOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RetireGrantWithContext indicates an expected call of RetireGrantWithContext
func (mr *MockKMSAPIMockRecorder) RetireGrantWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RetireGrantWithContext", reflect.TypeOf((*MockKMSAPI)(nil).RetireGrantWithContext), varargs...)
}

// RevokeGrant mocks base method
func (m *MockKMSAPI) RevokeGrant(arg0 *kms.RevokeGrantInput) (*kms.RevokeGrantOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RevokeGrant", arg0)
	ret0, _ := ret[0].(*kms.RevokeGrantOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RevokeGrantRequest mocks base method
func (m *MockKMSAPI) RevokeGrantRequest(arg0 *kms.RevokeGrantInput) (*request.Request, *kms.RevokeGrantOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RevokeGrantRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*kms.RevokeGrantOutput)
	return ret0, ret1
}

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

// RevokeGrantWithContext mocks base method
func (m *MockKMSAPI) RevokeGrantWithContext(arg0 context.Context, arg1 *kms.RevokeGrantInput, arg2 ...request.Option) (*kms.RevokeGrantOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RevokeGrantWithContext", varargs...)
	ret0, _ := ret[0].(*kms.RevokeGrantOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RevokeGrantWithContext indicates an expected call of RevokeGrantWithContext
func (mr *MockKMSAPIMockRecorder) RevokeGrantWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RevokeGrantWithContext", reflect.TypeOf((*MockKMSAPI)(nil).RevokeGrantWithContext), varargs...)
}

// ScheduleKeyDeletion mocks base method
func (m *MockKMSAPI) ScheduleKeyDeletion(arg0 *kms.ScheduleKeyDeletionInput) (*kms.ScheduleKeyDeletionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ScheduleKeyDeletion", arg0)
	ret0, _ := ret[0].(*kms.ScheduleKeyDeletionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ScheduleKeyDeletionRequest mocks base method
func (m *MockKMSAPI) ScheduleKeyDeletionRequest(arg0 *kms.ScheduleKeyDeletionInput) (*request.Request, *kms.ScheduleKeyDeletionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ScheduleKeyDeletionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*kms.ScheduleKeyDeletionOutput)
	return ret0, ret1
}

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

// ScheduleKeyDeletionWithContext mocks base method
func (m *MockKMSAPI) ScheduleKeyDeletionWithContext(arg0 context.Context, arg1 *kms.ScheduleKeyDeletionInput, arg2 ...request.Option) (*kms.ScheduleKeyDeletionOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ScheduleKeyDeletionWithContext", varargs...)
	ret0, _ := ret[0].(*kms.ScheduleKeyDeletionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ScheduleKeyDeletionWithContext indicates an expected call of ScheduleKeyDeletionWithContext
func (mr *MockKMSAPIMockRecorder) ScheduleKeyDeletionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScheduleKeyDeletionWithContext", reflect.TypeOf((*MockKMSAPI)(nil).ScheduleKeyDeletionWithContext), varargs...)
}

// Sign mocks base method
func (m *MockKMSAPI) Sign(arg0 *kms.SignInput) (*kms.SignOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Sign", arg0)
	ret0, _ := ret[0].(*kms.SignOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SignRequest mocks base method
func (m *MockKMSAPI) SignRequest(arg0 *kms.SignInput) (*request.Request, *kms.SignOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SignRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*kms.SignOutput)
	return ret0, ret1
}

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

// SignWithContext mocks base method
func (m *MockKMSAPI) SignWithContext(arg0 context.Context, arg1 *kms.SignInput, arg2 ...request.Option) (*kms.SignOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SignWithContext", varargs...)
	ret0, _ := ret[0].(*kms.SignOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SignWithContext indicates an expected call of SignWithContext
func (mr *MockKMSAPIMockRecorder) SignWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignWithContext", reflect.TypeOf((*MockKMSAPI)(nil).SignWithContext), varargs...)
}

// TagResource mocks base method
func (m *MockKMSAPI) TagResource(arg0 *kms.TagResourceInput) (*kms.TagResourceOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TagResource", arg0)
	ret0, _ := ret[0].(*kms.TagResourceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// TagResourceRequest mocks base method
func (m *MockKMSAPI) TagResourceRequest(arg0 *kms.TagResourceInput) (*request.Request, *kms.TagResourceOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TagResourceRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*kms.TagResourceOutput)
	return ret0, ret1
}

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

// TagResourceWithContext mocks base method
func (m *MockKMSAPI) TagResourceWithContext(arg0 context.Context, arg1 *kms.TagResourceInput, arg2 ...request.Option) (*kms.TagResourceOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "TagResourceWithContext", varargs...)
	ret0, _ := ret[0].(*kms.TagResourceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// TagResourceWithContext indicates an expected call of TagResourceWithContext
func (mr *MockKMSAPIMockRecorder) TagResourceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TagResourceWithContext", reflect.TypeOf((*MockKMSAPI)(nil).TagResourceWithContext), varargs...)
}

// UntagResource mocks base method
func (m *MockKMSAPI) UntagResource(arg0 *kms.UntagResourceInput) (*kms.UntagResourceOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UntagResource", arg0)
	ret0, _ := ret[0].(*kms.UntagResourceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UntagResourceRequest mocks base method
func (m *MockKMSAPI) UntagResourceRequest(arg0 *kms.UntagResourceInput) (*request.Request, *kms.UntagResourceOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UntagResourceRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*kms.UntagResourceOutput)
	return ret0, ret1
}

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

// UntagResourceWithContext mocks base method
func (m *MockKMSAPI) UntagResourceWithContext(arg0 context.Context, arg1 *kms.UntagResourceInput, arg2 ...request.Option) (*kms.UntagResourceOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UntagResourceWithContext", varargs...)
	ret0, _ := ret[0].(*kms.UntagResourceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UntagResourceWithContext indicates an expected call of UntagResourceWithContext
func (mr *MockKMSAPIMockRecorder) UntagResourceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UntagResourceWithContext", reflect.TypeOf((*MockKMSAPI)(nil).UntagResourceWithContext), varargs...)
}

// UpdateAlias mocks base method
func (m *MockKMSAPI) UpdateAlias(arg0 *kms.UpdateAliasInput) (*kms.UpdateAliasOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateAlias", arg0)
	ret0, _ := ret[0].(*kms.UpdateAliasOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateAliasRequest mocks base method
func (m *MockKMSAPI) UpdateAliasRequest(arg0 *kms.UpdateAliasInput) (*request.Request, *kms.UpdateAliasOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateAliasRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*kms.UpdateAliasOutput)
	return ret0, ret1
}

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

// UpdateAliasWithContext mocks base method
func (m *MockKMSAPI) UpdateAliasWithContext(arg0 context.Context, arg1 *kms.UpdateAliasInput, arg2 ...request.Option) (*kms.UpdateAliasOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateAliasWithContext", varargs...)
	ret0, _ := ret[0].(*kms.UpdateAliasOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateAliasWithContext indicates an expected call of UpdateAliasWithContext
func (mr *MockKMSAPIMockRecorder) UpdateAliasWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateAliasWithContext", reflect.TypeOf((*MockKMSAPI)(nil).UpdateAliasWithContext), varargs...)
}

// UpdateCustomKeyStore mocks base method
func (m *MockKMSAPI) UpdateCustomKeyStore(arg0 *kms.UpdateCustomKeyStoreInput) (*kms.UpdateCustomKeyStoreOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateCustomKeyStore", arg0)
	ret0, _ := ret[0].(*kms.UpdateCustomKeyStoreOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateCustomKeyStoreRequest mocks base method
func (m *MockKMSAPI) UpdateCustomKeyStoreRequest(arg0 *kms.UpdateCustomKeyStoreInput) (*request.Request, *kms.UpdateCustomKeyStoreOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateCustomKeyStoreRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*kms.UpdateCustomKeyStoreOutput)
	return ret0, ret1
}

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

// UpdateCustomKeyStoreWithContext mocks base method
func (m *MockKMSAPI) UpdateCustomKeyStoreWithContext(arg0 context.Context, arg1 *kms.UpdateCustomKeyStoreInput, arg2 ...request.Option) (*kms.UpdateCustomKeyStoreOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateCustomKeyStoreWithContext", varargs...)
	ret0, _ := ret[0].(*kms.UpdateCustomKeyStoreOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateCustomKeyStoreWithContext indicates an expected call of UpdateCustomKeyStoreWithContext
func (mr *MockKMSAPIMockRecorder) UpdateCustomKeyStoreWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateCustomKeyStoreWithContext", reflect.TypeOf((*MockKMSAPI)(nil).UpdateCustomKeyStoreWithContext), varargs...)
}

// UpdateKeyDescription mocks base method
func (m *MockKMSAPI) UpdateKeyDescription(arg0 *kms.UpdateKeyDescriptionInput) (*kms.UpdateKeyDescriptionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateKeyDescription", arg0)
	ret0, _ := ret[0].(*kms.UpdateKeyDescriptionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateKeyDescriptionRequest mocks base method
func (m *MockKMSAPI) UpdateKeyDescriptionRequest(arg0 *kms.UpdateKeyDescriptionInput) (*request.Request, *kms.UpdateKeyDescriptionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateKeyDescriptionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*kms.UpdateKeyDescriptionOutput)
	return ret0, ret1
}

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

// UpdateKeyDescriptionWithContext mocks base method
func (m *MockKMSAPI) UpdateKeyDescriptionWithContext(arg0 context.Context, arg1 *kms.UpdateKeyDescriptionInput, arg2 ...request.Option) (*kms.UpdateKeyDescriptionOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateKeyDescriptionWithContext", varargs...)
	ret0, _ := ret[0].(*kms.UpdateKeyDescriptionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateKeyDescriptionWithContext indicates an expected call of UpdateKeyDescriptionWithContext
func (mr *MockKMSAPIMockRecorder) UpdateKeyDescriptionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateKeyDescriptionWithContext", reflect.TypeOf((*MockKMSAPI)(nil).UpdateKeyDescriptionWithContext), varargs...)
}

// Verify mocks base method
func (m *MockKMSAPI) Verify(arg0 *kms.VerifyInput) (*kms.VerifyOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Verify", arg0)
	ret0, _ := ret[0].(*kms.VerifyOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// VerifyRequest mocks base method
func (m *MockKMSAPI) VerifyRequest(arg0 *kms.VerifyInput) (*request.Request, *kms.VerifyOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "VerifyRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*kms.VerifyOutput)
	return ret0, ret1
}

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

// VerifyWithContext mocks base method
func (m *MockKMSAPI) VerifyWithContext(arg0 context.Context, arg1 *kms.VerifyInput, arg2 ...request.Option) (*kms.VerifyOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "VerifyWithContext", varargs...)
	ret0, _ := ret[0].(*kms.VerifyOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// VerifyWithContext indicates an expected call of VerifyWithContext
func (mr *MockKMSAPIMockRecorder) VerifyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VerifyWithContext", reflect.TypeOf((*MockKMSAPI)(nil).VerifyWithContext), varargs...)
}
