From ee6a45f769666284c5b191d23e0c8190c274f4ef Mon Sep 17 00:00:00 2001 From: Travis Cline Date: Sat, 1 Dec 2018 15:37:10 -0800 Subject: [PATCH] gmockgen: make go-gettable, convert to go modules --- Makefile | 6 +- cli.go | 7 +- commands.go | 2 +- go.mod | 10 + go.sum | 31 + src/gcredstash/base64_test.go | 2 +- src/gcredstash/command/delete.go | 3 +- src/gcredstash/command/detele_test.go | 2 +- src/gcredstash/command/get.go | 2 +- src/gcredstash/command/get_test.go | 6 +- src/gcredstash/command/getall.go | 2 +- src/gcredstash/command/getall_test.go | 2 +- src/gcredstash/command/list.go | 2 +- src/gcredstash/command/list_test.go | 2 +- src/gcredstash/command/meta.go | 2 +- src/gcredstash/command/put.go | 2 +- src/gcredstash/command/put_test.go | 2 +- src/gcredstash/command/setup_test.go | 2 +- src/gcredstash/command/template.go | 2 +- src/gcredstash/command/template_test.go | 2 +- src/gcredstash/crypt_test.go | 2 +- src/gcredstash/driver_setup_test.go | 2 +- src/gcredstash/driver_test.go | 2 +- src/gcredstash/hex_test.go | 2 +- src/gcredstash/kms_test.go | 2 +- src/gcredstash/optparse_test.go | 2 +- src/gcredstash/utils_test.go | 2 +- src/mockaws/dynamodbmock.go | 1375 ++++++++++++++++------- src/mockaws/kmsmock.go | 1223 ++++++++++---------- 29 files changed, 1680 insertions(+), 1023 deletions(-) create mode 100644 go.mod create mode 100644 go.sum diff --git a/Makefile b/Makefile index 9f5e580..5f2b311 100644 --- a/Makefile +++ b/Makefile @@ -25,11 +25,7 @@ test: go-get $(TEST_SRC) $(CMD_TEST_SRC) GOPATH=$(RUNTIME_GOPATH) go test -v $(CMD_TEST_SRC) go-get: - go get github.com/mitchellh/cli - go get github.com/aws/aws-sdk-go - go get github.com/ryanuber/go-glob - go get github.com/golang/mock/gomock - go get github.com/mattn/go-shellwords + go get clean: rm -f gcredstash{,.exe} *.gz *.zip diff --git a/cli.go b/cli.go index 4197616..543f151 100644 --- a/cli.go +++ b/cli.go @@ -2,13 +2,14 @@ package main import ( "fmt" - "gcredstash" - "gcredstash/command" + "os" + "github.com/aws/aws-sdk-go/aws/session" "github.com/aws/aws-sdk-go/service/dynamodb" "github.com/aws/aws-sdk-go/service/kms" "github.com/mitchellh/cli" - "os" + "github.com/winebarrel/gcredstash/src/gcredstash" + "github.com/winebarrel/gcredstash/src/gcredstash/command" ) func Run(args []string) int { diff --git a/commands.go b/commands.go index e29c845..0e4640b 100644 --- a/commands.go +++ b/commands.go @@ -1,8 +1,8 @@ package main import ( - "gcredstash/command" "github.com/mitchellh/cli" + "github.com/winebarrel/gcredstash/src/gcredstash/command" ) func Commands(meta *command.Meta) map[string]cli.CommandFactory { diff --git a/go.mod b/go.mod new file mode 100644 index 0000000..b21db4d --- /dev/null +++ b/go.mod @@ -0,0 +1,10 @@ +module github.com/winebarrel/gcredstash + +require ( + github.com/aws/aws-sdk-go v1.15.88 + github.com/golang/mock v1.1.1 + github.com/mattn/go-shellwords v1.0.3 + github.com/mitchellh/cli v1.0.0 + github.com/ryanuber/go-glob v0.0.0-20170128012129-256dc444b735 + golang.org/x/net v0.0.0-20181201002055-351d144fa1fc // indirect +) diff --git a/go.sum b/go.sum new file mode 100644 index 0000000..8d4b95f --- /dev/null +++ b/go.sum @@ -0,0 +1,31 @@ +github.com/armon/go-radix v0.0.0-20180808171621-7fddfc383310 h1:BUAU3CGlLvorLI26FmByPp2eC2qla6E1Tw+scpcg/to= +github.com/armon/go-radix v0.0.0-20180808171621-7fddfc383310/go.mod h1:ufUuZ+zHj4x4TnLV4JWEpy2hxWSpsRywHrMgIH9cCH8= +github.com/aws/aws-sdk-go v1.15.88 h1:Om0MayFrixOds/PrbBey2Cg/lkNEIyOrAF2RFXLwmnE= +github.com/aws/aws-sdk-go v1.15.88/go.mod h1:es1KtYUFs7le0xQ3rOihkuoVD90z7D0fR2Qm4S00/gU= +github.com/bgentry/speakeasy v0.1.0 h1:ByYyxL9InA1OWqxJqqp2A5pYHUrCiAL6K3J+LKSsQkY= +github.com/bgentry/speakeasy v0.1.0/go.mod h1:+zsyZBPWlz7T6j88CTgSN5bM796AkVf0kBD4zp0CCIs= +github.com/fatih/color v1.7.0 h1:DkWD4oS2D8LGGgTQ6IvwJJXSL5Vp2ffcQg58nFV38Ys= +github.com/fatih/color v1.7.0/go.mod h1:Zm6kSWBoL9eyXnKyktHP6abPY2pDugNf5KwzbycvMj4= +github.com/golang/mock v1.1.1 h1:G5FRp8JnTd7RQH5kemVNlMeyXQAztQ3mOWV95KxsXH8= +github.com/golang/mock v1.1.1/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A= +github.com/hashicorp/errwrap v1.0.0 h1:hLrqtEDnRye3+sgx6z4qVLNuviH3MR5aQ0ykNJa/UYA= +github.com/hashicorp/errwrap v1.0.0/go.mod h1:YH+1FKiLXxHSkmPseP+kNlulaMuP3n2brvKWEqk/Jc4= +github.com/hashicorp/go-multierror v1.0.0 h1:iVjPR7a6H0tWELX5NxNe7bYopibicUzc7uPribsnS6o= +github.com/hashicorp/go-multierror v1.0.0/go.mod h1:dHtQlpGsu+cZNNAkkCN/P3hoUDHhCYQXV3UM06sGGrk= +github.com/jmespath/go-jmespath v0.0.0-20160202185014-0b12d6b521d8 h1:12VvqtR6Aowv3l/EQUlocDHW2Cp4G9WJVH7uyH8QFJE= +github.com/jmespath/go-jmespath v0.0.0-20160202185014-0b12d6b521d8/go.mod h1:Nht3zPeWKUH0NzdCt2Blrr5ys8VGpn0CEB0cQHVjt7k= +github.com/mattn/go-colorable v0.0.9 h1:UVL0vNpWh04HeJXV0KLcaT7r06gOH2l4OW6ddYRUIY4= +github.com/mattn/go-colorable v0.0.9/go.mod h1:9vuHe8Xs5qXnSaW/c/ABM9alt+Vo+STaOChaDxuIBZU= +github.com/mattn/go-isatty v0.0.3 h1:ns/ykhmWi7G9O+8a448SecJU3nSMBXJfqQkl0upE1jI= +github.com/mattn/go-isatty v0.0.3/go.mod h1:M+lRXTBqGeGNdLjl/ufCoiOlB5xdOkqRJdNxMWT7Zi4= +github.com/mattn/go-shellwords v1.0.3 h1:K/VxK7SZ+cvuPgFSLKi5QPI9Vr/ipOf4C1gN+ntueUk= +github.com/mattn/go-shellwords v1.0.3/go.mod h1:3xCvwCdWdlDJUrvuMn7Wuy9eWs4pE8vqg+NOMyg4B2o= +github.com/mitchellh/cli v1.0.0 h1:iGBIsUe3+HZ/AD/Vd7DErOt5sU9fa8Uj7A2s1aggv1Y= +github.com/mitchellh/cli v1.0.0/go.mod h1:hNIlj7HEI86fIcpObd7a0FcrxTWetlwJDGcceTlRvqc= +github.com/posener/complete v1.1.1 h1:ccV59UEOTzVDnDUEFdT95ZzHVZ+5+158q8+SJb2QV5w= +github.com/posener/complete v1.1.1/go.mod h1:em0nMJCgc9GFtwrmVmEMR/ZL6WyhyjMBndrE9hABlRI= +github.com/ryanuber/go-glob v0.0.0-20170128012129-256dc444b735 h1:7YvPJVmEeFHR1Tj9sZEYsmarJEQfMVYpd/Vyy/A8dqE= +github.com/ryanuber/go-glob v0.0.0-20170128012129-256dc444b735/go.mod h1:807d1WSdnB0XRJzKNil9Om6lcp/3a0v4qIHxIXzX/Yc= +golang.org/x/net v0.0.0-20181201002055-351d144fa1fc h1:a3CU5tJYVj92DY2LaA1kUkrsqD5/3mLDhx2NcNqyW+0= +golang.org/x/net v0.0.0-20181201002055-351d144fa1fc/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= +golang.org/x/sys v0.0.0-20180823144017-11551d06cbcc/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= diff --git a/src/gcredstash/base64_test.go b/src/gcredstash/base64_test.go index 6a8b251..032397c 100644 --- a/src/gcredstash/base64_test.go +++ b/src/gcredstash/base64_test.go @@ -1,7 +1,7 @@ package gcredstash import ( - . "gcredstash" + . "github.com/winebarrel/gcredstash/src/gcredstash" "testing" ) diff --git a/src/gcredstash/command/delete.go b/src/gcredstash/command/delete.go index ae7e0bf..96f7492 100644 --- a/src/gcredstash/command/delete.go +++ b/src/gcredstash/command/delete.go @@ -2,9 +2,10 @@ package command import ( "fmt" - "gcredstash" "os" "strings" + + "github.com/winebarrel/gcredstash/src/gcredstash" ) type DeleteCommand struct { diff --git a/src/gcredstash/command/detele_test.go b/src/gcredstash/command/detele_test.go index eb5abe0..f1d119d 100644 --- a/src/gcredstash/command/detele_test.go +++ b/src/gcredstash/command/detele_test.go @@ -1,7 +1,7 @@ package command import ( - "gcredstash" + "github.com/winebarrel/gcredstash/src/gcredstash" . "gcredstash/command" "gcredstash/testutils" "github.com/aws/aws-sdk-go/aws" diff --git a/src/gcredstash/command/get.go b/src/gcredstash/command/get.go index 247d5c8..7e09e78 100644 --- a/src/gcredstash/command/get.go +++ b/src/gcredstash/command/get.go @@ -2,7 +2,7 @@ package command import ( "fmt" - "gcredstash" + "github.com/winebarrel/gcredstash/src/gcredstash" "github.com/ryanuber/go-glob" "os" "strings" diff --git a/src/gcredstash/command/get_test.go b/src/gcredstash/command/get_test.go index 289583d..2ff9db6 100644 --- a/src/gcredstash/command/get_test.go +++ b/src/gcredstash/command/get_test.go @@ -1,7 +1,7 @@ package command import ( - "gcredstash" + "github.com/winebarrel/gcredstash/src/gcredstash" . "gcredstash/command" "gcredstash/testutils" "github.com/aws/aws-sdk-go/aws" @@ -392,7 +392,7 @@ func TestGetCommandWithE(t *testing.T) { }, } - tmpfile, _ := ioutil.TempFile("", "gcredstash") + tmpfile, _ := ioutil.TempFile("", "github.com/winebarrel/gcredstash/src/gcredstash") defer os.Remove(tmpfile.Name()) args := []string{"-e", tmpfile.Name(), name} @@ -448,7 +448,7 @@ func TestGetCommandWithErrOutEnv(t *testing.T) { }, } - tmpfile, _ := ioutil.TempFile("", "gcredstash") + tmpfile, _ := ioutil.TempFile("", "github.com/winebarrel/gcredstash/src/gcredstash") defer os.Remove(tmpfile.Name()) args := []string{name} diff --git a/src/gcredstash/command/getall.go b/src/gcredstash/command/getall.go index 0263f34..5e190f4 100644 --- a/src/gcredstash/command/getall.go +++ b/src/gcredstash/command/getall.go @@ -2,7 +2,7 @@ package command import ( "fmt" - "gcredstash" + "github.com/winebarrel/gcredstash/src/gcredstash" "os" "strings" ) diff --git a/src/gcredstash/command/getall_test.go b/src/gcredstash/command/getall_test.go index a1f3c26..ace3dc5 100644 --- a/src/gcredstash/command/getall_test.go +++ b/src/gcredstash/command/getall_test.go @@ -1,7 +1,7 @@ package command import ( - "gcredstash" + "github.com/winebarrel/gcredstash/src/gcredstash" . "gcredstash/command" "gcredstash/testutils" "github.com/aws/aws-sdk-go/aws" diff --git a/src/gcredstash/command/list.go b/src/gcredstash/command/list.go index e0b43d3..2845689 100644 --- a/src/gcredstash/command/list.go +++ b/src/gcredstash/command/list.go @@ -2,7 +2,7 @@ package command import ( "fmt" - "gcredstash" + "github.com/winebarrel/gcredstash/src/gcredstash" "os" "sort" "strings" diff --git a/src/gcredstash/command/list_test.go b/src/gcredstash/command/list_test.go index eb7b5f7..6a807ec 100644 --- a/src/gcredstash/command/list_test.go +++ b/src/gcredstash/command/list_test.go @@ -2,7 +2,7 @@ package command import ( "fmt" - "gcredstash" + "github.com/winebarrel/gcredstash/src/gcredstash" . "gcredstash/command" "gcredstash/testutils" "github.com/aws/aws-sdk-go/aws" diff --git a/src/gcredstash/command/meta.go b/src/gcredstash/command/meta.go index 1f5948e..fc37245 100644 --- a/src/gcredstash/command/meta.go +++ b/src/gcredstash/command/meta.go @@ -1,7 +1,7 @@ package command import ( - "gcredstash" + "github.com/winebarrel/gcredstash/src/gcredstash" "github.com/mitchellh/cli" ) diff --git a/src/gcredstash/command/put.go b/src/gcredstash/command/put.go index ab88446..c092813 100644 --- a/src/gcredstash/command/put.go +++ b/src/gcredstash/command/put.go @@ -2,7 +2,7 @@ package command import ( "fmt" - "gcredstash" + "github.com/winebarrel/gcredstash/src/gcredstash" "os" "strings" ) diff --git a/src/gcredstash/command/put_test.go b/src/gcredstash/command/put_test.go index d5c0a14..c4bef91 100644 --- a/src/gcredstash/command/put_test.go +++ b/src/gcredstash/command/put_test.go @@ -1,7 +1,7 @@ package command import ( - "gcredstash" + "github.com/winebarrel/gcredstash/src/gcredstash" . "gcredstash/command" "gcredstash/testutils" "github.com/aws/aws-sdk-go/aws" diff --git a/src/gcredstash/command/setup_test.go b/src/gcredstash/command/setup_test.go index b793dd2..070a6b8 100644 --- a/src/gcredstash/command/setup_test.go +++ b/src/gcredstash/command/setup_test.go @@ -1,7 +1,7 @@ package command import ( - "gcredstash" + "github.com/winebarrel/gcredstash/src/gcredstash" . "gcredstash/command" "github.com/aws/aws-sdk-go/aws" "github.com/aws/aws-sdk-go/service/dynamodb" diff --git a/src/gcredstash/command/template.go b/src/gcredstash/command/template.go index d456a83..247925b 100644 --- a/src/gcredstash/command/template.go +++ b/src/gcredstash/command/template.go @@ -3,7 +3,7 @@ package command import ( "bytes" "fmt" - "gcredstash" + "github.com/winebarrel/gcredstash/src/gcredstash" "github.com/mattn/go-shellwords" "text/template" "io/ioutil" diff --git a/src/gcredstash/command/template_test.go b/src/gcredstash/command/template_test.go index 34b1914..3afc522 100644 --- a/src/gcredstash/command/template_test.go +++ b/src/gcredstash/command/template_test.go @@ -1,7 +1,7 @@ package command import ( - "gcredstash" + "github.com/winebarrel/gcredstash/src/gcredstash" . "gcredstash/command" "gcredstash/testutils" "github.com/aws/aws-sdk-go/aws" diff --git a/src/gcredstash/crypt_test.go b/src/gcredstash/crypt_test.go index 1180cb8..e171451 100644 --- a/src/gcredstash/crypt_test.go +++ b/src/gcredstash/crypt_test.go @@ -2,7 +2,7 @@ package gcredstash import ( "bytes" - . "gcredstash" + . "github.com/winebarrel/gcredstash/src/gcredstash" "testing" ) diff --git a/src/gcredstash/driver_setup_test.go b/src/gcredstash/driver_setup_test.go index 80734b0..34b29f5 100644 --- a/src/gcredstash/driver_setup_test.go +++ b/src/gcredstash/driver_setup_test.go @@ -1,7 +1,7 @@ package gcredstash import ( - . "gcredstash" + . "github.com/winebarrel/gcredstash/src/gcredstash" "github.com/aws/aws-sdk-go/aws" "github.com/aws/aws-sdk-go/service/dynamodb" "github.com/golang/mock/gomock" diff --git a/src/gcredstash/driver_test.go b/src/gcredstash/driver_test.go index 467ffdb..5c25090 100644 --- a/src/gcredstash/driver_test.go +++ b/src/gcredstash/driver_test.go @@ -1,7 +1,7 @@ package gcredstash import ( - . "gcredstash" + . "github.com/winebarrel/gcredstash/src/gcredstash" "gcredstash/testutils" "github.com/aws/aws-sdk-go/aws" "github.com/aws/aws-sdk-go/service/dynamodb" diff --git a/src/gcredstash/hex_test.go b/src/gcredstash/hex_test.go index 2369906..ea5f998 100644 --- a/src/gcredstash/hex_test.go +++ b/src/gcredstash/hex_test.go @@ -1,7 +1,7 @@ package gcredstash import ( - . "gcredstash" + . "github.com/winebarrel/gcredstash/src/gcredstash" "testing" ) diff --git a/src/gcredstash/kms_test.go b/src/gcredstash/kms_test.go index 45538b8..775048c 100644 --- a/src/gcredstash/kms_test.go +++ b/src/gcredstash/kms_test.go @@ -2,7 +2,7 @@ package gcredstash import ( "bytes" - . "gcredstash" + . "github.com/winebarrel/gcredstash/src/gcredstash" "github.com/aws/aws-sdk-go/aws" "github.com/aws/aws-sdk-go/service/kms" "github.com/golang/mock/gomock" diff --git a/src/gcredstash/optparse_test.go b/src/gcredstash/optparse_test.go index d2d4cbc..af91670 100644 --- a/src/gcredstash/optparse_test.go +++ b/src/gcredstash/optparse_test.go @@ -1,7 +1,7 @@ package gcredstash import ( - . "gcredstash" + . "github.com/winebarrel/gcredstash/src/gcredstash" "reflect" "testing" ) diff --git a/src/gcredstash/utils_test.go b/src/gcredstash/utils_test.go index 8fc4007..d14ba18 100644 --- a/src/gcredstash/utils_test.go +++ b/src/gcredstash/utils_test.go @@ -1,7 +1,7 @@ package gcredstash import ( - . "gcredstash" + . "github.com/winebarrel/gcredstash/src/gcredstash" "testing" ) diff --git a/src/mockaws/dynamodbmock.go b/src/mockaws/dynamodbmock.go index a71ab96..ca7051a 100644 --- a/src/mockaws/dynamodbmock.go +++ b/src/mockaws/dynamodbmock.go @@ -1,6 +1,7 @@ // Code generated by MockGen. DO NOT EDIT. -// Source: /Users/sugawara/.go/src/github.com/aws/aws-sdk-go/service/dynamodb/dynamodbiface/interface.go +// Source: /Users/tmc/go/src/github.com/aws/aws-sdk-go/service/dynamodb/dynamodbiface/interface.go +// Package mockaws is a generated GoMock package. package mockaws import ( @@ -30,1016 +31,1632 @@ func NewMockDynamoDBAPI(ctrl *gomock.Controller) *MockDynamoDBAPI { } // EXPECT returns an object that allows the caller to indicate expected use -func (_m *MockDynamoDBAPI) EXPECT() *MockDynamoDBAPIMockRecorder { - return _m.recorder +func (m *MockDynamoDBAPI) EXPECT() *MockDynamoDBAPIMockRecorder { + return m.recorder } // BatchGetItem mocks base method -func (_m *MockDynamoDBAPI) BatchGetItem(_param0 *dynamodb.BatchGetItemInput) (*dynamodb.BatchGetItemOutput, error) { - ret := _m.ctrl.Call(_m, "BatchGetItem", _param0) +func (m *MockDynamoDBAPI) BatchGetItem(arg0 *dynamodb.BatchGetItemInput) (*dynamodb.BatchGetItemOutput, error) { + ret := m.ctrl.Call(m, "BatchGetItem", arg0) ret0, _ := ret[0].(*dynamodb.BatchGetItemOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // BatchGetItem indicates an expected call of BatchGetItem -func (_mr *MockDynamoDBAPIMockRecorder) BatchGetItem(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "BatchGetItem", reflect.TypeOf((*MockDynamoDBAPI)(nil).BatchGetItem), arg0) +func (mr *MockDynamoDBAPIMockRecorder) BatchGetItem(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchGetItem", reflect.TypeOf((*MockDynamoDBAPI)(nil).BatchGetItem), arg0) } // BatchGetItemWithContext mocks base method -func (_m *MockDynamoDBAPI) BatchGetItemWithContext(_param0 aws.Context, _param1 *dynamodb.BatchGetItemInput, _param2 ...request.Option) (*dynamodb.BatchGetItemOutput, error) { - _s := []interface{}{_param0, _param1} - for _, _x := range _param2 { - _s = append(_s, _x) +func (m *MockDynamoDBAPI) BatchGetItemWithContext(arg0 aws.Context, arg1 *dynamodb.BatchGetItemInput, arg2 ...request.Option) (*dynamodb.BatchGetItemOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) } - ret := _m.ctrl.Call(_m, "BatchGetItemWithContext", _s...) + ret := m.ctrl.Call(m, "BatchGetItemWithContext", varargs...) ret0, _ := ret[0].(*dynamodb.BatchGetItemOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // BatchGetItemWithContext indicates an expected call of BatchGetItemWithContext -func (_mr *MockDynamoDBAPIMockRecorder) BatchGetItemWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - _s := append([]interface{}{arg0, arg1}, arg2...) - return _mr.mock.ctrl.RecordCall(_mr.mock, "BatchGetItemWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).BatchGetItemWithContext), _s...) +func (mr *MockDynamoDBAPIMockRecorder) BatchGetItemWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchGetItemWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).BatchGetItemWithContext), varargs...) } // BatchGetItemRequest mocks base method -func (_m *MockDynamoDBAPI) BatchGetItemRequest(_param0 *dynamodb.BatchGetItemInput) (*request.Request, *dynamodb.BatchGetItemOutput) { - ret := _m.ctrl.Call(_m, "BatchGetItemRequest", _param0) +func (m *MockDynamoDBAPI) BatchGetItemRequest(arg0 *dynamodb.BatchGetItemInput) (*request.Request, *dynamodb.BatchGetItemOutput) { + ret := m.ctrl.Call(m, "BatchGetItemRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*dynamodb.BatchGetItemOutput) return ret0, ret1 } // BatchGetItemRequest indicates an expected call of BatchGetItemRequest -func (_mr *MockDynamoDBAPIMockRecorder) BatchGetItemRequest(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "BatchGetItemRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).BatchGetItemRequest), arg0) +func (mr *MockDynamoDBAPIMockRecorder) BatchGetItemRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchGetItemRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).BatchGetItemRequest), arg0) } // BatchGetItemPages mocks base method -func (_m *MockDynamoDBAPI) BatchGetItemPages(_param0 *dynamodb.BatchGetItemInput, _param1 func(*dynamodb.BatchGetItemOutput, bool) bool) error { - ret := _m.ctrl.Call(_m, "BatchGetItemPages", _param0, _param1) +func (m *MockDynamoDBAPI) BatchGetItemPages(arg0 *dynamodb.BatchGetItemInput, arg1 func(*dynamodb.BatchGetItemOutput, bool) bool) error { + ret := m.ctrl.Call(m, "BatchGetItemPages", arg0, arg1) ret0, _ := ret[0].(error) return ret0 } // BatchGetItemPages indicates an expected call of BatchGetItemPages -func (_mr *MockDynamoDBAPIMockRecorder) BatchGetItemPages(arg0, arg1 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "BatchGetItemPages", reflect.TypeOf((*MockDynamoDBAPI)(nil).BatchGetItemPages), arg0, arg1) +func (mr *MockDynamoDBAPIMockRecorder) BatchGetItemPages(arg0, arg1 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchGetItemPages", reflect.TypeOf((*MockDynamoDBAPI)(nil).BatchGetItemPages), arg0, arg1) } // BatchGetItemPagesWithContext mocks base method -func (_m *MockDynamoDBAPI) BatchGetItemPagesWithContext(_param0 aws.Context, _param1 *dynamodb.BatchGetItemInput, _param2 func(*dynamodb.BatchGetItemOutput, bool) bool, _param3 ...request.Option) error { - _s := []interface{}{_param0, _param1, _param2} - for _, _x := range _param3 { - _s = append(_s, _x) +func (m *MockDynamoDBAPI) BatchGetItemPagesWithContext(arg0 aws.Context, arg1 *dynamodb.BatchGetItemInput, arg2 func(*dynamodb.BatchGetItemOutput, bool) bool, arg3 ...request.Option) error { + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) } - ret := _m.ctrl.Call(_m, "BatchGetItemPagesWithContext", _s...) + ret := m.ctrl.Call(m, "BatchGetItemPagesWithContext", varargs...) ret0, _ := ret[0].(error) return ret0 } // BatchGetItemPagesWithContext indicates an expected call of BatchGetItemPagesWithContext -func (_mr *MockDynamoDBAPIMockRecorder) BatchGetItemPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { - _s := append([]interface{}{arg0, arg1, arg2}, arg3...) - return _mr.mock.ctrl.RecordCall(_mr.mock, "BatchGetItemPagesWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).BatchGetItemPagesWithContext), _s...) +func (mr *MockDynamoDBAPIMockRecorder) BatchGetItemPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchGetItemPagesWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).BatchGetItemPagesWithContext), varargs...) } // BatchWriteItem mocks base method -func (_m *MockDynamoDBAPI) BatchWriteItem(_param0 *dynamodb.BatchWriteItemInput) (*dynamodb.BatchWriteItemOutput, error) { - ret := _m.ctrl.Call(_m, "BatchWriteItem", _param0) +func (m *MockDynamoDBAPI) BatchWriteItem(arg0 *dynamodb.BatchWriteItemInput) (*dynamodb.BatchWriteItemOutput, error) { + ret := m.ctrl.Call(m, "BatchWriteItem", arg0) ret0, _ := ret[0].(*dynamodb.BatchWriteItemOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // BatchWriteItem indicates an expected call of BatchWriteItem -func (_mr *MockDynamoDBAPIMockRecorder) BatchWriteItem(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "BatchWriteItem", reflect.TypeOf((*MockDynamoDBAPI)(nil).BatchWriteItem), arg0) +func (mr *MockDynamoDBAPIMockRecorder) BatchWriteItem(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchWriteItem", reflect.TypeOf((*MockDynamoDBAPI)(nil).BatchWriteItem), arg0) } // BatchWriteItemWithContext mocks base method -func (_m *MockDynamoDBAPI) BatchWriteItemWithContext(_param0 aws.Context, _param1 *dynamodb.BatchWriteItemInput, _param2 ...request.Option) (*dynamodb.BatchWriteItemOutput, error) { - _s := []interface{}{_param0, _param1} - for _, _x := range _param2 { - _s = append(_s, _x) +func (m *MockDynamoDBAPI) BatchWriteItemWithContext(arg0 aws.Context, arg1 *dynamodb.BatchWriteItemInput, arg2 ...request.Option) (*dynamodb.BatchWriteItemOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) } - ret := _m.ctrl.Call(_m, "BatchWriteItemWithContext", _s...) + ret := m.ctrl.Call(m, "BatchWriteItemWithContext", varargs...) ret0, _ := ret[0].(*dynamodb.BatchWriteItemOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // BatchWriteItemWithContext indicates an expected call of BatchWriteItemWithContext -func (_mr *MockDynamoDBAPIMockRecorder) BatchWriteItemWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - _s := append([]interface{}{arg0, arg1}, arg2...) - return _mr.mock.ctrl.RecordCall(_mr.mock, "BatchWriteItemWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).BatchWriteItemWithContext), _s...) +func (mr *MockDynamoDBAPIMockRecorder) BatchWriteItemWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchWriteItemWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).BatchWriteItemWithContext), varargs...) } // BatchWriteItemRequest mocks base method -func (_m *MockDynamoDBAPI) BatchWriteItemRequest(_param0 *dynamodb.BatchWriteItemInput) (*request.Request, *dynamodb.BatchWriteItemOutput) { - ret := _m.ctrl.Call(_m, "BatchWriteItemRequest", _param0) +func (m *MockDynamoDBAPI) BatchWriteItemRequest(arg0 *dynamodb.BatchWriteItemInput) (*request.Request, *dynamodb.BatchWriteItemOutput) { + ret := m.ctrl.Call(m, "BatchWriteItemRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*dynamodb.BatchWriteItemOutput) return ret0, ret1 } // BatchWriteItemRequest indicates an expected call of BatchWriteItemRequest -func (_mr *MockDynamoDBAPIMockRecorder) BatchWriteItemRequest(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "BatchWriteItemRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).BatchWriteItemRequest), arg0) +func (mr *MockDynamoDBAPIMockRecorder) BatchWriteItemRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchWriteItemRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).BatchWriteItemRequest), arg0) +} + +// CreateBackup mocks base method +func (m *MockDynamoDBAPI) CreateBackup(arg0 *dynamodb.CreateBackupInput) (*dynamodb.CreateBackupOutput, error) { + ret := m.ctrl.Call(m, "CreateBackup", arg0) + ret0, _ := ret[0].(*dynamodb.CreateBackupOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateBackup indicates an expected call of CreateBackup +func (mr *MockDynamoDBAPIMockRecorder) CreateBackup(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateBackup", reflect.TypeOf((*MockDynamoDBAPI)(nil).CreateBackup), arg0) +} + +// CreateBackupWithContext mocks base method +func (m *MockDynamoDBAPI) CreateBackupWithContext(arg0 aws.Context, arg1 *dynamodb.CreateBackupInput, arg2 ...request.Option) (*dynamodb.CreateBackupOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateBackupWithContext", varargs...) + ret0, _ := ret[0].(*dynamodb.CreateBackupOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateBackupWithContext indicates an expected call of CreateBackupWithContext +func (mr *MockDynamoDBAPIMockRecorder) CreateBackupWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateBackupWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).CreateBackupWithContext), varargs...) +} + +// CreateBackupRequest mocks base method +func (m *MockDynamoDBAPI) CreateBackupRequest(arg0 *dynamodb.CreateBackupInput) (*request.Request, *dynamodb.CreateBackupOutput) { + ret := m.ctrl.Call(m, "CreateBackupRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*dynamodb.CreateBackupOutput) + return ret0, ret1 +} + +// CreateBackupRequest indicates an expected call of CreateBackupRequest +func (mr *MockDynamoDBAPIMockRecorder) CreateBackupRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateBackupRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).CreateBackupRequest), arg0) +} + +// CreateGlobalTable mocks base method +func (m *MockDynamoDBAPI) CreateGlobalTable(arg0 *dynamodb.CreateGlobalTableInput) (*dynamodb.CreateGlobalTableOutput, error) { + ret := m.ctrl.Call(m, "CreateGlobalTable", arg0) + ret0, _ := ret[0].(*dynamodb.CreateGlobalTableOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateGlobalTable indicates an expected call of CreateGlobalTable +func (mr *MockDynamoDBAPIMockRecorder) CreateGlobalTable(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateGlobalTable", reflect.TypeOf((*MockDynamoDBAPI)(nil).CreateGlobalTable), arg0) +} + +// CreateGlobalTableWithContext mocks base method +func (m *MockDynamoDBAPI) CreateGlobalTableWithContext(arg0 aws.Context, arg1 *dynamodb.CreateGlobalTableInput, arg2 ...request.Option) (*dynamodb.CreateGlobalTableOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateGlobalTableWithContext", varargs...) + ret0, _ := ret[0].(*dynamodb.CreateGlobalTableOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateGlobalTableWithContext indicates an expected call of CreateGlobalTableWithContext +func (mr *MockDynamoDBAPIMockRecorder) CreateGlobalTableWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateGlobalTableWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).CreateGlobalTableWithContext), varargs...) +} + +// CreateGlobalTableRequest mocks base method +func (m *MockDynamoDBAPI) CreateGlobalTableRequest(arg0 *dynamodb.CreateGlobalTableInput) (*request.Request, *dynamodb.CreateGlobalTableOutput) { + ret := m.ctrl.Call(m, "CreateGlobalTableRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*dynamodb.CreateGlobalTableOutput) + return ret0, ret1 +} + +// CreateGlobalTableRequest indicates an expected call of CreateGlobalTableRequest +func (mr *MockDynamoDBAPIMockRecorder) CreateGlobalTableRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateGlobalTableRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).CreateGlobalTableRequest), arg0) } // CreateTable mocks base method -func (_m *MockDynamoDBAPI) CreateTable(_param0 *dynamodb.CreateTableInput) (*dynamodb.CreateTableOutput, error) { - ret := _m.ctrl.Call(_m, "CreateTable", _param0) +func (m *MockDynamoDBAPI) CreateTable(arg0 *dynamodb.CreateTableInput) (*dynamodb.CreateTableOutput, error) { + ret := m.ctrl.Call(m, "CreateTable", arg0) ret0, _ := ret[0].(*dynamodb.CreateTableOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // CreateTable indicates an expected call of CreateTable -func (_mr *MockDynamoDBAPIMockRecorder) CreateTable(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "CreateTable", reflect.TypeOf((*MockDynamoDBAPI)(nil).CreateTable), arg0) +func (mr *MockDynamoDBAPIMockRecorder) CreateTable(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTable", reflect.TypeOf((*MockDynamoDBAPI)(nil).CreateTable), arg0) } // CreateTableWithContext mocks base method -func (_m *MockDynamoDBAPI) CreateTableWithContext(_param0 aws.Context, _param1 *dynamodb.CreateTableInput, _param2 ...request.Option) (*dynamodb.CreateTableOutput, error) { - _s := []interface{}{_param0, _param1} - for _, _x := range _param2 { - _s = append(_s, _x) +func (m *MockDynamoDBAPI) CreateTableWithContext(arg0 aws.Context, arg1 *dynamodb.CreateTableInput, arg2 ...request.Option) (*dynamodb.CreateTableOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) } - ret := _m.ctrl.Call(_m, "CreateTableWithContext", _s...) + ret := m.ctrl.Call(m, "CreateTableWithContext", varargs...) ret0, _ := ret[0].(*dynamodb.CreateTableOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // CreateTableWithContext indicates an expected call of CreateTableWithContext -func (_mr *MockDynamoDBAPIMockRecorder) CreateTableWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - _s := append([]interface{}{arg0, arg1}, arg2...) - return _mr.mock.ctrl.RecordCall(_mr.mock, "CreateTableWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).CreateTableWithContext), _s...) +func (mr *MockDynamoDBAPIMockRecorder) CreateTableWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTableWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).CreateTableWithContext), varargs...) } // CreateTableRequest mocks base method -func (_m *MockDynamoDBAPI) CreateTableRequest(_param0 *dynamodb.CreateTableInput) (*request.Request, *dynamodb.CreateTableOutput) { - ret := _m.ctrl.Call(_m, "CreateTableRequest", _param0) +func (m *MockDynamoDBAPI) CreateTableRequest(arg0 *dynamodb.CreateTableInput) (*request.Request, *dynamodb.CreateTableOutput) { + ret := m.ctrl.Call(m, "CreateTableRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*dynamodb.CreateTableOutput) return ret0, ret1 } // CreateTableRequest indicates an expected call of CreateTableRequest -func (_mr *MockDynamoDBAPIMockRecorder) CreateTableRequest(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "CreateTableRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).CreateTableRequest), arg0) +func (mr *MockDynamoDBAPIMockRecorder) CreateTableRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTableRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).CreateTableRequest), arg0) +} + +// DeleteBackup mocks base method +func (m *MockDynamoDBAPI) DeleteBackup(arg0 *dynamodb.DeleteBackupInput) (*dynamodb.DeleteBackupOutput, error) { + ret := m.ctrl.Call(m, "DeleteBackup", arg0) + ret0, _ := ret[0].(*dynamodb.DeleteBackupOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteBackup indicates an expected call of DeleteBackup +func (mr *MockDynamoDBAPIMockRecorder) DeleteBackup(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBackup", reflect.TypeOf((*MockDynamoDBAPI)(nil).DeleteBackup), arg0) +} + +// DeleteBackupWithContext mocks base method +func (m *MockDynamoDBAPI) DeleteBackupWithContext(arg0 aws.Context, arg1 *dynamodb.DeleteBackupInput, arg2 ...request.Option) (*dynamodb.DeleteBackupOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteBackupWithContext", varargs...) + ret0, _ := ret[0].(*dynamodb.DeleteBackupOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteBackupWithContext indicates an expected call of DeleteBackupWithContext +func (mr *MockDynamoDBAPIMockRecorder) DeleteBackupWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBackupWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).DeleteBackupWithContext), varargs...) +} + +// DeleteBackupRequest mocks base method +func (m *MockDynamoDBAPI) DeleteBackupRequest(arg0 *dynamodb.DeleteBackupInput) (*request.Request, *dynamodb.DeleteBackupOutput) { + ret := m.ctrl.Call(m, "DeleteBackupRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*dynamodb.DeleteBackupOutput) + return ret0, ret1 +} + +// DeleteBackupRequest indicates an expected call of DeleteBackupRequest +func (mr *MockDynamoDBAPIMockRecorder) DeleteBackupRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBackupRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).DeleteBackupRequest), arg0) } // DeleteItem mocks base method -func (_m *MockDynamoDBAPI) DeleteItem(_param0 *dynamodb.DeleteItemInput) (*dynamodb.DeleteItemOutput, error) { - ret := _m.ctrl.Call(_m, "DeleteItem", _param0) +func (m *MockDynamoDBAPI) DeleteItem(arg0 *dynamodb.DeleteItemInput) (*dynamodb.DeleteItemOutput, error) { + ret := m.ctrl.Call(m, "DeleteItem", arg0) ret0, _ := ret[0].(*dynamodb.DeleteItemOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // DeleteItem indicates an expected call of DeleteItem -func (_mr *MockDynamoDBAPIMockRecorder) DeleteItem(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteItem", reflect.TypeOf((*MockDynamoDBAPI)(nil).DeleteItem), arg0) +func (mr *MockDynamoDBAPIMockRecorder) DeleteItem(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteItem", reflect.TypeOf((*MockDynamoDBAPI)(nil).DeleteItem), arg0) } // DeleteItemWithContext mocks base method -func (_m *MockDynamoDBAPI) DeleteItemWithContext(_param0 aws.Context, _param1 *dynamodb.DeleteItemInput, _param2 ...request.Option) (*dynamodb.DeleteItemOutput, error) { - _s := []interface{}{_param0, _param1} - for _, _x := range _param2 { - _s = append(_s, _x) +func (m *MockDynamoDBAPI) DeleteItemWithContext(arg0 aws.Context, arg1 *dynamodb.DeleteItemInput, arg2 ...request.Option) (*dynamodb.DeleteItemOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) } - ret := _m.ctrl.Call(_m, "DeleteItemWithContext", _s...) + ret := m.ctrl.Call(m, "DeleteItemWithContext", varargs...) ret0, _ := ret[0].(*dynamodb.DeleteItemOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // DeleteItemWithContext indicates an expected call of DeleteItemWithContext -func (_mr *MockDynamoDBAPIMockRecorder) DeleteItemWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - _s := append([]interface{}{arg0, arg1}, arg2...) - return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteItemWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).DeleteItemWithContext), _s...) +func (mr *MockDynamoDBAPIMockRecorder) DeleteItemWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteItemWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).DeleteItemWithContext), varargs...) } // DeleteItemRequest mocks base method -func (_m *MockDynamoDBAPI) DeleteItemRequest(_param0 *dynamodb.DeleteItemInput) (*request.Request, *dynamodb.DeleteItemOutput) { - ret := _m.ctrl.Call(_m, "DeleteItemRequest", _param0) +func (m *MockDynamoDBAPI) DeleteItemRequest(arg0 *dynamodb.DeleteItemInput) (*request.Request, *dynamodb.DeleteItemOutput) { + ret := m.ctrl.Call(m, "DeleteItemRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*dynamodb.DeleteItemOutput) return ret0, ret1 } // DeleteItemRequest indicates an expected call of DeleteItemRequest -func (_mr *MockDynamoDBAPIMockRecorder) DeleteItemRequest(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteItemRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).DeleteItemRequest), arg0) +func (mr *MockDynamoDBAPIMockRecorder) DeleteItemRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteItemRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).DeleteItemRequest), arg0) } // DeleteTable mocks base method -func (_m *MockDynamoDBAPI) DeleteTable(_param0 *dynamodb.DeleteTableInput) (*dynamodb.DeleteTableOutput, error) { - ret := _m.ctrl.Call(_m, "DeleteTable", _param0) +func (m *MockDynamoDBAPI) DeleteTable(arg0 *dynamodb.DeleteTableInput) (*dynamodb.DeleteTableOutput, error) { + ret := m.ctrl.Call(m, "DeleteTable", arg0) ret0, _ := ret[0].(*dynamodb.DeleteTableOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // DeleteTable indicates an expected call of DeleteTable -func (_mr *MockDynamoDBAPIMockRecorder) DeleteTable(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteTable", reflect.TypeOf((*MockDynamoDBAPI)(nil).DeleteTable), arg0) +func (mr *MockDynamoDBAPIMockRecorder) DeleteTable(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTable", reflect.TypeOf((*MockDynamoDBAPI)(nil).DeleteTable), arg0) } // DeleteTableWithContext mocks base method -func (_m *MockDynamoDBAPI) DeleteTableWithContext(_param0 aws.Context, _param1 *dynamodb.DeleteTableInput, _param2 ...request.Option) (*dynamodb.DeleteTableOutput, error) { - _s := []interface{}{_param0, _param1} - for _, _x := range _param2 { - _s = append(_s, _x) +func (m *MockDynamoDBAPI) DeleteTableWithContext(arg0 aws.Context, arg1 *dynamodb.DeleteTableInput, arg2 ...request.Option) (*dynamodb.DeleteTableOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) } - ret := _m.ctrl.Call(_m, "DeleteTableWithContext", _s...) + ret := m.ctrl.Call(m, "DeleteTableWithContext", varargs...) ret0, _ := ret[0].(*dynamodb.DeleteTableOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // DeleteTableWithContext indicates an expected call of DeleteTableWithContext -func (_mr *MockDynamoDBAPIMockRecorder) DeleteTableWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - _s := append([]interface{}{arg0, arg1}, arg2...) - return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteTableWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).DeleteTableWithContext), _s...) +func (mr *MockDynamoDBAPIMockRecorder) DeleteTableWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTableWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).DeleteTableWithContext), varargs...) } // DeleteTableRequest mocks base method -func (_m *MockDynamoDBAPI) DeleteTableRequest(_param0 *dynamodb.DeleteTableInput) (*request.Request, *dynamodb.DeleteTableOutput) { - ret := _m.ctrl.Call(_m, "DeleteTableRequest", _param0) +func (m *MockDynamoDBAPI) DeleteTableRequest(arg0 *dynamodb.DeleteTableInput) (*request.Request, *dynamodb.DeleteTableOutput) { + ret := m.ctrl.Call(m, "DeleteTableRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*dynamodb.DeleteTableOutput) return ret0, ret1 } // DeleteTableRequest indicates an expected call of DeleteTableRequest -func (_mr *MockDynamoDBAPIMockRecorder) DeleteTableRequest(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteTableRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).DeleteTableRequest), arg0) +func (mr *MockDynamoDBAPIMockRecorder) DeleteTableRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTableRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).DeleteTableRequest), arg0) +} + +// DescribeBackup mocks base method +func (m *MockDynamoDBAPI) DescribeBackup(arg0 *dynamodb.DescribeBackupInput) (*dynamodb.DescribeBackupOutput, error) { + ret := m.ctrl.Call(m, "DescribeBackup", arg0) + ret0, _ := ret[0].(*dynamodb.DescribeBackupOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeBackup indicates an expected call of DescribeBackup +func (mr *MockDynamoDBAPIMockRecorder) DescribeBackup(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeBackup", reflect.TypeOf((*MockDynamoDBAPI)(nil).DescribeBackup), arg0) +} + +// DescribeBackupWithContext mocks base method +func (m *MockDynamoDBAPI) DescribeBackupWithContext(arg0 aws.Context, arg1 *dynamodb.DescribeBackupInput, arg2 ...request.Option) (*dynamodb.DescribeBackupOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeBackupWithContext", varargs...) + ret0, _ := ret[0].(*dynamodb.DescribeBackupOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeBackupWithContext indicates an expected call of DescribeBackupWithContext +func (mr *MockDynamoDBAPIMockRecorder) DescribeBackupWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeBackupWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).DescribeBackupWithContext), varargs...) +} + +// DescribeBackupRequest mocks base method +func (m *MockDynamoDBAPI) DescribeBackupRequest(arg0 *dynamodb.DescribeBackupInput) (*request.Request, *dynamodb.DescribeBackupOutput) { + ret := m.ctrl.Call(m, "DescribeBackupRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*dynamodb.DescribeBackupOutput) + return ret0, ret1 +} + +// DescribeBackupRequest indicates an expected call of DescribeBackupRequest +func (mr *MockDynamoDBAPIMockRecorder) DescribeBackupRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeBackupRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).DescribeBackupRequest), arg0) +} + +// DescribeContinuousBackups mocks base method +func (m *MockDynamoDBAPI) DescribeContinuousBackups(arg0 *dynamodb.DescribeContinuousBackupsInput) (*dynamodb.DescribeContinuousBackupsOutput, error) { + ret := m.ctrl.Call(m, "DescribeContinuousBackups", arg0) + ret0, _ := ret[0].(*dynamodb.DescribeContinuousBackupsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeContinuousBackups indicates an expected call of DescribeContinuousBackups +func (mr *MockDynamoDBAPIMockRecorder) DescribeContinuousBackups(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeContinuousBackups", reflect.TypeOf((*MockDynamoDBAPI)(nil).DescribeContinuousBackups), arg0) +} + +// DescribeContinuousBackupsWithContext mocks base method +func (m *MockDynamoDBAPI) DescribeContinuousBackupsWithContext(arg0 aws.Context, arg1 *dynamodb.DescribeContinuousBackupsInput, arg2 ...request.Option) (*dynamodb.DescribeContinuousBackupsOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeContinuousBackupsWithContext", varargs...) + ret0, _ := ret[0].(*dynamodb.DescribeContinuousBackupsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeContinuousBackupsWithContext indicates an expected call of DescribeContinuousBackupsWithContext +func (mr *MockDynamoDBAPIMockRecorder) DescribeContinuousBackupsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeContinuousBackupsWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).DescribeContinuousBackupsWithContext), varargs...) +} + +// DescribeContinuousBackupsRequest mocks base method +func (m *MockDynamoDBAPI) DescribeContinuousBackupsRequest(arg0 *dynamodb.DescribeContinuousBackupsInput) (*request.Request, *dynamodb.DescribeContinuousBackupsOutput) { + ret := m.ctrl.Call(m, "DescribeContinuousBackupsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*dynamodb.DescribeContinuousBackupsOutput) + return ret0, ret1 +} + +// DescribeContinuousBackupsRequest indicates an expected call of DescribeContinuousBackupsRequest +func (mr *MockDynamoDBAPIMockRecorder) DescribeContinuousBackupsRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeContinuousBackupsRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).DescribeContinuousBackupsRequest), arg0) +} + +// DescribeGlobalTable mocks base method +func (m *MockDynamoDBAPI) DescribeGlobalTable(arg0 *dynamodb.DescribeGlobalTableInput) (*dynamodb.DescribeGlobalTableOutput, error) { + ret := m.ctrl.Call(m, "DescribeGlobalTable", arg0) + ret0, _ := ret[0].(*dynamodb.DescribeGlobalTableOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeGlobalTable indicates an expected call of DescribeGlobalTable +func (mr *MockDynamoDBAPIMockRecorder) DescribeGlobalTable(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeGlobalTable", reflect.TypeOf((*MockDynamoDBAPI)(nil).DescribeGlobalTable), arg0) +} + +// DescribeGlobalTableWithContext mocks base method +func (m *MockDynamoDBAPI) DescribeGlobalTableWithContext(arg0 aws.Context, arg1 *dynamodb.DescribeGlobalTableInput, arg2 ...request.Option) (*dynamodb.DescribeGlobalTableOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeGlobalTableWithContext", varargs...) + ret0, _ := ret[0].(*dynamodb.DescribeGlobalTableOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeGlobalTableWithContext indicates an expected call of DescribeGlobalTableWithContext +func (mr *MockDynamoDBAPIMockRecorder) DescribeGlobalTableWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeGlobalTableWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).DescribeGlobalTableWithContext), varargs...) +} + +// DescribeGlobalTableRequest mocks base method +func (m *MockDynamoDBAPI) DescribeGlobalTableRequest(arg0 *dynamodb.DescribeGlobalTableInput) (*request.Request, *dynamodb.DescribeGlobalTableOutput) { + ret := m.ctrl.Call(m, "DescribeGlobalTableRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*dynamodb.DescribeGlobalTableOutput) + return ret0, ret1 +} + +// DescribeGlobalTableRequest indicates an expected call of DescribeGlobalTableRequest +func (mr *MockDynamoDBAPIMockRecorder) DescribeGlobalTableRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeGlobalTableRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).DescribeGlobalTableRequest), arg0) +} + +// DescribeGlobalTableSettings mocks base method +func (m *MockDynamoDBAPI) DescribeGlobalTableSettings(arg0 *dynamodb.DescribeGlobalTableSettingsInput) (*dynamodb.DescribeGlobalTableSettingsOutput, error) { + ret := m.ctrl.Call(m, "DescribeGlobalTableSettings", arg0) + ret0, _ := ret[0].(*dynamodb.DescribeGlobalTableSettingsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeGlobalTableSettings indicates an expected call of DescribeGlobalTableSettings +func (mr *MockDynamoDBAPIMockRecorder) DescribeGlobalTableSettings(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeGlobalTableSettings", reflect.TypeOf((*MockDynamoDBAPI)(nil).DescribeGlobalTableSettings), arg0) +} + +// DescribeGlobalTableSettingsWithContext mocks base method +func (m *MockDynamoDBAPI) DescribeGlobalTableSettingsWithContext(arg0 aws.Context, arg1 *dynamodb.DescribeGlobalTableSettingsInput, arg2 ...request.Option) (*dynamodb.DescribeGlobalTableSettingsOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeGlobalTableSettingsWithContext", varargs...) + ret0, _ := ret[0].(*dynamodb.DescribeGlobalTableSettingsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeGlobalTableSettingsWithContext indicates an expected call of DescribeGlobalTableSettingsWithContext +func (mr *MockDynamoDBAPIMockRecorder) DescribeGlobalTableSettingsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeGlobalTableSettingsWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).DescribeGlobalTableSettingsWithContext), varargs...) +} + +// DescribeGlobalTableSettingsRequest mocks base method +func (m *MockDynamoDBAPI) DescribeGlobalTableSettingsRequest(arg0 *dynamodb.DescribeGlobalTableSettingsInput) (*request.Request, *dynamodb.DescribeGlobalTableSettingsOutput) { + ret := m.ctrl.Call(m, "DescribeGlobalTableSettingsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*dynamodb.DescribeGlobalTableSettingsOutput) + return ret0, ret1 +} + +// DescribeGlobalTableSettingsRequest indicates an expected call of DescribeGlobalTableSettingsRequest +func (mr *MockDynamoDBAPIMockRecorder) DescribeGlobalTableSettingsRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeGlobalTableSettingsRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).DescribeGlobalTableSettingsRequest), arg0) } // DescribeLimits mocks base method -func (_m *MockDynamoDBAPI) DescribeLimits(_param0 *dynamodb.DescribeLimitsInput) (*dynamodb.DescribeLimitsOutput, error) { - ret := _m.ctrl.Call(_m, "DescribeLimits", _param0) +func (m *MockDynamoDBAPI) DescribeLimits(arg0 *dynamodb.DescribeLimitsInput) (*dynamodb.DescribeLimitsOutput, error) { + ret := m.ctrl.Call(m, "DescribeLimits", arg0) ret0, _ := ret[0].(*dynamodb.DescribeLimitsOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // DescribeLimits indicates an expected call of DescribeLimits -func (_mr *MockDynamoDBAPIMockRecorder) DescribeLimits(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "DescribeLimits", reflect.TypeOf((*MockDynamoDBAPI)(nil).DescribeLimits), arg0) +func (mr *MockDynamoDBAPIMockRecorder) DescribeLimits(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLimits", reflect.TypeOf((*MockDynamoDBAPI)(nil).DescribeLimits), arg0) } // DescribeLimitsWithContext mocks base method -func (_m *MockDynamoDBAPI) DescribeLimitsWithContext(_param0 aws.Context, _param1 *dynamodb.DescribeLimitsInput, _param2 ...request.Option) (*dynamodb.DescribeLimitsOutput, error) { - _s := []interface{}{_param0, _param1} - for _, _x := range _param2 { - _s = append(_s, _x) +func (m *MockDynamoDBAPI) DescribeLimitsWithContext(arg0 aws.Context, arg1 *dynamodb.DescribeLimitsInput, arg2 ...request.Option) (*dynamodb.DescribeLimitsOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) } - ret := _m.ctrl.Call(_m, "DescribeLimitsWithContext", _s...) + ret := m.ctrl.Call(m, "DescribeLimitsWithContext", varargs...) ret0, _ := ret[0].(*dynamodb.DescribeLimitsOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // DescribeLimitsWithContext indicates an expected call of DescribeLimitsWithContext -func (_mr *MockDynamoDBAPIMockRecorder) DescribeLimitsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - _s := append([]interface{}{arg0, arg1}, arg2...) - return _mr.mock.ctrl.RecordCall(_mr.mock, "DescribeLimitsWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).DescribeLimitsWithContext), _s...) +func (mr *MockDynamoDBAPIMockRecorder) DescribeLimitsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLimitsWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).DescribeLimitsWithContext), varargs...) } // DescribeLimitsRequest mocks base method -func (_m *MockDynamoDBAPI) DescribeLimitsRequest(_param0 *dynamodb.DescribeLimitsInput) (*request.Request, *dynamodb.DescribeLimitsOutput) { - ret := _m.ctrl.Call(_m, "DescribeLimitsRequest", _param0) +func (m *MockDynamoDBAPI) DescribeLimitsRequest(arg0 *dynamodb.DescribeLimitsInput) (*request.Request, *dynamodb.DescribeLimitsOutput) { + ret := m.ctrl.Call(m, "DescribeLimitsRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*dynamodb.DescribeLimitsOutput) return ret0, ret1 } // DescribeLimitsRequest indicates an expected call of DescribeLimitsRequest -func (_mr *MockDynamoDBAPIMockRecorder) DescribeLimitsRequest(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "DescribeLimitsRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).DescribeLimitsRequest), arg0) +func (mr *MockDynamoDBAPIMockRecorder) DescribeLimitsRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLimitsRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).DescribeLimitsRequest), arg0) } // DescribeTable mocks base method -func (_m *MockDynamoDBAPI) DescribeTable(_param0 *dynamodb.DescribeTableInput) (*dynamodb.DescribeTableOutput, error) { - ret := _m.ctrl.Call(_m, "DescribeTable", _param0) +func (m *MockDynamoDBAPI) DescribeTable(arg0 *dynamodb.DescribeTableInput) (*dynamodb.DescribeTableOutput, error) { + ret := m.ctrl.Call(m, "DescribeTable", arg0) ret0, _ := ret[0].(*dynamodb.DescribeTableOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // DescribeTable indicates an expected call of DescribeTable -func (_mr *MockDynamoDBAPIMockRecorder) DescribeTable(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "DescribeTable", reflect.TypeOf((*MockDynamoDBAPI)(nil).DescribeTable), arg0) +func (mr *MockDynamoDBAPIMockRecorder) DescribeTable(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTable", reflect.TypeOf((*MockDynamoDBAPI)(nil).DescribeTable), arg0) } // DescribeTableWithContext mocks base method -func (_m *MockDynamoDBAPI) DescribeTableWithContext(_param0 aws.Context, _param1 *dynamodb.DescribeTableInput, _param2 ...request.Option) (*dynamodb.DescribeTableOutput, error) { - _s := []interface{}{_param0, _param1} - for _, _x := range _param2 { - _s = append(_s, _x) +func (m *MockDynamoDBAPI) DescribeTableWithContext(arg0 aws.Context, arg1 *dynamodb.DescribeTableInput, arg2 ...request.Option) (*dynamodb.DescribeTableOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) } - ret := _m.ctrl.Call(_m, "DescribeTableWithContext", _s...) + ret := m.ctrl.Call(m, "DescribeTableWithContext", varargs...) ret0, _ := ret[0].(*dynamodb.DescribeTableOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // DescribeTableWithContext indicates an expected call of DescribeTableWithContext -func (_mr *MockDynamoDBAPIMockRecorder) DescribeTableWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - _s := append([]interface{}{arg0, arg1}, arg2...) - return _mr.mock.ctrl.RecordCall(_mr.mock, "DescribeTableWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).DescribeTableWithContext), _s...) +func (mr *MockDynamoDBAPIMockRecorder) DescribeTableWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTableWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).DescribeTableWithContext), varargs...) } // DescribeTableRequest mocks base method -func (_m *MockDynamoDBAPI) DescribeTableRequest(_param0 *dynamodb.DescribeTableInput) (*request.Request, *dynamodb.DescribeTableOutput) { - ret := _m.ctrl.Call(_m, "DescribeTableRequest", _param0) +func (m *MockDynamoDBAPI) DescribeTableRequest(arg0 *dynamodb.DescribeTableInput) (*request.Request, *dynamodb.DescribeTableOutput) { + ret := m.ctrl.Call(m, "DescribeTableRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*dynamodb.DescribeTableOutput) return ret0, ret1 } // DescribeTableRequest indicates an expected call of DescribeTableRequest -func (_mr *MockDynamoDBAPIMockRecorder) DescribeTableRequest(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "DescribeTableRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).DescribeTableRequest), arg0) +func (mr *MockDynamoDBAPIMockRecorder) DescribeTableRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTableRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).DescribeTableRequest), arg0) } // DescribeTimeToLive mocks base method -func (_m *MockDynamoDBAPI) DescribeTimeToLive(_param0 *dynamodb.DescribeTimeToLiveInput) (*dynamodb.DescribeTimeToLiveOutput, error) { - ret := _m.ctrl.Call(_m, "DescribeTimeToLive", _param0) +func (m *MockDynamoDBAPI) DescribeTimeToLive(arg0 *dynamodb.DescribeTimeToLiveInput) (*dynamodb.DescribeTimeToLiveOutput, error) { + ret := m.ctrl.Call(m, "DescribeTimeToLive", arg0) ret0, _ := ret[0].(*dynamodb.DescribeTimeToLiveOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // DescribeTimeToLive indicates an expected call of DescribeTimeToLive -func (_mr *MockDynamoDBAPIMockRecorder) DescribeTimeToLive(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "DescribeTimeToLive", reflect.TypeOf((*MockDynamoDBAPI)(nil).DescribeTimeToLive), arg0) +func (mr *MockDynamoDBAPIMockRecorder) DescribeTimeToLive(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTimeToLive", reflect.TypeOf((*MockDynamoDBAPI)(nil).DescribeTimeToLive), arg0) } // DescribeTimeToLiveWithContext mocks base method -func (_m *MockDynamoDBAPI) DescribeTimeToLiveWithContext(_param0 aws.Context, _param1 *dynamodb.DescribeTimeToLiveInput, _param2 ...request.Option) (*dynamodb.DescribeTimeToLiveOutput, error) { - _s := []interface{}{_param0, _param1} - for _, _x := range _param2 { - _s = append(_s, _x) +func (m *MockDynamoDBAPI) DescribeTimeToLiveWithContext(arg0 aws.Context, arg1 *dynamodb.DescribeTimeToLiveInput, arg2 ...request.Option) (*dynamodb.DescribeTimeToLiveOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) } - ret := _m.ctrl.Call(_m, "DescribeTimeToLiveWithContext", _s...) + ret := m.ctrl.Call(m, "DescribeTimeToLiveWithContext", varargs...) ret0, _ := ret[0].(*dynamodb.DescribeTimeToLiveOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // DescribeTimeToLiveWithContext indicates an expected call of DescribeTimeToLiveWithContext -func (_mr *MockDynamoDBAPIMockRecorder) DescribeTimeToLiveWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - _s := append([]interface{}{arg0, arg1}, arg2...) - return _mr.mock.ctrl.RecordCall(_mr.mock, "DescribeTimeToLiveWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).DescribeTimeToLiveWithContext), _s...) +func (mr *MockDynamoDBAPIMockRecorder) DescribeTimeToLiveWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTimeToLiveWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).DescribeTimeToLiveWithContext), varargs...) } // DescribeTimeToLiveRequest mocks base method -func (_m *MockDynamoDBAPI) DescribeTimeToLiveRequest(_param0 *dynamodb.DescribeTimeToLiveInput) (*request.Request, *dynamodb.DescribeTimeToLiveOutput) { - ret := _m.ctrl.Call(_m, "DescribeTimeToLiveRequest", _param0) +func (m *MockDynamoDBAPI) DescribeTimeToLiveRequest(arg0 *dynamodb.DescribeTimeToLiveInput) (*request.Request, *dynamodb.DescribeTimeToLiveOutput) { + ret := m.ctrl.Call(m, "DescribeTimeToLiveRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*dynamodb.DescribeTimeToLiveOutput) return ret0, ret1 } // DescribeTimeToLiveRequest indicates an expected call of DescribeTimeToLiveRequest -func (_mr *MockDynamoDBAPIMockRecorder) DescribeTimeToLiveRequest(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "DescribeTimeToLiveRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).DescribeTimeToLiveRequest), arg0) +func (mr *MockDynamoDBAPIMockRecorder) DescribeTimeToLiveRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTimeToLiveRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).DescribeTimeToLiveRequest), arg0) } // GetItem mocks base method -func (_m *MockDynamoDBAPI) GetItem(_param0 *dynamodb.GetItemInput) (*dynamodb.GetItemOutput, error) { - ret := _m.ctrl.Call(_m, "GetItem", _param0) +func (m *MockDynamoDBAPI) GetItem(arg0 *dynamodb.GetItemInput) (*dynamodb.GetItemOutput, error) { + ret := m.ctrl.Call(m, "GetItem", arg0) ret0, _ := ret[0].(*dynamodb.GetItemOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // GetItem indicates an expected call of GetItem -func (_mr *MockDynamoDBAPIMockRecorder) GetItem(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "GetItem", reflect.TypeOf((*MockDynamoDBAPI)(nil).GetItem), arg0) +func (mr *MockDynamoDBAPIMockRecorder) GetItem(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetItem", reflect.TypeOf((*MockDynamoDBAPI)(nil).GetItem), arg0) } // GetItemWithContext mocks base method -func (_m *MockDynamoDBAPI) GetItemWithContext(_param0 aws.Context, _param1 *dynamodb.GetItemInput, _param2 ...request.Option) (*dynamodb.GetItemOutput, error) { - _s := []interface{}{_param0, _param1} - for _, _x := range _param2 { - _s = append(_s, _x) +func (m *MockDynamoDBAPI) GetItemWithContext(arg0 aws.Context, arg1 *dynamodb.GetItemInput, arg2 ...request.Option) (*dynamodb.GetItemOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) } - ret := _m.ctrl.Call(_m, "GetItemWithContext", _s...) + ret := m.ctrl.Call(m, "GetItemWithContext", varargs...) ret0, _ := ret[0].(*dynamodb.GetItemOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // GetItemWithContext indicates an expected call of GetItemWithContext -func (_mr *MockDynamoDBAPIMockRecorder) GetItemWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - _s := append([]interface{}{arg0, arg1}, arg2...) - return _mr.mock.ctrl.RecordCall(_mr.mock, "GetItemWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).GetItemWithContext), _s...) +func (mr *MockDynamoDBAPIMockRecorder) GetItemWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetItemWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).GetItemWithContext), varargs...) } // GetItemRequest mocks base method -func (_m *MockDynamoDBAPI) GetItemRequest(_param0 *dynamodb.GetItemInput) (*request.Request, *dynamodb.GetItemOutput) { - ret := _m.ctrl.Call(_m, "GetItemRequest", _param0) +func (m *MockDynamoDBAPI) GetItemRequest(arg0 *dynamodb.GetItemInput) (*request.Request, *dynamodb.GetItemOutput) { + ret := m.ctrl.Call(m, "GetItemRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*dynamodb.GetItemOutput) return ret0, ret1 } // GetItemRequest indicates an expected call of GetItemRequest -func (_mr *MockDynamoDBAPIMockRecorder) GetItemRequest(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "GetItemRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).GetItemRequest), arg0) +func (mr *MockDynamoDBAPIMockRecorder) GetItemRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetItemRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).GetItemRequest), arg0) +} + +// ListBackups mocks base method +func (m *MockDynamoDBAPI) ListBackups(arg0 *dynamodb.ListBackupsInput) (*dynamodb.ListBackupsOutput, error) { + ret := m.ctrl.Call(m, "ListBackups", arg0) + ret0, _ := ret[0].(*dynamodb.ListBackupsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListBackups indicates an expected call of ListBackups +func (mr *MockDynamoDBAPIMockRecorder) ListBackups(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListBackups", reflect.TypeOf((*MockDynamoDBAPI)(nil).ListBackups), arg0) +} + +// ListBackupsWithContext mocks base method +func (m *MockDynamoDBAPI) ListBackupsWithContext(arg0 aws.Context, arg1 *dynamodb.ListBackupsInput, arg2 ...request.Option) (*dynamodb.ListBackupsOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListBackupsWithContext", varargs...) + ret0, _ := ret[0].(*dynamodb.ListBackupsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListBackupsWithContext indicates an expected call of ListBackupsWithContext +func (mr *MockDynamoDBAPIMockRecorder) ListBackupsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListBackupsWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).ListBackupsWithContext), varargs...) +} + +// ListBackupsRequest mocks base method +func (m *MockDynamoDBAPI) ListBackupsRequest(arg0 *dynamodb.ListBackupsInput) (*request.Request, *dynamodb.ListBackupsOutput) { + ret := m.ctrl.Call(m, "ListBackupsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*dynamodb.ListBackupsOutput) + return ret0, ret1 +} + +// ListBackupsRequest indicates an expected call of ListBackupsRequest +func (mr *MockDynamoDBAPIMockRecorder) ListBackupsRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListBackupsRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).ListBackupsRequest), arg0) +} + +// ListGlobalTables mocks base method +func (m *MockDynamoDBAPI) ListGlobalTables(arg0 *dynamodb.ListGlobalTablesInput) (*dynamodb.ListGlobalTablesOutput, error) { + ret := m.ctrl.Call(m, "ListGlobalTables", arg0) + ret0, _ := ret[0].(*dynamodb.ListGlobalTablesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListGlobalTables indicates an expected call of ListGlobalTables +func (mr *MockDynamoDBAPIMockRecorder) ListGlobalTables(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListGlobalTables", reflect.TypeOf((*MockDynamoDBAPI)(nil).ListGlobalTables), arg0) +} + +// ListGlobalTablesWithContext mocks base method +func (m *MockDynamoDBAPI) ListGlobalTablesWithContext(arg0 aws.Context, arg1 *dynamodb.ListGlobalTablesInput, arg2 ...request.Option) (*dynamodb.ListGlobalTablesOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListGlobalTablesWithContext", varargs...) + ret0, _ := ret[0].(*dynamodb.ListGlobalTablesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListGlobalTablesWithContext indicates an expected call of ListGlobalTablesWithContext +func (mr *MockDynamoDBAPIMockRecorder) ListGlobalTablesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListGlobalTablesWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).ListGlobalTablesWithContext), varargs...) +} + +// ListGlobalTablesRequest mocks base method +func (m *MockDynamoDBAPI) ListGlobalTablesRequest(arg0 *dynamodb.ListGlobalTablesInput) (*request.Request, *dynamodb.ListGlobalTablesOutput) { + ret := m.ctrl.Call(m, "ListGlobalTablesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*dynamodb.ListGlobalTablesOutput) + return ret0, ret1 +} + +// ListGlobalTablesRequest indicates an expected call of ListGlobalTablesRequest +func (mr *MockDynamoDBAPIMockRecorder) ListGlobalTablesRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListGlobalTablesRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).ListGlobalTablesRequest), arg0) } // ListTables mocks base method -func (_m *MockDynamoDBAPI) ListTables(_param0 *dynamodb.ListTablesInput) (*dynamodb.ListTablesOutput, error) { - ret := _m.ctrl.Call(_m, "ListTables", _param0) +func (m *MockDynamoDBAPI) ListTables(arg0 *dynamodb.ListTablesInput) (*dynamodb.ListTablesOutput, error) { + ret := m.ctrl.Call(m, "ListTables", arg0) ret0, _ := ret[0].(*dynamodb.ListTablesOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // ListTables indicates an expected call of ListTables -func (_mr *MockDynamoDBAPIMockRecorder) ListTables(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "ListTables", reflect.TypeOf((*MockDynamoDBAPI)(nil).ListTables), arg0) +func (mr *MockDynamoDBAPIMockRecorder) ListTables(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTables", reflect.TypeOf((*MockDynamoDBAPI)(nil).ListTables), arg0) } // ListTablesWithContext mocks base method -func (_m *MockDynamoDBAPI) ListTablesWithContext(_param0 aws.Context, _param1 *dynamodb.ListTablesInput, _param2 ...request.Option) (*dynamodb.ListTablesOutput, error) { - _s := []interface{}{_param0, _param1} - for _, _x := range _param2 { - _s = append(_s, _x) +func (m *MockDynamoDBAPI) ListTablesWithContext(arg0 aws.Context, arg1 *dynamodb.ListTablesInput, arg2 ...request.Option) (*dynamodb.ListTablesOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) } - ret := _m.ctrl.Call(_m, "ListTablesWithContext", _s...) + ret := m.ctrl.Call(m, "ListTablesWithContext", varargs...) ret0, _ := ret[0].(*dynamodb.ListTablesOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // ListTablesWithContext indicates an expected call of ListTablesWithContext -func (_mr *MockDynamoDBAPIMockRecorder) ListTablesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - _s := append([]interface{}{arg0, arg1}, arg2...) - return _mr.mock.ctrl.RecordCall(_mr.mock, "ListTablesWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).ListTablesWithContext), _s...) +func (mr *MockDynamoDBAPIMockRecorder) ListTablesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTablesWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).ListTablesWithContext), varargs...) } // ListTablesRequest mocks base method -func (_m *MockDynamoDBAPI) ListTablesRequest(_param0 *dynamodb.ListTablesInput) (*request.Request, *dynamodb.ListTablesOutput) { - ret := _m.ctrl.Call(_m, "ListTablesRequest", _param0) +func (m *MockDynamoDBAPI) ListTablesRequest(arg0 *dynamodb.ListTablesInput) (*request.Request, *dynamodb.ListTablesOutput) { + ret := m.ctrl.Call(m, "ListTablesRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*dynamodb.ListTablesOutput) return ret0, ret1 } // ListTablesRequest indicates an expected call of ListTablesRequest -func (_mr *MockDynamoDBAPIMockRecorder) ListTablesRequest(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "ListTablesRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).ListTablesRequest), arg0) +func (mr *MockDynamoDBAPIMockRecorder) ListTablesRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTablesRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).ListTablesRequest), arg0) } // ListTablesPages mocks base method -func (_m *MockDynamoDBAPI) ListTablesPages(_param0 *dynamodb.ListTablesInput, _param1 func(*dynamodb.ListTablesOutput, bool) bool) error { - ret := _m.ctrl.Call(_m, "ListTablesPages", _param0, _param1) +func (m *MockDynamoDBAPI) ListTablesPages(arg0 *dynamodb.ListTablesInput, arg1 func(*dynamodb.ListTablesOutput, bool) bool) error { + ret := m.ctrl.Call(m, "ListTablesPages", arg0, arg1) ret0, _ := ret[0].(error) return ret0 } // ListTablesPages indicates an expected call of ListTablesPages -func (_mr *MockDynamoDBAPIMockRecorder) ListTablesPages(arg0, arg1 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "ListTablesPages", reflect.TypeOf((*MockDynamoDBAPI)(nil).ListTablesPages), arg0, arg1) +func (mr *MockDynamoDBAPIMockRecorder) ListTablesPages(arg0, arg1 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTablesPages", reflect.TypeOf((*MockDynamoDBAPI)(nil).ListTablesPages), arg0, arg1) } // ListTablesPagesWithContext mocks base method -func (_m *MockDynamoDBAPI) ListTablesPagesWithContext(_param0 aws.Context, _param1 *dynamodb.ListTablesInput, _param2 func(*dynamodb.ListTablesOutput, bool) bool, _param3 ...request.Option) error { - _s := []interface{}{_param0, _param1, _param2} - for _, _x := range _param3 { - _s = append(_s, _x) +func (m *MockDynamoDBAPI) ListTablesPagesWithContext(arg0 aws.Context, arg1 *dynamodb.ListTablesInput, arg2 func(*dynamodb.ListTablesOutput, bool) bool, arg3 ...request.Option) error { + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) } - ret := _m.ctrl.Call(_m, "ListTablesPagesWithContext", _s...) + ret := m.ctrl.Call(m, "ListTablesPagesWithContext", varargs...) ret0, _ := ret[0].(error) return ret0 } // ListTablesPagesWithContext indicates an expected call of ListTablesPagesWithContext -func (_mr *MockDynamoDBAPIMockRecorder) ListTablesPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { - _s := append([]interface{}{arg0, arg1, arg2}, arg3...) - return _mr.mock.ctrl.RecordCall(_mr.mock, "ListTablesPagesWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).ListTablesPagesWithContext), _s...) +func (mr *MockDynamoDBAPIMockRecorder) ListTablesPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTablesPagesWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).ListTablesPagesWithContext), varargs...) } // ListTagsOfResource mocks base method -func (_m *MockDynamoDBAPI) ListTagsOfResource(_param0 *dynamodb.ListTagsOfResourceInput) (*dynamodb.ListTagsOfResourceOutput, error) { - ret := _m.ctrl.Call(_m, "ListTagsOfResource", _param0) +func (m *MockDynamoDBAPI) ListTagsOfResource(arg0 *dynamodb.ListTagsOfResourceInput) (*dynamodb.ListTagsOfResourceOutput, error) { + ret := m.ctrl.Call(m, "ListTagsOfResource", arg0) ret0, _ := ret[0].(*dynamodb.ListTagsOfResourceOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // ListTagsOfResource indicates an expected call of ListTagsOfResource -func (_mr *MockDynamoDBAPIMockRecorder) ListTagsOfResource(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "ListTagsOfResource", reflect.TypeOf((*MockDynamoDBAPI)(nil).ListTagsOfResource), arg0) +func (mr *MockDynamoDBAPIMockRecorder) ListTagsOfResource(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTagsOfResource", reflect.TypeOf((*MockDynamoDBAPI)(nil).ListTagsOfResource), arg0) } // ListTagsOfResourceWithContext mocks base method -func (_m *MockDynamoDBAPI) ListTagsOfResourceWithContext(_param0 aws.Context, _param1 *dynamodb.ListTagsOfResourceInput, _param2 ...request.Option) (*dynamodb.ListTagsOfResourceOutput, error) { - _s := []interface{}{_param0, _param1} - for _, _x := range _param2 { - _s = append(_s, _x) +func (m *MockDynamoDBAPI) ListTagsOfResourceWithContext(arg0 aws.Context, arg1 *dynamodb.ListTagsOfResourceInput, arg2 ...request.Option) (*dynamodb.ListTagsOfResourceOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) } - ret := _m.ctrl.Call(_m, "ListTagsOfResourceWithContext", _s...) + ret := m.ctrl.Call(m, "ListTagsOfResourceWithContext", varargs...) ret0, _ := ret[0].(*dynamodb.ListTagsOfResourceOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // ListTagsOfResourceWithContext indicates an expected call of ListTagsOfResourceWithContext -func (_mr *MockDynamoDBAPIMockRecorder) ListTagsOfResourceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - _s := append([]interface{}{arg0, arg1}, arg2...) - return _mr.mock.ctrl.RecordCall(_mr.mock, "ListTagsOfResourceWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).ListTagsOfResourceWithContext), _s...) +func (mr *MockDynamoDBAPIMockRecorder) ListTagsOfResourceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTagsOfResourceWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).ListTagsOfResourceWithContext), varargs...) } // ListTagsOfResourceRequest mocks base method -func (_m *MockDynamoDBAPI) ListTagsOfResourceRequest(_param0 *dynamodb.ListTagsOfResourceInput) (*request.Request, *dynamodb.ListTagsOfResourceOutput) { - ret := _m.ctrl.Call(_m, "ListTagsOfResourceRequest", _param0) +func (m *MockDynamoDBAPI) ListTagsOfResourceRequest(arg0 *dynamodb.ListTagsOfResourceInput) (*request.Request, *dynamodb.ListTagsOfResourceOutput) { + ret := m.ctrl.Call(m, "ListTagsOfResourceRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*dynamodb.ListTagsOfResourceOutput) return ret0, ret1 } // ListTagsOfResourceRequest indicates an expected call of ListTagsOfResourceRequest -func (_mr *MockDynamoDBAPIMockRecorder) ListTagsOfResourceRequest(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "ListTagsOfResourceRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).ListTagsOfResourceRequest), arg0) +func (mr *MockDynamoDBAPIMockRecorder) ListTagsOfResourceRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTagsOfResourceRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).ListTagsOfResourceRequest), arg0) } // PutItem mocks base method -func (_m *MockDynamoDBAPI) PutItem(_param0 *dynamodb.PutItemInput) (*dynamodb.PutItemOutput, error) { - ret := _m.ctrl.Call(_m, "PutItem", _param0) +func (m *MockDynamoDBAPI) PutItem(arg0 *dynamodb.PutItemInput) (*dynamodb.PutItemOutput, error) { + ret := m.ctrl.Call(m, "PutItem", arg0) ret0, _ := ret[0].(*dynamodb.PutItemOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // PutItem indicates an expected call of PutItem -func (_mr *MockDynamoDBAPIMockRecorder) PutItem(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "PutItem", reflect.TypeOf((*MockDynamoDBAPI)(nil).PutItem), arg0) +func (mr *MockDynamoDBAPIMockRecorder) PutItem(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutItem", reflect.TypeOf((*MockDynamoDBAPI)(nil).PutItem), arg0) } // PutItemWithContext mocks base method -func (_m *MockDynamoDBAPI) PutItemWithContext(_param0 aws.Context, _param1 *dynamodb.PutItemInput, _param2 ...request.Option) (*dynamodb.PutItemOutput, error) { - _s := []interface{}{_param0, _param1} - for _, _x := range _param2 { - _s = append(_s, _x) +func (m *MockDynamoDBAPI) PutItemWithContext(arg0 aws.Context, arg1 *dynamodb.PutItemInput, arg2 ...request.Option) (*dynamodb.PutItemOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) } - ret := _m.ctrl.Call(_m, "PutItemWithContext", _s...) + ret := m.ctrl.Call(m, "PutItemWithContext", varargs...) ret0, _ := ret[0].(*dynamodb.PutItemOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // PutItemWithContext indicates an expected call of PutItemWithContext -func (_mr *MockDynamoDBAPIMockRecorder) PutItemWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - _s := append([]interface{}{arg0, arg1}, arg2...) - return _mr.mock.ctrl.RecordCall(_mr.mock, "PutItemWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).PutItemWithContext), _s...) +func (mr *MockDynamoDBAPIMockRecorder) PutItemWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutItemWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).PutItemWithContext), varargs...) } // PutItemRequest mocks base method -func (_m *MockDynamoDBAPI) PutItemRequest(_param0 *dynamodb.PutItemInput) (*request.Request, *dynamodb.PutItemOutput) { - ret := _m.ctrl.Call(_m, "PutItemRequest", _param0) +func (m *MockDynamoDBAPI) PutItemRequest(arg0 *dynamodb.PutItemInput) (*request.Request, *dynamodb.PutItemOutput) { + ret := m.ctrl.Call(m, "PutItemRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*dynamodb.PutItemOutput) return ret0, ret1 } // PutItemRequest indicates an expected call of PutItemRequest -func (_mr *MockDynamoDBAPIMockRecorder) PutItemRequest(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "PutItemRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).PutItemRequest), arg0) +func (mr *MockDynamoDBAPIMockRecorder) PutItemRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutItemRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).PutItemRequest), arg0) } // Query mocks base method -func (_m *MockDynamoDBAPI) Query(_param0 *dynamodb.QueryInput) (*dynamodb.QueryOutput, error) { - ret := _m.ctrl.Call(_m, "Query", _param0) +func (m *MockDynamoDBAPI) Query(arg0 *dynamodb.QueryInput) (*dynamodb.QueryOutput, error) { + ret := m.ctrl.Call(m, "Query", arg0) ret0, _ := ret[0].(*dynamodb.QueryOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // Query indicates an expected call of Query -func (_mr *MockDynamoDBAPIMockRecorder) Query(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "Query", reflect.TypeOf((*MockDynamoDBAPI)(nil).Query), arg0) +func (mr *MockDynamoDBAPIMockRecorder) Query(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Query", reflect.TypeOf((*MockDynamoDBAPI)(nil).Query), arg0) } // QueryWithContext mocks base method -func (_m *MockDynamoDBAPI) QueryWithContext(_param0 aws.Context, _param1 *dynamodb.QueryInput, _param2 ...request.Option) (*dynamodb.QueryOutput, error) { - _s := []interface{}{_param0, _param1} - for _, _x := range _param2 { - _s = append(_s, _x) +func (m *MockDynamoDBAPI) QueryWithContext(arg0 aws.Context, arg1 *dynamodb.QueryInput, arg2 ...request.Option) (*dynamodb.QueryOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) } - ret := _m.ctrl.Call(_m, "QueryWithContext", _s...) + ret := m.ctrl.Call(m, "QueryWithContext", varargs...) ret0, _ := ret[0].(*dynamodb.QueryOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // QueryWithContext indicates an expected call of QueryWithContext -func (_mr *MockDynamoDBAPIMockRecorder) QueryWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - _s := append([]interface{}{arg0, arg1}, arg2...) - return _mr.mock.ctrl.RecordCall(_mr.mock, "QueryWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).QueryWithContext), _s...) +func (mr *MockDynamoDBAPIMockRecorder) QueryWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).QueryWithContext), varargs...) } // QueryRequest mocks base method -func (_m *MockDynamoDBAPI) QueryRequest(_param0 *dynamodb.QueryInput) (*request.Request, *dynamodb.QueryOutput) { - ret := _m.ctrl.Call(_m, "QueryRequest", _param0) +func (m *MockDynamoDBAPI) QueryRequest(arg0 *dynamodb.QueryInput) (*request.Request, *dynamodb.QueryOutput) { + ret := m.ctrl.Call(m, "QueryRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*dynamodb.QueryOutput) return ret0, ret1 } // QueryRequest indicates an expected call of QueryRequest -func (_mr *MockDynamoDBAPIMockRecorder) QueryRequest(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "QueryRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).QueryRequest), arg0) +func (mr *MockDynamoDBAPIMockRecorder) QueryRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).QueryRequest), arg0) } // QueryPages mocks base method -func (_m *MockDynamoDBAPI) QueryPages(_param0 *dynamodb.QueryInput, _param1 func(*dynamodb.QueryOutput, bool) bool) error { - ret := _m.ctrl.Call(_m, "QueryPages", _param0, _param1) +func (m *MockDynamoDBAPI) QueryPages(arg0 *dynamodb.QueryInput, arg1 func(*dynamodb.QueryOutput, bool) bool) error { + ret := m.ctrl.Call(m, "QueryPages", arg0, arg1) ret0, _ := ret[0].(error) return ret0 } // QueryPages indicates an expected call of QueryPages -func (_mr *MockDynamoDBAPIMockRecorder) QueryPages(arg0, arg1 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "QueryPages", reflect.TypeOf((*MockDynamoDBAPI)(nil).QueryPages), arg0, arg1) +func (mr *MockDynamoDBAPIMockRecorder) QueryPages(arg0, arg1 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryPages", reflect.TypeOf((*MockDynamoDBAPI)(nil).QueryPages), arg0, arg1) } // QueryPagesWithContext mocks base method -func (_m *MockDynamoDBAPI) QueryPagesWithContext(_param0 aws.Context, _param1 *dynamodb.QueryInput, _param2 func(*dynamodb.QueryOutput, bool) bool, _param3 ...request.Option) error { - _s := []interface{}{_param0, _param1, _param2} - for _, _x := range _param3 { - _s = append(_s, _x) +func (m *MockDynamoDBAPI) QueryPagesWithContext(arg0 aws.Context, arg1 *dynamodb.QueryInput, arg2 func(*dynamodb.QueryOutput, bool) bool, arg3 ...request.Option) error { + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) } - ret := _m.ctrl.Call(_m, "QueryPagesWithContext", _s...) + ret := m.ctrl.Call(m, "QueryPagesWithContext", varargs...) ret0, _ := ret[0].(error) return ret0 } // QueryPagesWithContext indicates an expected call of QueryPagesWithContext -func (_mr *MockDynamoDBAPIMockRecorder) QueryPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { - _s := append([]interface{}{arg0, arg1, arg2}, arg3...) - return _mr.mock.ctrl.RecordCall(_mr.mock, "QueryPagesWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).QueryPagesWithContext), _s...) +func (mr *MockDynamoDBAPIMockRecorder) QueryPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryPagesWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).QueryPagesWithContext), varargs...) +} + +// RestoreTableFromBackup mocks base method +func (m *MockDynamoDBAPI) RestoreTableFromBackup(arg0 *dynamodb.RestoreTableFromBackupInput) (*dynamodb.RestoreTableFromBackupOutput, error) { + ret := m.ctrl.Call(m, "RestoreTableFromBackup", arg0) + ret0, _ := ret[0].(*dynamodb.RestoreTableFromBackupOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RestoreTableFromBackup indicates an expected call of RestoreTableFromBackup +func (mr *MockDynamoDBAPIMockRecorder) RestoreTableFromBackup(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RestoreTableFromBackup", reflect.TypeOf((*MockDynamoDBAPI)(nil).RestoreTableFromBackup), arg0) +} + +// RestoreTableFromBackupWithContext mocks base method +func (m *MockDynamoDBAPI) RestoreTableFromBackupWithContext(arg0 aws.Context, arg1 *dynamodb.RestoreTableFromBackupInput, arg2 ...request.Option) (*dynamodb.RestoreTableFromBackupOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "RestoreTableFromBackupWithContext", varargs...) + ret0, _ := ret[0].(*dynamodb.RestoreTableFromBackupOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RestoreTableFromBackupWithContext indicates an expected call of RestoreTableFromBackupWithContext +func (mr *MockDynamoDBAPIMockRecorder) RestoreTableFromBackupWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RestoreTableFromBackupWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).RestoreTableFromBackupWithContext), varargs...) +} + +// RestoreTableFromBackupRequest mocks base method +func (m *MockDynamoDBAPI) RestoreTableFromBackupRequest(arg0 *dynamodb.RestoreTableFromBackupInput) (*request.Request, *dynamodb.RestoreTableFromBackupOutput) { + ret := m.ctrl.Call(m, "RestoreTableFromBackupRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*dynamodb.RestoreTableFromBackupOutput) + return ret0, ret1 +} + +// RestoreTableFromBackupRequest indicates an expected call of RestoreTableFromBackupRequest +func (mr *MockDynamoDBAPIMockRecorder) RestoreTableFromBackupRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RestoreTableFromBackupRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).RestoreTableFromBackupRequest), arg0) +} + +// RestoreTableToPointInTime mocks base method +func (m *MockDynamoDBAPI) RestoreTableToPointInTime(arg0 *dynamodb.RestoreTableToPointInTimeInput) (*dynamodb.RestoreTableToPointInTimeOutput, error) { + ret := m.ctrl.Call(m, "RestoreTableToPointInTime", arg0) + ret0, _ := ret[0].(*dynamodb.RestoreTableToPointInTimeOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RestoreTableToPointInTime indicates an expected call of RestoreTableToPointInTime +func (mr *MockDynamoDBAPIMockRecorder) RestoreTableToPointInTime(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RestoreTableToPointInTime", reflect.TypeOf((*MockDynamoDBAPI)(nil).RestoreTableToPointInTime), arg0) +} + +// RestoreTableToPointInTimeWithContext mocks base method +func (m *MockDynamoDBAPI) RestoreTableToPointInTimeWithContext(arg0 aws.Context, arg1 *dynamodb.RestoreTableToPointInTimeInput, arg2 ...request.Option) (*dynamodb.RestoreTableToPointInTimeOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "RestoreTableToPointInTimeWithContext", varargs...) + ret0, _ := ret[0].(*dynamodb.RestoreTableToPointInTimeOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RestoreTableToPointInTimeWithContext indicates an expected call of RestoreTableToPointInTimeWithContext +func (mr *MockDynamoDBAPIMockRecorder) RestoreTableToPointInTimeWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RestoreTableToPointInTimeWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).RestoreTableToPointInTimeWithContext), varargs...) +} + +// RestoreTableToPointInTimeRequest mocks base method +func (m *MockDynamoDBAPI) RestoreTableToPointInTimeRequest(arg0 *dynamodb.RestoreTableToPointInTimeInput) (*request.Request, *dynamodb.RestoreTableToPointInTimeOutput) { + ret := m.ctrl.Call(m, "RestoreTableToPointInTimeRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*dynamodb.RestoreTableToPointInTimeOutput) + return ret0, ret1 +} + +// RestoreTableToPointInTimeRequest indicates an expected call of RestoreTableToPointInTimeRequest +func (mr *MockDynamoDBAPIMockRecorder) RestoreTableToPointInTimeRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RestoreTableToPointInTimeRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).RestoreTableToPointInTimeRequest), arg0) } // Scan mocks base method -func (_m *MockDynamoDBAPI) Scan(_param0 *dynamodb.ScanInput) (*dynamodb.ScanOutput, error) { - ret := _m.ctrl.Call(_m, "Scan", _param0) +func (m *MockDynamoDBAPI) Scan(arg0 *dynamodb.ScanInput) (*dynamodb.ScanOutput, error) { + ret := m.ctrl.Call(m, "Scan", arg0) ret0, _ := ret[0].(*dynamodb.ScanOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // Scan indicates an expected call of Scan -func (_mr *MockDynamoDBAPIMockRecorder) Scan(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "Scan", reflect.TypeOf((*MockDynamoDBAPI)(nil).Scan), arg0) +func (mr *MockDynamoDBAPIMockRecorder) Scan(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Scan", reflect.TypeOf((*MockDynamoDBAPI)(nil).Scan), arg0) } // ScanWithContext mocks base method -func (_m *MockDynamoDBAPI) ScanWithContext(_param0 aws.Context, _param1 *dynamodb.ScanInput, _param2 ...request.Option) (*dynamodb.ScanOutput, error) { - _s := []interface{}{_param0, _param1} - for _, _x := range _param2 { - _s = append(_s, _x) +func (m *MockDynamoDBAPI) ScanWithContext(arg0 aws.Context, arg1 *dynamodb.ScanInput, arg2 ...request.Option) (*dynamodb.ScanOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) } - ret := _m.ctrl.Call(_m, "ScanWithContext", _s...) + ret := m.ctrl.Call(m, "ScanWithContext", varargs...) ret0, _ := ret[0].(*dynamodb.ScanOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // ScanWithContext indicates an expected call of ScanWithContext -func (_mr *MockDynamoDBAPIMockRecorder) ScanWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - _s := append([]interface{}{arg0, arg1}, arg2...) - return _mr.mock.ctrl.RecordCall(_mr.mock, "ScanWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).ScanWithContext), _s...) +func (mr *MockDynamoDBAPIMockRecorder) ScanWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScanWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).ScanWithContext), varargs...) } // ScanRequest mocks base method -func (_m *MockDynamoDBAPI) ScanRequest(_param0 *dynamodb.ScanInput) (*request.Request, *dynamodb.ScanOutput) { - ret := _m.ctrl.Call(_m, "ScanRequest", _param0) +func (m *MockDynamoDBAPI) ScanRequest(arg0 *dynamodb.ScanInput) (*request.Request, *dynamodb.ScanOutput) { + ret := m.ctrl.Call(m, "ScanRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*dynamodb.ScanOutput) return ret0, ret1 } // ScanRequest indicates an expected call of ScanRequest -func (_mr *MockDynamoDBAPIMockRecorder) ScanRequest(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "ScanRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).ScanRequest), arg0) +func (mr *MockDynamoDBAPIMockRecorder) ScanRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScanRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).ScanRequest), arg0) } // ScanPages mocks base method -func (_m *MockDynamoDBAPI) ScanPages(_param0 *dynamodb.ScanInput, _param1 func(*dynamodb.ScanOutput, bool) bool) error { - ret := _m.ctrl.Call(_m, "ScanPages", _param0, _param1) +func (m *MockDynamoDBAPI) ScanPages(arg0 *dynamodb.ScanInput, arg1 func(*dynamodb.ScanOutput, bool) bool) error { + ret := m.ctrl.Call(m, "ScanPages", arg0, arg1) ret0, _ := ret[0].(error) return ret0 } // ScanPages indicates an expected call of ScanPages -func (_mr *MockDynamoDBAPIMockRecorder) ScanPages(arg0, arg1 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "ScanPages", reflect.TypeOf((*MockDynamoDBAPI)(nil).ScanPages), arg0, arg1) +func (mr *MockDynamoDBAPIMockRecorder) ScanPages(arg0, arg1 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScanPages", reflect.TypeOf((*MockDynamoDBAPI)(nil).ScanPages), arg0, arg1) } // ScanPagesWithContext mocks base method -func (_m *MockDynamoDBAPI) ScanPagesWithContext(_param0 aws.Context, _param1 *dynamodb.ScanInput, _param2 func(*dynamodb.ScanOutput, bool) bool, _param3 ...request.Option) error { - _s := []interface{}{_param0, _param1, _param2} - for _, _x := range _param3 { - _s = append(_s, _x) +func (m *MockDynamoDBAPI) ScanPagesWithContext(arg0 aws.Context, arg1 *dynamodb.ScanInput, arg2 func(*dynamodb.ScanOutput, bool) bool, arg3 ...request.Option) error { + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) } - ret := _m.ctrl.Call(_m, "ScanPagesWithContext", _s...) + ret := m.ctrl.Call(m, "ScanPagesWithContext", varargs...) ret0, _ := ret[0].(error) return ret0 } // ScanPagesWithContext indicates an expected call of ScanPagesWithContext -func (_mr *MockDynamoDBAPIMockRecorder) ScanPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { - _s := append([]interface{}{arg0, arg1, arg2}, arg3...) - return _mr.mock.ctrl.RecordCall(_mr.mock, "ScanPagesWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).ScanPagesWithContext), _s...) +func (mr *MockDynamoDBAPIMockRecorder) ScanPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScanPagesWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).ScanPagesWithContext), varargs...) } // TagResource mocks base method -func (_m *MockDynamoDBAPI) TagResource(_param0 *dynamodb.TagResourceInput) (*dynamodb.TagResourceOutput, error) { - ret := _m.ctrl.Call(_m, "TagResource", _param0) +func (m *MockDynamoDBAPI) TagResource(arg0 *dynamodb.TagResourceInput) (*dynamodb.TagResourceOutput, error) { + ret := m.ctrl.Call(m, "TagResource", arg0) ret0, _ := ret[0].(*dynamodb.TagResourceOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // TagResource indicates an expected call of TagResource -func (_mr *MockDynamoDBAPIMockRecorder) TagResource(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "TagResource", reflect.TypeOf((*MockDynamoDBAPI)(nil).TagResource), arg0) +func (mr *MockDynamoDBAPIMockRecorder) TagResource(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TagResource", reflect.TypeOf((*MockDynamoDBAPI)(nil).TagResource), arg0) } // TagResourceWithContext mocks base method -func (_m *MockDynamoDBAPI) TagResourceWithContext(_param0 aws.Context, _param1 *dynamodb.TagResourceInput, _param2 ...request.Option) (*dynamodb.TagResourceOutput, error) { - _s := []interface{}{_param0, _param1} - for _, _x := range _param2 { - _s = append(_s, _x) +func (m *MockDynamoDBAPI) TagResourceWithContext(arg0 aws.Context, arg1 *dynamodb.TagResourceInput, arg2 ...request.Option) (*dynamodb.TagResourceOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) } - ret := _m.ctrl.Call(_m, "TagResourceWithContext", _s...) + ret := m.ctrl.Call(m, "TagResourceWithContext", varargs...) ret0, _ := ret[0].(*dynamodb.TagResourceOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // TagResourceWithContext indicates an expected call of TagResourceWithContext -func (_mr *MockDynamoDBAPIMockRecorder) TagResourceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - _s := append([]interface{}{arg0, arg1}, arg2...) - return _mr.mock.ctrl.RecordCall(_mr.mock, "TagResourceWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).TagResourceWithContext), _s...) +func (mr *MockDynamoDBAPIMockRecorder) TagResourceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TagResourceWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).TagResourceWithContext), varargs...) } // TagResourceRequest mocks base method -func (_m *MockDynamoDBAPI) TagResourceRequest(_param0 *dynamodb.TagResourceInput) (*request.Request, *dynamodb.TagResourceOutput) { - ret := _m.ctrl.Call(_m, "TagResourceRequest", _param0) +func (m *MockDynamoDBAPI) TagResourceRequest(arg0 *dynamodb.TagResourceInput) (*request.Request, *dynamodb.TagResourceOutput) { + ret := m.ctrl.Call(m, "TagResourceRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*dynamodb.TagResourceOutput) return ret0, ret1 } // TagResourceRequest indicates an expected call of TagResourceRequest -func (_mr *MockDynamoDBAPIMockRecorder) TagResourceRequest(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "TagResourceRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).TagResourceRequest), arg0) +func (mr *MockDynamoDBAPIMockRecorder) TagResourceRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TagResourceRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).TagResourceRequest), arg0) } // UntagResource mocks base method -func (_m *MockDynamoDBAPI) UntagResource(_param0 *dynamodb.UntagResourceInput) (*dynamodb.UntagResourceOutput, error) { - ret := _m.ctrl.Call(_m, "UntagResource", _param0) +func (m *MockDynamoDBAPI) UntagResource(arg0 *dynamodb.UntagResourceInput) (*dynamodb.UntagResourceOutput, error) { + ret := m.ctrl.Call(m, "UntagResource", arg0) ret0, _ := ret[0].(*dynamodb.UntagResourceOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // UntagResource indicates an expected call of UntagResource -func (_mr *MockDynamoDBAPIMockRecorder) UntagResource(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "UntagResource", reflect.TypeOf((*MockDynamoDBAPI)(nil).UntagResource), arg0) +func (mr *MockDynamoDBAPIMockRecorder) UntagResource(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UntagResource", reflect.TypeOf((*MockDynamoDBAPI)(nil).UntagResource), arg0) } // UntagResourceWithContext mocks base method -func (_m *MockDynamoDBAPI) UntagResourceWithContext(_param0 aws.Context, _param1 *dynamodb.UntagResourceInput, _param2 ...request.Option) (*dynamodb.UntagResourceOutput, error) { - _s := []interface{}{_param0, _param1} - for _, _x := range _param2 { - _s = append(_s, _x) +func (m *MockDynamoDBAPI) UntagResourceWithContext(arg0 aws.Context, arg1 *dynamodb.UntagResourceInput, arg2 ...request.Option) (*dynamodb.UntagResourceOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) } - ret := _m.ctrl.Call(_m, "UntagResourceWithContext", _s...) + ret := m.ctrl.Call(m, "UntagResourceWithContext", varargs...) ret0, _ := ret[0].(*dynamodb.UntagResourceOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // UntagResourceWithContext indicates an expected call of UntagResourceWithContext -func (_mr *MockDynamoDBAPIMockRecorder) UntagResourceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - _s := append([]interface{}{arg0, arg1}, arg2...) - return _mr.mock.ctrl.RecordCall(_mr.mock, "UntagResourceWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).UntagResourceWithContext), _s...) +func (mr *MockDynamoDBAPIMockRecorder) UntagResourceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UntagResourceWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).UntagResourceWithContext), varargs...) } // UntagResourceRequest mocks base method -func (_m *MockDynamoDBAPI) UntagResourceRequest(_param0 *dynamodb.UntagResourceInput) (*request.Request, *dynamodb.UntagResourceOutput) { - ret := _m.ctrl.Call(_m, "UntagResourceRequest", _param0) +func (m *MockDynamoDBAPI) UntagResourceRequest(arg0 *dynamodb.UntagResourceInput) (*request.Request, *dynamodb.UntagResourceOutput) { + ret := m.ctrl.Call(m, "UntagResourceRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*dynamodb.UntagResourceOutput) return ret0, ret1 } // UntagResourceRequest indicates an expected call of UntagResourceRequest -func (_mr *MockDynamoDBAPIMockRecorder) UntagResourceRequest(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "UntagResourceRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).UntagResourceRequest), arg0) +func (mr *MockDynamoDBAPIMockRecorder) UntagResourceRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UntagResourceRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).UntagResourceRequest), arg0) +} + +// UpdateContinuousBackups mocks base method +func (m *MockDynamoDBAPI) UpdateContinuousBackups(arg0 *dynamodb.UpdateContinuousBackupsInput) (*dynamodb.UpdateContinuousBackupsOutput, error) { + ret := m.ctrl.Call(m, "UpdateContinuousBackups", arg0) + ret0, _ := ret[0].(*dynamodb.UpdateContinuousBackupsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateContinuousBackups indicates an expected call of UpdateContinuousBackups +func (mr *MockDynamoDBAPIMockRecorder) UpdateContinuousBackups(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateContinuousBackups", reflect.TypeOf((*MockDynamoDBAPI)(nil).UpdateContinuousBackups), arg0) +} + +// UpdateContinuousBackupsWithContext mocks base method +func (m *MockDynamoDBAPI) UpdateContinuousBackupsWithContext(arg0 aws.Context, arg1 *dynamodb.UpdateContinuousBackupsInput, arg2 ...request.Option) (*dynamodb.UpdateContinuousBackupsOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "UpdateContinuousBackupsWithContext", varargs...) + ret0, _ := ret[0].(*dynamodb.UpdateContinuousBackupsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateContinuousBackupsWithContext indicates an expected call of UpdateContinuousBackupsWithContext +func (mr *MockDynamoDBAPIMockRecorder) UpdateContinuousBackupsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateContinuousBackupsWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).UpdateContinuousBackupsWithContext), varargs...) +} + +// UpdateContinuousBackupsRequest mocks base method +func (m *MockDynamoDBAPI) UpdateContinuousBackupsRequest(arg0 *dynamodb.UpdateContinuousBackupsInput) (*request.Request, *dynamodb.UpdateContinuousBackupsOutput) { + ret := m.ctrl.Call(m, "UpdateContinuousBackupsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*dynamodb.UpdateContinuousBackupsOutput) + return ret0, ret1 +} + +// UpdateContinuousBackupsRequest indicates an expected call of UpdateContinuousBackupsRequest +func (mr *MockDynamoDBAPIMockRecorder) UpdateContinuousBackupsRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateContinuousBackupsRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).UpdateContinuousBackupsRequest), arg0) +} + +// UpdateGlobalTable mocks base method +func (m *MockDynamoDBAPI) UpdateGlobalTable(arg0 *dynamodb.UpdateGlobalTableInput) (*dynamodb.UpdateGlobalTableOutput, error) { + ret := m.ctrl.Call(m, "UpdateGlobalTable", arg0) + ret0, _ := ret[0].(*dynamodb.UpdateGlobalTableOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateGlobalTable indicates an expected call of UpdateGlobalTable +func (mr *MockDynamoDBAPIMockRecorder) UpdateGlobalTable(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateGlobalTable", reflect.TypeOf((*MockDynamoDBAPI)(nil).UpdateGlobalTable), arg0) +} + +// UpdateGlobalTableWithContext mocks base method +func (m *MockDynamoDBAPI) UpdateGlobalTableWithContext(arg0 aws.Context, arg1 *dynamodb.UpdateGlobalTableInput, arg2 ...request.Option) (*dynamodb.UpdateGlobalTableOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "UpdateGlobalTableWithContext", varargs...) + ret0, _ := ret[0].(*dynamodb.UpdateGlobalTableOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateGlobalTableWithContext indicates an expected call of UpdateGlobalTableWithContext +func (mr *MockDynamoDBAPIMockRecorder) UpdateGlobalTableWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateGlobalTableWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).UpdateGlobalTableWithContext), varargs...) +} + +// UpdateGlobalTableRequest mocks base method +func (m *MockDynamoDBAPI) UpdateGlobalTableRequest(arg0 *dynamodb.UpdateGlobalTableInput) (*request.Request, *dynamodb.UpdateGlobalTableOutput) { + ret := m.ctrl.Call(m, "UpdateGlobalTableRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*dynamodb.UpdateGlobalTableOutput) + return ret0, ret1 +} + +// UpdateGlobalTableRequest indicates an expected call of UpdateGlobalTableRequest +func (mr *MockDynamoDBAPIMockRecorder) UpdateGlobalTableRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateGlobalTableRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).UpdateGlobalTableRequest), arg0) +} + +// UpdateGlobalTableSettings mocks base method +func (m *MockDynamoDBAPI) UpdateGlobalTableSettings(arg0 *dynamodb.UpdateGlobalTableSettingsInput) (*dynamodb.UpdateGlobalTableSettingsOutput, error) { + ret := m.ctrl.Call(m, "UpdateGlobalTableSettings", arg0) + ret0, _ := ret[0].(*dynamodb.UpdateGlobalTableSettingsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateGlobalTableSettings indicates an expected call of UpdateGlobalTableSettings +func (mr *MockDynamoDBAPIMockRecorder) UpdateGlobalTableSettings(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateGlobalTableSettings", reflect.TypeOf((*MockDynamoDBAPI)(nil).UpdateGlobalTableSettings), arg0) +} + +// UpdateGlobalTableSettingsWithContext mocks base method +func (m *MockDynamoDBAPI) UpdateGlobalTableSettingsWithContext(arg0 aws.Context, arg1 *dynamodb.UpdateGlobalTableSettingsInput, arg2 ...request.Option) (*dynamodb.UpdateGlobalTableSettingsOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "UpdateGlobalTableSettingsWithContext", varargs...) + ret0, _ := ret[0].(*dynamodb.UpdateGlobalTableSettingsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateGlobalTableSettingsWithContext indicates an expected call of UpdateGlobalTableSettingsWithContext +func (mr *MockDynamoDBAPIMockRecorder) UpdateGlobalTableSettingsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateGlobalTableSettingsWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).UpdateGlobalTableSettingsWithContext), varargs...) +} + +// UpdateGlobalTableSettingsRequest mocks base method +func (m *MockDynamoDBAPI) UpdateGlobalTableSettingsRequest(arg0 *dynamodb.UpdateGlobalTableSettingsInput) (*request.Request, *dynamodb.UpdateGlobalTableSettingsOutput) { + ret := m.ctrl.Call(m, "UpdateGlobalTableSettingsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*dynamodb.UpdateGlobalTableSettingsOutput) + return ret0, ret1 +} + +// UpdateGlobalTableSettingsRequest indicates an expected call of UpdateGlobalTableSettingsRequest +func (mr *MockDynamoDBAPIMockRecorder) UpdateGlobalTableSettingsRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateGlobalTableSettingsRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).UpdateGlobalTableSettingsRequest), arg0) } // UpdateItem mocks base method -func (_m *MockDynamoDBAPI) UpdateItem(_param0 *dynamodb.UpdateItemInput) (*dynamodb.UpdateItemOutput, error) { - ret := _m.ctrl.Call(_m, "UpdateItem", _param0) +func (m *MockDynamoDBAPI) UpdateItem(arg0 *dynamodb.UpdateItemInput) (*dynamodb.UpdateItemOutput, error) { + ret := m.ctrl.Call(m, "UpdateItem", arg0) ret0, _ := ret[0].(*dynamodb.UpdateItemOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // UpdateItem indicates an expected call of UpdateItem -func (_mr *MockDynamoDBAPIMockRecorder) UpdateItem(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "UpdateItem", reflect.TypeOf((*MockDynamoDBAPI)(nil).UpdateItem), arg0) +func (mr *MockDynamoDBAPIMockRecorder) UpdateItem(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateItem", reflect.TypeOf((*MockDynamoDBAPI)(nil).UpdateItem), arg0) } // UpdateItemWithContext mocks base method -func (_m *MockDynamoDBAPI) UpdateItemWithContext(_param0 aws.Context, _param1 *dynamodb.UpdateItemInput, _param2 ...request.Option) (*dynamodb.UpdateItemOutput, error) { - _s := []interface{}{_param0, _param1} - for _, _x := range _param2 { - _s = append(_s, _x) +func (m *MockDynamoDBAPI) UpdateItemWithContext(arg0 aws.Context, arg1 *dynamodb.UpdateItemInput, arg2 ...request.Option) (*dynamodb.UpdateItemOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) } - ret := _m.ctrl.Call(_m, "UpdateItemWithContext", _s...) + ret := m.ctrl.Call(m, "UpdateItemWithContext", varargs...) ret0, _ := ret[0].(*dynamodb.UpdateItemOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // UpdateItemWithContext indicates an expected call of UpdateItemWithContext -func (_mr *MockDynamoDBAPIMockRecorder) UpdateItemWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - _s := append([]interface{}{arg0, arg1}, arg2...) - return _mr.mock.ctrl.RecordCall(_mr.mock, "UpdateItemWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).UpdateItemWithContext), _s...) +func (mr *MockDynamoDBAPIMockRecorder) UpdateItemWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateItemWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).UpdateItemWithContext), varargs...) } // UpdateItemRequest mocks base method -func (_m *MockDynamoDBAPI) UpdateItemRequest(_param0 *dynamodb.UpdateItemInput) (*request.Request, *dynamodb.UpdateItemOutput) { - ret := _m.ctrl.Call(_m, "UpdateItemRequest", _param0) +func (m *MockDynamoDBAPI) UpdateItemRequest(arg0 *dynamodb.UpdateItemInput) (*request.Request, *dynamodb.UpdateItemOutput) { + ret := m.ctrl.Call(m, "UpdateItemRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*dynamodb.UpdateItemOutput) return ret0, ret1 } // UpdateItemRequest indicates an expected call of UpdateItemRequest -func (_mr *MockDynamoDBAPIMockRecorder) UpdateItemRequest(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "UpdateItemRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).UpdateItemRequest), arg0) +func (mr *MockDynamoDBAPIMockRecorder) UpdateItemRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateItemRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).UpdateItemRequest), arg0) } // UpdateTable mocks base method -func (_m *MockDynamoDBAPI) UpdateTable(_param0 *dynamodb.UpdateTableInput) (*dynamodb.UpdateTableOutput, error) { - ret := _m.ctrl.Call(_m, "UpdateTable", _param0) +func (m *MockDynamoDBAPI) UpdateTable(arg0 *dynamodb.UpdateTableInput) (*dynamodb.UpdateTableOutput, error) { + ret := m.ctrl.Call(m, "UpdateTable", arg0) ret0, _ := ret[0].(*dynamodb.UpdateTableOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // UpdateTable indicates an expected call of UpdateTable -func (_mr *MockDynamoDBAPIMockRecorder) UpdateTable(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "UpdateTable", reflect.TypeOf((*MockDynamoDBAPI)(nil).UpdateTable), arg0) +func (mr *MockDynamoDBAPIMockRecorder) UpdateTable(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTable", reflect.TypeOf((*MockDynamoDBAPI)(nil).UpdateTable), arg0) } // UpdateTableWithContext mocks base method -func (_m *MockDynamoDBAPI) UpdateTableWithContext(_param0 aws.Context, _param1 *dynamodb.UpdateTableInput, _param2 ...request.Option) (*dynamodb.UpdateTableOutput, error) { - _s := []interface{}{_param0, _param1} - for _, _x := range _param2 { - _s = append(_s, _x) +func (m *MockDynamoDBAPI) UpdateTableWithContext(arg0 aws.Context, arg1 *dynamodb.UpdateTableInput, arg2 ...request.Option) (*dynamodb.UpdateTableOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) } - ret := _m.ctrl.Call(_m, "UpdateTableWithContext", _s...) + ret := m.ctrl.Call(m, "UpdateTableWithContext", varargs...) ret0, _ := ret[0].(*dynamodb.UpdateTableOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // UpdateTableWithContext indicates an expected call of UpdateTableWithContext -func (_mr *MockDynamoDBAPIMockRecorder) UpdateTableWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - _s := append([]interface{}{arg0, arg1}, arg2...) - return _mr.mock.ctrl.RecordCall(_mr.mock, "UpdateTableWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).UpdateTableWithContext), _s...) +func (mr *MockDynamoDBAPIMockRecorder) UpdateTableWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTableWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).UpdateTableWithContext), varargs...) } // UpdateTableRequest mocks base method -func (_m *MockDynamoDBAPI) UpdateTableRequest(_param0 *dynamodb.UpdateTableInput) (*request.Request, *dynamodb.UpdateTableOutput) { - ret := _m.ctrl.Call(_m, "UpdateTableRequest", _param0) +func (m *MockDynamoDBAPI) UpdateTableRequest(arg0 *dynamodb.UpdateTableInput) (*request.Request, *dynamodb.UpdateTableOutput) { + ret := m.ctrl.Call(m, "UpdateTableRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*dynamodb.UpdateTableOutput) return ret0, ret1 } // UpdateTableRequest indicates an expected call of UpdateTableRequest -func (_mr *MockDynamoDBAPIMockRecorder) UpdateTableRequest(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "UpdateTableRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).UpdateTableRequest), arg0) +func (mr *MockDynamoDBAPIMockRecorder) UpdateTableRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTableRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).UpdateTableRequest), arg0) } // UpdateTimeToLive mocks base method -func (_m *MockDynamoDBAPI) UpdateTimeToLive(_param0 *dynamodb.UpdateTimeToLiveInput) (*dynamodb.UpdateTimeToLiveOutput, error) { - ret := _m.ctrl.Call(_m, "UpdateTimeToLive", _param0) +func (m *MockDynamoDBAPI) UpdateTimeToLive(arg0 *dynamodb.UpdateTimeToLiveInput) (*dynamodb.UpdateTimeToLiveOutput, error) { + ret := m.ctrl.Call(m, "UpdateTimeToLive", arg0) ret0, _ := ret[0].(*dynamodb.UpdateTimeToLiveOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // UpdateTimeToLive indicates an expected call of UpdateTimeToLive -func (_mr *MockDynamoDBAPIMockRecorder) UpdateTimeToLive(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "UpdateTimeToLive", reflect.TypeOf((*MockDynamoDBAPI)(nil).UpdateTimeToLive), arg0) +func (mr *MockDynamoDBAPIMockRecorder) UpdateTimeToLive(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTimeToLive", reflect.TypeOf((*MockDynamoDBAPI)(nil).UpdateTimeToLive), arg0) } // UpdateTimeToLiveWithContext mocks base method -func (_m *MockDynamoDBAPI) UpdateTimeToLiveWithContext(_param0 aws.Context, _param1 *dynamodb.UpdateTimeToLiveInput, _param2 ...request.Option) (*dynamodb.UpdateTimeToLiveOutput, error) { - _s := []interface{}{_param0, _param1} - for _, _x := range _param2 { - _s = append(_s, _x) +func (m *MockDynamoDBAPI) UpdateTimeToLiveWithContext(arg0 aws.Context, arg1 *dynamodb.UpdateTimeToLiveInput, arg2 ...request.Option) (*dynamodb.UpdateTimeToLiveOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) } - ret := _m.ctrl.Call(_m, "UpdateTimeToLiveWithContext", _s...) + ret := m.ctrl.Call(m, "UpdateTimeToLiveWithContext", varargs...) ret0, _ := ret[0].(*dynamodb.UpdateTimeToLiveOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // UpdateTimeToLiveWithContext indicates an expected call of UpdateTimeToLiveWithContext -func (_mr *MockDynamoDBAPIMockRecorder) UpdateTimeToLiveWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - _s := append([]interface{}{arg0, arg1}, arg2...) - return _mr.mock.ctrl.RecordCall(_mr.mock, "UpdateTimeToLiveWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).UpdateTimeToLiveWithContext), _s...) +func (mr *MockDynamoDBAPIMockRecorder) UpdateTimeToLiveWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTimeToLiveWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).UpdateTimeToLiveWithContext), varargs...) } // UpdateTimeToLiveRequest mocks base method -func (_m *MockDynamoDBAPI) UpdateTimeToLiveRequest(_param0 *dynamodb.UpdateTimeToLiveInput) (*request.Request, *dynamodb.UpdateTimeToLiveOutput) { - ret := _m.ctrl.Call(_m, "UpdateTimeToLiveRequest", _param0) +func (m *MockDynamoDBAPI) UpdateTimeToLiveRequest(arg0 *dynamodb.UpdateTimeToLiveInput) (*request.Request, *dynamodb.UpdateTimeToLiveOutput) { + ret := m.ctrl.Call(m, "UpdateTimeToLiveRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*dynamodb.UpdateTimeToLiveOutput) return ret0, ret1 } // UpdateTimeToLiveRequest indicates an expected call of UpdateTimeToLiveRequest -func (_mr *MockDynamoDBAPIMockRecorder) UpdateTimeToLiveRequest(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "UpdateTimeToLiveRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).UpdateTimeToLiveRequest), arg0) +func (mr *MockDynamoDBAPIMockRecorder) UpdateTimeToLiveRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTimeToLiveRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).UpdateTimeToLiveRequest), arg0) } // WaitUntilTableExists mocks base method -func (_m *MockDynamoDBAPI) WaitUntilTableExists(_param0 *dynamodb.DescribeTableInput) error { - ret := _m.ctrl.Call(_m, "WaitUntilTableExists", _param0) +func (m *MockDynamoDBAPI) WaitUntilTableExists(arg0 *dynamodb.DescribeTableInput) error { + ret := m.ctrl.Call(m, "WaitUntilTableExists", arg0) ret0, _ := ret[0].(error) return ret0 } // WaitUntilTableExists indicates an expected call of WaitUntilTableExists -func (_mr *MockDynamoDBAPIMockRecorder) WaitUntilTableExists(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "WaitUntilTableExists", reflect.TypeOf((*MockDynamoDBAPI)(nil).WaitUntilTableExists), arg0) +func (mr *MockDynamoDBAPIMockRecorder) WaitUntilTableExists(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilTableExists", reflect.TypeOf((*MockDynamoDBAPI)(nil).WaitUntilTableExists), arg0) } // WaitUntilTableExistsWithContext mocks base method -func (_m *MockDynamoDBAPI) WaitUntilTableExistsWithContext(_param0 aws.Context, _param1 *dynamodb.DescribeTableInput, _param2 ...request.WaiterOption) error { - _s := []interface{}{_param0, _param1} - for _, _x := range _param2 { - _s = append(_s, _x) +func (m *MockDynamoDBAPI) WaitUntilTableExistsWithContext(arg0 aws.Context, arg1 *dynamodb.DescribeTableInput, arg2 ...request.WaiterOption) error { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) } - ret := _m.ctrl.Call(_m, "WaitUntilTableExistsWithContext", _s...) + ret := m.ctrl.Call(m, "WaitUntilTableExistsWithContext", varargs...) ret0, _ := ret[0].(error) return ret0 } // WaitUntilTableExistsWithContext indicates an expected call of WaitUntilTableExistsWithContext -func (_mr *MockDynamoDBAPIMockRecorder) WaitUntilTableExistsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - _s := append([]interface{}{arg0, arg1}, arg2...) - return _mr.mock.ctrl.RecordCall(_mr.mock, "WaitUntilTableExistsWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).WaitUntilTableExistsWithContext), _s...) +func (mr *MockDynamoDBAPIMockRecorder) WaitUntilTableExistsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilTableExistsWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).WaitUntilTableExistsWithContext), varargs...) } // WaitUntilTableNotExists mocks base method -func (_m *MockDynamoDBAPI) WaitUntilTableNotExists(_param0 *dynamodb.DescribeTableInput) error { - ret := _m.ctrl.Call(_m, "WaitUntilTableNotExists", _param0) +func (m *MockDynamoDBAPI) WaitUntilTableNotExists(arg0 *dynamodb.DescribeTableInput) error { + ret := m.ctrl.Call(m, "WaitUntilTableNotExists", arg0) ret0, _ := ret[0].(error) return ret0 } // WaitUntilTableNotExists indicates an expected call of WaitUntilTableNotExists -func (_mr *MockDynamoDBAPIMockRecorder) WaitUntilTableNotExists(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "WaitUntilTableNotExists", reflect.TypeOf((*MockDynamoDBAPI)(nil).WaitUntilTableNotExists), arg0) +func (mr *MockDynamoDBAPIMockRecorder) WaitUntilTableNotExists(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilTableNotExists", reflect.TypeOf((*MockDynamoDBAPI)(nil).WaitUntilTableNotExists), arg0) } // WaitUntilTableNotExistsWithContext mocks base method -func (_m *MockDynamoDBAPI) WaitUntilTableNotExistsWithContext(_param0 aws.Context, _param1 *dynamodb.DescribeTableInput, _param2 ...request.WaiterOption) error { - _s := []interface{}{_param0, _param1} - for _, _x := range _param2 { - _s = append(_s, _x) +func (m *MockDynamoDBAPI) WaitUntilTableNotExistsWithContext(arg0 aws.Context, arg1 *dynamodb.DescribeTableInput, arg2 ...request.WaiterOption) error { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) } - ret := _m.ctrl.Call(_m, "WaitUntilTableNotExistsWithContext", _s...) + ret := m.ctrl.Call(m, "WaitUntilTableNotExistsWithContext", varargs...) ret0, _ := ret[0].(error) return ret0 } // WaitUntilTableNotExistsWithContext indicates an expected call of WaitUntilTableNotExistsWithContext -func (_mr *MockDynamoDBAPIMockRecorder) WaitUntilTableNotExistsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - _s := append([]interface{}{arg0, arg1}, arg2...) - return _mr.mock.ctrl.RecordCall(_mr.mock, "WaitUntilTableNotExistsWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).WaitUntilTableNotExistsWithContext), _s...) +func (mr *MockDynamoDBAPIMockRecorder) WaitUntilTableNotExistsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilTableNotExistsWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).WaitUntilTableNotExistsWithContext), varargs...) } diff --git a/src/mockaws/kmsmock.go b/src/mockaws/kmsmock.go index ef3c738..9695d92 100644 --- a/src/mockaws/kmsmock.go +++ b/src/mockaws/kmsmock.go @@ -1,6 +1,7 @@ // Code generated by MockGen. DO NOT EDIT. -// Source: /Users/sugawara/.go/src/github.com/aws/aws-sdk-go/service/kms/kmsiface/interface.go +// Source: /Users/tmc/go/src/github.com/aws/aws-sdk-go/service/kms/kmsiface/interface.go +// Package mockaws is a generated GoMock package. package mockaws import ( @@ -30,1662 +31,1662 @@ func NewMockKMSAPI(ctrl *gomock.Controller) *MockKMSAPI { } // EXPECT returns an object that allows the caller to indicate expected use -func (_m *MockKMSAPI) EXPECT() *MockKMSAPIMockRecorder { - return _m.recorder +func (m *MockKMSAPI) EXPECT() *MockKMSAPIMockRecorder { + return m.recorder } // CancelKeyDeletion mocks base method -func (_m *MockKMSAPI) CancelKeyDeletion(_param0 *kms.CancelKeyDeletionInput) (*kms.CancelKeyDeletionOutput, error) { - ret := _m.ctrl.Call(_m, "CancelKeyDeletion", _param0) +func (m *MockKMSAPI) CancelKeyDeletion(arg0 *kms.CancelKeyDeletionInput) (*kms.CancelKeyDeletionOutput, error) { + 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 { - return _mr.mock.ctrl.RecordCall(_mr.mock, "CancelKeyDeletion", reflect.TypeOf((*MockKMSAPI)(nil).CancelKeyDeletion), arg0) +func (mr *MockKMSAPIMockRecorder) CancelKeyDeletion(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelKeyDeletion", reflect.TypeOf((*MockKMSAPI)(nil).CancelKeyDeletion), arg0) } // CancelKeyDeletionWithContext mocks base method -func (_m *MockKMSAPI) CancelKeyDeletionWithContext(_param0 aws.Context, _param1 *kms.CancelKeyDeletionInput, _param2 ...request.Option) (*kms.CancelKeyDeletionOutput, error) { - _s := []interface{}{_param0, _param1} - for _, _x := range _param2 { - _s = append(_s, _x) +func (m *MockKMSAPI) CancelKeyDeletionWithContext(arg0 aws.Context, arg1 *kms.CancelKeyDeletionInput, arg2 ...request.Option) (*kms.CancelKeyDeletionOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) } - ret := _m.ctrl.Call(_m, "CancelKeyDeletionWithContext", _s...) + 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 { - _s := append([]interface{}{arg0, arg1}, arg2...) - return _mr.mock.ctrl.RecordCall(_mr.mock, "CancelKeyDeletionWithContext", reflect.TypeOf((*MockKMSAPI)(nil).CancelKeyDeletionWithContext), _s...) +func (mr *MockKMSAPIMockRecorder) CancelKeyDeletionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelKeyDeletionWithContext", reflect.TypeOf((*MockKMSAPI)(nil).CancelKeyDeletionWithContext), varargs...) } // CancelKeyDeletionRequest mocks base method -func (_m *MockKMSAPI) CancelKeyDeletionRequest(_param0 *kms.CancelKeyDeletionInput) (*request.Request, *kms.CancelKeyDeletionOutput) { - ret := _m.ctrl.Call(_m, "CancelKeyDeletionRequest", _param0) +func (m *MockKMSAPI) CancelKeyDeletionRequest(arg0 *kms.CancelKeyDeletionInput) (*request.Request, *kms.CancelKeyDeletionOutput) { + 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 { - return _mr.mock.ctrl.RecordCall(_mr.mock, "CancelKeyDeletionRequest", reflect.TypeOf((*MockKMSAPI)(nil).CancelKeyDeletionRequest), arg0) +func (mr *MockKMSAPIMockRecorder) CancelKeyDeletionRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelKeyDeletionRequest", reflect.TypeOf((*MockKMSAPI)(nil).CancelKeyDeletionRequest), arg0) } // CreateAlias mocks base method -func (_m *MockKMSAPI) CreateAlias(_param0 *kms.CreateAliasInput) (*kms.CreateAliasOutput, error) { - ret := _m.ctrl.Call(_m, "CreateAlias", _param0) +func (m *MockKMSAPI) CreateAlias(arg0 *kms.CreateAliasInput) (*kms.CreateAliasOutput, error) { + 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 { - return _mr.mock.ctrl.RecordCall(_mr.mock, "CreateAlias", reflect.TypeOf((*MockKMSAPI)(nil).CreateAlias), arg0) +func (mr *MockKMSAPIMockRecorder) CreateAlias(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateAlias", reflect.TypeOf((*MockKMSAPI)(nil).CreateAlias), arg0) } // CreateAliasWithContext mocks base method -func (_m *MockKMSAPI) CreateAliasWithContext(_param0 aws.Context, _param1 *kms.CreateAliasInput, _param2 ...request.Option) (*kms.CreateAliasOutput, error) { - _s := []interface{}{_param0, _param1} - for _, _x := range _param2 { - _s = append(_s, _x) +func (m *MockKMSAPI) CreateAliasWithContext(arg0 aws.Context, arg1 *kms.CreateAliasInput, arg2 ...request.Option) (*kms.CreateAliasOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) } - ret := _m.ctrl.Call(_m, "CreateAliasWithContext", _s...) + 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 { - _s := append([]interface{}{arg0, arg1}, arg2...) - return _mr.mock.ctrl.RecordCall(_mr.mock, "CreateAliasWithContext", reflect.TypeOf((*MockKMSAPI)(nil).CreateAliasWithContext), _s...) +func (mr *MockKMSAPIMockRecorder) CreateAliasWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateAliasWithContext", reflect.TypeOf((*MockKMSAPI)(nil).CreateAliasWithContext), varargs...) } // CreateAliasRequest mocks base method -func (_m *MockKMSAPI) CreateAliasRequest(_param0 *kms.CreateAliasInput) (*request.Request, *kms.CreateAliasOutput) { - ret := _m.ctrl.Call(_m, "CreateAliasRequest", _param0) +func (m *MockKMSAPI) CreateAliasRequest(arg0 *kms.CreateAliasInput) (*request.Request, *kms.CreateAliasOutput) { + 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 { - return _mr.mock.ctrl.RecordCall(_mr.mock, "CreateAliasRequest", reflect.TypeOf((*MockKMSAPI)(nil).CreateAliasRequest), arg0) +func (mr *MockKMSAPIMockRecorder) CreateAliasRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateAliasRequest", reflect.TypeOf((*MockKMSAPI)(nil).CreateAliasRequest), arg0) } // CreateGrant mocks base method -func (_m *MockKMSAPI) CreateGrant(_param0 *kms.CreateGrantInput) (*kms.CreateGrantOutput, error) { - ret := _m.ctrl.Call(_m, "CreateGrant", _param0) +func (m *MockKMSAPI) CreateGrant(arg0 *kms.CreateGrantInput) (*kms.CreateGrantOutput, error) { + 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 { - return _mr.mock.ctrl.RecordCall(_mr.mock, "CreateGrant", reflect.TypeOf((*MockKMSAPI)(nil).CreateGrant), arg0) +func (mr *MockKMSAPIMockRecorder) CreateGrant(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateGrant", reflect.TypeOf((*MockKMSAPI)(nil).CreateGrant), arg0) } // CreateGrantWithContext mocks base method -func (_m *MockKMSAPI) CreateGrantWithContext(_param0 aws.Context, _param1 *kms.CreateGrantInput, _param2 ...request.Option) (*kms.CreateGrantOutput, error) { - _s := []interface{}{_param0, _param1} - for _, _x := range _param2 { - _s = append(_s, _x) +func (m *MockKMSAPI) CreateGrantWithContext(arg0 aws.Context, arg1 *kms.CreateGrantInput, arg2 ...request.Option) (*kms.CreateGrantOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) } - ret := _m.ctrl.Call(_m, "CreateGrantWithContext", _s...) + 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 { - _s := append([]interface{}{arg0, arg1}, arg2...) - return _mr.mock.ctrl.RecordCall(_mr.mock, "CreateGrantWithContext", reflect.TypeOf((*MockKMSAPI)(nil).CreateGrantWithContext), _s...) +func (mr *MockKMSAPIMockRecorder) CreateGrantWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateGrantWithContext", reflect.TypeOf((*MockKMSAPI)(nil).CreateGrantWithContext), varargs...) } // CreateGrantRequest mocks base method -func (_m *MockKMSAPI) CreateGrantRequest(_param0 *kms.CreateGrantInput) (*request.Request, *kms.CreateGrantOutput) { - ret := _m.ctrl.Call(_m, "CreateGrantRequest", _param0) +func (m *MockKMSAPI) CreateGrantRequest(arg0 *kms.CreateGrantInput) (*request.Request, *kms.CreateGrantOutput) { + 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 { - return _mr.mock.ctrl.RecordCall(_mr.mock, "CreateGrantRequest", reflect.TypeOf((*MockKMSAPI)(nil).CreateGrantRequest), arg0) +func (mr *MockKMSAPIMockRecorder) CreateGrantRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateGrantRequest", reflect.TypeOf((*MockKMSAPI)(nil).CreateGrantRequest), arg0) } // CreateKey mocks base method -func (_m *MockKMSAPI) CreateKey(_param0 *kms.CreateKeyInput) (*kms.CreateKeyOutput, error) { - ret := _m.ctrl.Call(_m, "CreateKey", _param0) +func (m *MockKMSAPI) CreateKey(arg0 *kms.CreateKeyInput) (*kms.CreateKeyOutput, error) { + 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 { - return _mr.mock.ctrl.RecordCall(_mr.mock, "CreateKey", reflect.TypeOf((*MockKMSAPI)(nil).CreateKey), arg0) +func (mr *MockKMSAPIMockRecorder) CreateKey(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateKey", reflect.TypeOf((*MockKMSAPI)(nil).CreateKey), arg0) } // CreateKeyWithContext mocks base method -func (_m *MockKMSAPI) CreateKeyWithContext(_param0 aws.Context, _param1 *kms.CreateKeyInput, _param2 ...request.Option) (*kms.CreateKeyOutput, error) { - _s := []interface{}{_param0, _param1} - for _, _x := range _param2 { - _s = append(_s, _x) +func (m *MockKMSAPI) CreateKeyWithContext(arg0 aws.Context, arg1 *kms.CreateKeyInput, arg2 ...request.Option) (*kms.CreateKeyOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) } - ret := _m.ctrl.Call(_m, "CreateKeyWithContext", _s...) + 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 { - _s := append([]interface{}{arg0, arg1}, arg2...) - return _mr.mock.ctrl.RecordCall(_mr.mock, "CreateKeyWithContext", reflect.TypeOf((*MockKMSAPI)(nil).CreateKeyWithContext), _s...) +func (mr *MockKMSAPIMockRecorder) CreateKeyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateKeyWithContext", reflect.TypeOf((*MockKMSAPI)(nil).CreateKeyWithContext), varargs...) } // CreateKeyRequest mocks base method -func (_m *MockKMSAPI) CreateKeyRequest(_param0 *kms.CreateKeyInput) (*request.Request, *kms.CreateKeyOutput) { - ret := _m.ctrl.Call(_m, "CreateKeyRequest", _param0) +func (m *MockKMSAPI) CreateKeyRequest(arg0 *kms.CreateKeyInput) (*request.Request, *kms.CreateKeyOutput) { + 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 { - return _mr.mock.ctrl.RecordCall(_mr.mock, "CreateKeyRequest", reflect.TypeOf((*MockKMSAPI)(nil).CreateKeyRequest), arg0) +func (mr *MockKMSAPIMockRecorder) CreateKeyRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateKeyRequest", reflect.TypeOf((*MockKMSAPI)(nil).CreateKeyRequest), arg0) } // Decrypt mocks base method -func (_m *MockKMSAPI) Decrypt(_param0 *kms.DecryptInput) (*kms.DecryptOutput, error) { - ret := _m.ctrl.Call(_m, "Decrypt", _param0) +func (m *MockKMSAPI) Decrypt(arg0 *kms.DecryptInput) (*kms.DecryptOutput, error) { + 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 { - return _mr.mock.ctrl.RecordCall(_mr.mock, "Decrypt", reflect.TypeOf((*MockKMSAPI)(nil).Decrypt), arg0) +func (mr *MockKMSAPIMockRecorder) Decrypt(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Decrypt", reflect.TypeOf((*MockKMSAPI)(nil).Decrypt), arg0) } // DecryptWithContext mocks base method -func (_m *MockKMSAPI) DecryptWithContext(_param0 aws.Context, _param1 *kms.DecryptInput, _param2 ...request.Option) (*kms.DecryptOutput, error) { - _s := []interface{}{_param0, _param1} - for _, _x := range _param2 { - _s = append(_s, _x) +func (m *MockKMSAPI) DecryptWithContext(arg0 aws.Context, arg1 *kms.DecryptInput, arg2 ...request.Option) (*kms.DecryptOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) } - ret := _m.ctrl.Call(_m, "DecryptWithContext", _s...) + 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 { - _s := append([]interface{}{arg0, arg1}, arg2...) - return _mr.mock.ctrl.RecordCall(_mr.mock, "DecryptWithContext", reflect.TypeOf((*MockKMSAPI)(nil).DecryptWithContext), _s...) +func (mr *MockKMSAPIMockRecorder) DecryptWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DecryptWithContext", reflect.TypeOf((*MockKMSAPI)(nil).DecryptWithContext), varargs...) } // DecryptRequest mocks base method -func (_m *MockKMSAPI) DecryptRequest(_param0 *kms.DecryptInput) (*request.Request, *kms.DecryptOutput) { - ret := _m.ctrl.Call(_m, "DecryptRequest", _param0) +func (m *MockKMSAPI) DecryptRequest(arg0 *kms.DecryptInput) (*request.Request, *kms.DecryptOutput) { + 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 { - return _mr.mock.ctrl.RecordCall(_mr.mock, "DecryptRequest", reflect.TypeOf((*MockKMSAPI)(nil).DecryptRequest), arg0) +func (mr *MockKMSAPIMockRecorder) DecryptRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DecryptRequest", reflect.TypeOf((*MockKMSAPI)(nil).DecryptRequest), arg0) } // DeleteAlias mocks base method -func (_m *MockKMSAPI) DeleteAlias(_param0 *kms.DeleteAliasInput) (*kms.DeleteAliasOutput, error) { - ret := _m.ctrl.Call(_m, "DeleteAlias", _param0) +func (m *MockKMSAPI) DeleteAlias(arg0 *kms.DeleteAliasInput) (*kms.DeleteAliasOutput, error) { + 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 { - return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteAlias", reflect.TypeOf((*MockKMSAPI)(nil).DeleteAlias), arg0) +func (mr *MockKMSAPIMockRecorder) DeleteAlias(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAlias", reflect.TypeOf((*MockKMSAPI)(nil).DeleteAlias), arg0) } // DeleteAliasWithContext mocks base method -func (_m *MockKMSAPI) DeleteAliasWithContext(_param0 aws.Context, _param1 *kms.DeleteAliasInput, _param2 ...request.Option) (*kms.DeleteAliasOutput, error) { - _s := []interface{}{_param0, _param1} - for _, _x := range _param2 { - _s = append(_s, _x) +func (m *MockKMSAPI) DeleteAliasWithContext(arg0 aws.Context, arg1 *kms.DeleteAliasInput, arg2 ...request.Option) (*kms.DeleteAliasOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) } - ret := _m.ctrl.Call(_m, "DeleteAliasWithContext", _s...) + 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 { - _s := append([]interface{}{arg0, arg1}, arg2...) - return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteAliasWithContext", reflect.TypeOf((*MockKMSAPI)(nil).DeleteAliasWithContext), _s...) +func (mr *MockKMSAPIMockRecorder) DeleteAliasWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAliasWithContext", reflect.TypeOf((*MockKMSAPI)(nil).DeleteAliasWithContext), varargs...) } // DeleteAliasRequest mocks base method -func (_m *MockKMSAPI) DeleteAliasRequest(_param0 *kms.DeleteAliasInput) (*request.Request, *kms.DeleteAliasOutput) { - ret := _m.ctrl.Call(_m, "DeleteAliasRequest", _param0) +func (m *MockKMSAPI) DeleteAliasRequest(arg0 *kms.DeleteAliasInput) (*request.Request, *kms.DeleteAliasOutput) { + 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 { - return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteAliasRequest", reflect.TypeOf((*MockKMSAPI)(nil).DeleteAliasRequest), arg0) +func (mr *MockKMSAPIMockRecorder) DeleteAliasRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAliasRequest", reflect.TypeOf((*MockKMSAPI)(nil).DeleteAliasRequest), arg0) } // DeleteImportedKeyMaterial mocks base method -func (_m *MockKMSAPI) DeleteImportedKeyMaterial(_param0 *kms.DeleteImportedKeyMaterialInput) (*kms.DeleteImportedKeyMaterialOutput, error) { - ret := _m.ctrl.Call(_m, "DeleteImportedKeyMaterial", _param0) +func (m *MockKMSAPI) DeleteImportedKeyMaterial(arg0 *kms.DeleteImportedKeyMaterialInput) (*kms.DeleteImportedKeyMaterialOutput, error) { + 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 { - return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteImportedKeyMaterial", reflect.TypeOf((*MockKMSAPI)(nil).DeleteImportedKeyMaterial), arg0) +func (mr *MockKMSAPIMockRecorder) DeleteImportedKeyMaterial(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteImportedKeyMaterial", reflect.TypeOf((*MockKMSAPI)(nil).DeleteImportedKeyMaterial), arg0) } // DeleteImportedKeyMaterialWithContext mocks base method -func (_m *MockKMSAPI) DeleteImportedKeyMaterialWithContext(_param0 aws.Context, _param1 *kms.DeleteImportedKeyMaterialInput, _param2 ...request.Option) (*kms.DeleteImportedKeyMaterialOutput, error) { - _s := []interface{}{_param0, _param1} - for _, _x := range _param2 { - _s = append(_s, _x) +func (m *MockKMSAPI) DeleteImportedKeyMaterialWithContext(arg0 aws.Context, arg1 *kms.DeleteImportedKeyMaterialInput, arg2 ...request.Option) (*kms.DeleteImportedKeyMaterialOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) } - ret := _m.ctrl.Call(_m, "DeleteImportedKeyMaterialWithContext", _s...) + 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 { - _s := append([]interface{}{arg0, arg1}, arg2...) - return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteImportedKeyMaterialWithContext", reflect.TypeOf((*MockKMSAPI)(nil).DeleteImportedKeyMaterialWithContext), _s...) +func (mr *MockKMSAPIMockRecorder) DeleteImportedKeyMaterialWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteImportedKeyMaterialWithContext", reflect.TypeOf((*MockKMSAPI)(nil).DeleteImportedKeyMaterialWithContext), varargs...) } // DeleteImportedKeyMaterialRequest mocks base method -func (_m *MockKMSAPI) DeleteImportedKeyMaterialRequest(_param0 *kms.DeleteImportedKeyMaterialInput) (*request.Request, *kms.DeleteImportedKeyMaterialOutput) { - ret := _m.ctrl.Call(_m, "DeleteImportedKeyMaterialRequest", _param0) +func (m *MockKMSAPI) DeleteImportedKeyMaterialRequest(arg0 *kms.DeleteImportedKeyMaterialInput) (*request.Request, *kms.DeleteImportedKeyMaterialOutput) { + 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 { - return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteImportedKeyMaterialRequest", reflect.TypeOf((*MockKMSAPI)(nil).DeleteImportedKeyMaterialRequest), arg0) +func (mr *MockKMSAPIMockRecorder) DeleteImportedKeyMaterialRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteImportedKeyMaterialRequest", reflect.TypeOf((*MockKMSAPI)(nil).DeleteImportedKeyMaterialRequest), arg0) } // DescribeKey mocks base method -func (_m *MockKMSAPI) DescribeKey(_param0 *kms.DescribeKeyInput) (*kms.DescribeKeyOutput, error) { - ret := _m.ctrl.Call(_m, "DescribeKey", _param0) +func (m *MockKMSAPI) DescribeKey(arg0 *kms.DescribeKeyInput) (*kms.DescribeKeyOutput, error) { + 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 { - return _mr.mock.ctrl.RecordCall(_mr.mock, "DescribeKey", reflect.TypeOf((*MockKMSAPI)(nil).DescribeKey), arg0) +func (mr *MockKMSAPIMockRecorder) DescribeKey(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeKey", reflect.TypeOf((*MockKMSAPI)(nil).DescribeKey), arg0) } // DescribeKeyWithContext mocks base method -func (_m *MockKMSAPI) DescribeKeyWithContext(_param0 aws.Context, _param1 *kms.DescribeKeyInput, _param2 ...request.Option) (*kms.DescribeKeyOutput, error) { - _s := []interface{}{_param0, _param1} - for _, _x := range _param2 { - _s = append(_s, _x) +func (m *MockKMSAPI) DescribeKeyWithContext(arg0 aws.Context, arg1 *kms.DescribeKeyInput, arg2 ...request.Option) (*kms.DescribeKeyOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) } - ret := _m.ctrl.Call(_m, "DescribeKeyWithContext", _s...) + 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 { - _s := append([]interface{}{arg0, arg1}, arg2...) - return _mr.mock.ctrl.RecordCall(_mr.mock, "DescribeKeyWithContext", reflect.TypeOf((*MockKMSAPI)(nil).DescribeKeyWithContext), _s...) +func (mr *MockKMSAPIMockRecorder) DescribeKeyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeKeyWithContext", reflect.TypeOf((*MockKMSAPI)(nil).DescribeKeyWithContext), varargs...) } // DescribeKeyRequest mocks base method -func (_m *MockKMSAPI) DescribeKeyRequest(_param0 *kms.DescribeKeyInput) (*request.Request, *kms.DescribeKeyOutput) { - ret := _m.ctrl.Call(_m, "DescribeKeyRequest", _param0) +func (m *MockKMSAPI) DescribeKeyRequest(arg0 *kms.DescribeKeyInput) (*request.Request, *kms.DescribeKeyOutput) { + 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 { - return _mr.mock.ctrl.RecordCall(_mr.mock, "DescribeKeyRequest", reflect.TypeOf((*MockKMSAPI)(nil).DescribeKeyRequest), arg0) +func (mr *MockKMSAPIMockRecorder) DescribeKeyRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeKeyRequest", reflect.TypeOf((*MockKMSAPI)(nil).DescribeKeyRequest), arg0) } // DisableKey mocks base method -func (_m *MockKMSAPI) DisableKey(_param0 *kms.DisableKeyInput) (*kms.DisableKeyOutput, error) { - ret := _m.ctrl.Call(_m, "DisableKey", _param0) +func (m *MockKMSAPI) DisableKey(arg0 *kms.DisableKeyInput) (*kms.DisableKeyOutput, error) { + 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 { - return _mr.mock.ctrl.RecordCall(_mr.mock, "DisableKey", reflect.TypeOf((*MockKMSAPI)(nil).DisableKey), arg0) +func (mr *MockKMSAPIMockRecorder) DisableKey(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableKey", reflect.TypeOf((*MockKMSAPI)(nil).DisableKey), arg0) } // DisableKeyWithContext mocks base method -func (_m *MockKMSAPI) DisableKeyWithContext(_param0 aws.Context, _param1 *kms.DisableKeyInput, _param2 ...request.Option) (*kms.DisableKeyOutput, error) { - _s := []interface{}{_param0, _param1} - for _, _x := range _param2 { - _s = append(_s, _x) +func (m *MockKMSAPI) DisableKeyWithContext(arg0 aws.Context, arg1 *kms.DisableKeyInput, arg2 ...request.Option) (*kms.DisableKeyOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) } - ret := _m.ctrl.Call(_m, "DisableKeyWithContext", _s...) + 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 { - _s := append([]interface{}{arg0, arg1}, arg2...) - return _mr.mock.ctrl.RecordCall(_mr.mock, "DisableKeyWithContext", reflect.TypeOf((*MockKMSAPI)(nil).DisableKeyWithContext), _s...) +func (mr *MockKMSAPIMockRecorder) DisableKeyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableKeyWithContext", reflect.TypeOf((*MockKMSAPI)(nil).DisableKeyWithContext), varargs...) } // DisableKeyRequest mocks base method -func (_m *MockKMSAPI) DisableKeyRequest(_param0 *kms.DisableKeyInput) (*request.Request, *kms.DisableKeyOutput) { - ret := _m.ctrl.Call(_m, "DisableKeyRequest", _param0) +func (m *MockKMSAPI) DisableKeyRequest(arg0 *kms.DisableKeyInput) (*request.Request, *kms.DisableKeyOutput) { + 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 { - return _mr.mock.ctrl.RecordCall(_mr.mock, "DisableKeyRequest", reflect.TypeOf((*MockKMSAPI)(nil).DisableKeyRequest), arg0) +func (mr *MockKMSAPIMockRecorder) DisableKeyRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableKeyRequest", reflect.TypeOf((*MockKMSAPI)(nil).DisableKeyRequest), arg0) } // DisableKeyRotation mocks base method -func (_m *MockKMSAPI) DisableKeyRotation(_param0 *kms.DisableKeyRotationInput) (*kms.DisableKeyRotationOutput, error) { - ret := _m.ctrl.Call(_m, "DisableKeyRotation", _param0) +func (m *MockKMSAPI) DisableKeyRotation(arg0 *kms.DisableKeyRotationInput) (*kms.DisableKeyRotationOutput, error) { + 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 { - return _mr.mock.ctrl.RecordCall(_mr.mock, "DisableKeyRotation", reflect.TypeOf((*MockKMSAPI)(nil).DisableKeyRotation), arg0) +func (mr *MockKMSAPIMockRecorder) DisableKeyRotation(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableKeyRotation", reflect.TypeOf((*MockKMSAPI)(nil).DisableKeyRotation), arg0) } // DisableKeyRotationWithContext mocks base method -func (_m *MockKMSAPI) DisableKeyRotationWithContext(_param0 aws.Context, _param1 *kms.DisableKeyRotationInput, _param2 ...request.Option) (*kms.DisableKeyRotationOutput, error) { - _s := []interface{}{_param0, _param1} - for _, _x := range _param2 { - _s = append(_s, _x) +func (m *MockKMSAPI) DisableKeyRotationWithContext(arg0 aws.Context, arg1 *kms.DisableKeyRotationInput, arg2 ...request.Option) (*kms.DisableKeyRotationOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) } - ret := _m.ctrl.Call(_m, "DisableKeyRotationWithContext", _s...) + 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 { - _s := append([]interface{}{arg0, arg1}, arg2...) - return _mr.mock.ctrl.RecordCall(_mr.mock, "DisableKeyRotationWithContext", reflect.TypeOf((*MockKMSAPI)(nil).DisableKeyRotationWithContext), _s...) +func (mr *MockKMSAPIMockRecorder) DisableKeyRotationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableKeyRotationWithContext", reflect.TypeOf((*MockKMSAPI)(nil).DisableKeyRotationWithContext), varargs...) } // DisableKeyRotationRequest mocks base method -func (_m *MockKMSAPI) DisableKeyRotationRequest(_param0 *kms.DisableKeyRotationInput) (*request.Request, *kms.DisableKeyRotationOutput) { - ret := _m.ctrl.Call(_m, "DisableKeyRotationRequest", _param0) +func (m *MockKMSAPI) DisableKeyRotationRequest(arg0 *kms.DisableKeyRotationInput) (*request.Request, *kms.DisableKeyRotationOutput) { + 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 { - return _mr.mock.ctrl.RecordCall(_mr.mock, "DisableKeyRotationRequest", reflect.TypeOf((*MockKMSAPI)(nil).DisableKeyRotationRequest), arg0) +func (mr *MockKMSAPIMockRecorder) DisableKeyRotationRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableKeyRotationRequest", reflect.TypeOf((*MockKMSAPI)(nil).DisableKeyRotationRequest), arg0) } // EnableKey mocks base method -func (_m *MockKMSAPI) EnableKey(_param0 *kms.EnableKeyInput) (*kms.EnableKeyOutput, error) { - ret := _m.ctrl.Call(_m, "EnableKey", _param0) +func (m *MockKMSAPI) EnableKey(arg0 *kms.EnableKeyInput) (*kms.EnableKeyOutput, error) { + 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 { - return _mr.mock.ctrl.RecordCall(_mr.mock, "EnableKey", reflect.TypeOf((*MockKMSAPI)(nil).EnableKey), arg0) +func (mr *MockKMSAPIMockRecorder) EnableKey(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableKey", reflect.TypeOf((*MockKMSAPI)(nil).EnableKey), arg0) } // EnableKeyWithContext mocks base method -func (_m *MockKMSAPI) EnableKeyWithContext(_param0 aws.Context, _param1 *kms.EnableKeyInput, _param2 ...request.Option) (*kms.EnableKeyOutput, error) { - _s := []interface{}{_param0, _param1} - for _, _x := range _param2 { - _s = append(_s, _x) +func (m *MockKMSAPI) EnableKeyWithContext(arg0 aws.Context, arg1 *kms.EnableKeyInput, arg2 ...request.Option) (*kms.EnableKeyOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) } - ret := _m.ctrl.Call(_m, "EnableKeyWithContext", _s...) + 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 { - _s := append([]interface{}{arg0, arg1}, arg2...) - return _mr.mock.ctrl.RecordCall(_mr.mock, "EnableKeyWithContext", reflect.TypeOf((*MockKMSAPI)(nil).EnableKeyWithContext), _s...) +func (mr *MockKMSAPIMockRecorder) EnableKeyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableKeyWithContext", reflect.TypeOf((*MockKMSAPI)(nil).EnableKeyWithContext), varargs...) } // EnableKeyRequest mocks base method -func (_m *MockKMSAPI) EnableKeyRequest(_param0 *kms.EnableKeyInput) (*request.Request, *kms.EnableKeyOutput) { - ret := _m.ctrl.Call(_m, "EnableKeyRequest", _param0) +func (m *MockKMSAPI) EnableKeyRequest(arg0 *kms.EnableKeyInput) (*request.Request, *kms.EnableKeyOutput) { + 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 { - return _mr.mock.ctrl.RecordCall(_mr.mock, "EnableKeyRequest", reflect.TypeOf((*MockKMSAPI)(nil).EnableKeyRequest), arg0) +func (mr *MockKMSAPIMockRecorder) EnableKeyRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableKeyRequest", reflect.TypeOf((*MockKMSAPI)(nil).EnableKeyRequest), arg0) } // EnableKeyRotation mocks base method -func (_m *MockKMSAPI) EnableKeyRotation(_param0 *kms.EnableKeyRotationInput) (*kms.EnableKeyRotationOutput, error) { - ret := _m.ctrl.Call(_m, "EnableKeyRotation", _param0) +func (m *MockKMSAPI) EnableKeyRotation(arg0 *kms.EnableKeyRotationInput) (*kms.EnableKeyRotationOutput, error) { + 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 { - return _mr.mock.ctrl.RecordCall(_mr.mock, "EnableKeyRotation", reflect.TypeOf((*MockKMSAPI)(nil).EnableKeyRotation), arg0) +func (mr *MockKMSAPIMockRecorder) EnableKeyRotation(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableKeyRotation", reflect.TypeOf((*MockKMSAPI)(nil).EnableKeyRotation), arg0) } // EnableKeyRotationWithContext mocks base method -func (_m *MockKMSAPI) EnableKeyRotationWithContext(_param0 aws.Context, _param1 *kms.EnableKeyRotationInput, _param2 ...request.Option) (*kms.EnableKeyRotationOutput, error) { - _s := []interface{}{_param0, _param1} - for _, _x := range _param2 { - _s = append(_s, _x) +func (m *MockKMSAPI) EnableKeyRotationWithContext(arg0 aws.Context, arg1 *kms.EnableKeyRotationInput, arg2 ...request.Option) (*kms.EnableKeyRotationOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) } - ret := _m.ctrl.Call(_m, "EnableKeyRotationWithContext", _s...) + 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 { - _s := append([]interface{}{arg0, arg1}, arg2...) - return _mr.mock.ctrl.RecordCall(_mr.mock, "EnableKeyRotationWithContext", reflect.TypeOf((*MockKMSAPI)(nil).EnableKeyRotationWithContext), _s...) +func (mr *MockKMSAPIMockRecorder) EnableKeyRotationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableKeyRotationWithContext", reflect.TypeOf((*MockKMSAPI)(nil).EnableKeyRotationWithContext), varargs...) } // EnableKeyRotationRequest mocks base method -func (_m *MockKMSAPI) EnableKeyRotationRequest(_param0 *kms.EnableKeyRotationInput) (*request.Request, *kms.EnableKeyRotationOutput) { - ret := _m.ctrl.Call(_m, "EnableKeyRotationRequest", _param0) +func (m *MockKMSAPI) EnableKeyRotationRequest(arg0 *kms.EnableKeyRotationInput) (*request.Request, *kms.EnableKeyRotationOutput) { + 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 { - return _mr.mock.ctrl.RecordCall(_mr.mock, "EnableKeyRotationRequest", reflect.TypeOf((*MockKMSAPI)(nil).EnableKeyRotationRequest), arg0) +func (mr *MockKMSAPIMockRecorder) EnableKeyRotationRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableKeyRotationRequest", reflect.TypeOf((*MockKMSAPI)(nil).EnableKeyRotationRequest), arg0) } // Encrypt mocks base method -func (_m *MockKMSAPI) Encrypt(_param0 *kms.EncryptInput) (*kms.EncryptOutput, error) { - ret := _m.ctrl.Call(_m, "Encrypt", _param0) +func (m *MockKMSAPI) Encrypt(arg0 *kms.EncryptInput) (*kms.EncryptOutput, error) { + 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 { - return _mr.mock.ctrl.RecordCall(_mr.mock, "Encrypt", reflect.TypeOf((*MockKMSAPI)(nil).Encrypt), arg0) +func (mr *MockKMSAPIMockRecorder) Encrypt(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Encrypt", reflect.TypeOf((*MockKMSAPI)(nil).Encrypt), arg0) } // EncryptWithContext mocks base method -func (_m *MockKMSAPI) EncryptWithContext(_param0 aws.Context, _param1 *kms.EncryptInput, _param2 ...request.Option) (*kms.EncryptOutput, error) { - _s := []interface{}{_param0, _param1} - for _, _x := range _param2 { - _s = append(_s, _x) +func (m *MockKMSAPI) EncryptWithContext(arg0 aws.Context, arg1 *kms.EncryptInput, arg2 ...request.Option) (*kms.EncryptOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) } - ret := _m.ctrl.Call(_m, "EncryptWithContext", _s...) + 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 { - _s := append([]interface{}{arg0, arg1}, arg2...) - return _mr.mock.ctrl.RecordCall(_mr.mock, "EncryptWithContext", reflect.TypeOf((*MockKMSAPI)(nil).EncryptWithContext), _s...) +func (mr *MockKMSAPIMockRecorder) EncryptWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EncryptWithContext", reflect.TypeOf((*MockKMSAPI)(nil).EncryptWithContext), varargs...) } // EncryptRequest mocks base method -func (_m *MockKMSAPI) EncryptRequest(_param0 *kms.EncryptInput) (*request.Request, *kms.EncryptOutput) { - ret := _m.ctrl.Call(_m, "EncryptRequest", _param0) +func (m *MockKMSAPI) EncryptRequest(arg0 *kms.EncryptInput) (*request.Request, *kms.EncryptOutput) { + 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 { - return _mr.mock.ctrl.RecordCall(_mr.mock, "EncryptRequest", reflect.TypeOf((*MockKMSAPI)(nil).EncryptRequest), arg0) +func (mr *MockKMSAPIMockRecorder) EncryptRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EncryptRequest", reflect.TypeOf((*MockKMSAPI)(nil).EncryptRequest), arg0) } // GenerateDataKey mocks base method -func (_m *MockKMSAPI) GenerateDataKey(_param0 *kms.GenerateDataKeyInput) (*kms.GenerateDataKeyOutput, error) { - ret := _m.ctrl.Call(_m, "GenerateDataKey", _param0) +func (m *MockKMSAPI) GenerateDataKey(arg0 *kms.GenerateDataKeyInput) (*kms.GenerateDataKeyOutput, error) { + 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 { - return _mr.mock.ctrl.RecordCall(_mr.mock, "GenerateDataKey", reflect.TypeOf((*MockKMSAPI)(nil).GenerateDataKey), arg0) +func (mr *MockKMSAPIMockRecorder) GenerateDataKey(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GenerateDataKey", reflect.TypeOf((*MockKMSAPI)(nil).GenerateDataKey), arg0) } // GenerateDataKeyWithContext mocks base method -func (_m *MockKMSAPI) GenerateDataKeyWithContext(_param0 aws.Context, _param1 *kms.GenerateDataKeyInput, _param2 ...request.Option) (*kms.GenerateDataKeyOutput, error) { - _s := []interface{}{_param0, _param1} - for _, _x := range _param2 { - _s = append(_s, _x) +func (m *MockKMSAPI) GenerateDataKeyWithContext(arg0 aws.Context, arg1 *kms.GenerateDataKeyInput, arg2 ...request.Option) (*kms.GenerateDataKeyOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) } - ret := _m.ctrl.Call(_m, "GenerateDataKeyWithContext", _s...) + 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 { - _s := append([]interface{}{arg0, arg1}, arg2...) - return _mr.mock.ctrl.RecordCall(_mr.mock, "GenerateDataKeyWithContext", reflect.TypeOf((*MockKMSAPI)(nil).GenerateDataKeyWithContext), _s...) +func (mr *MockKMSAPIMockRecorder) GenerateDataKeyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GenerateDataKeyWithContext", reflect.TypeOf((*MockKMSAPI)(nil).GenerateDataKeyWithContext), varargs...) } // GenerateDataKeyRequest mocks base method -func (_m *MockKMSAPI) GenerateDataKeyRequest(_param0 *kms.GenerateDataKeyInput) (*request.Request, *kms.GenerateDataKeyOutput) { - ret := _m.ctrl.Call(_m, "GenerateDataKeyRequest", _param0) +func (m *MockKMSAPI) GenerateDataKeyRequest(arg0 *kms.GenerateDataKeyInput) (*request.Request, *kms.GenerateDataKeyOutput) { + 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 { - return _mr.mock.ctrl.RecordCall(_mr.mock, "GenerateDataKeyRequest", reflect.TypeOf((*MockKMSAPI)(nil).GenerateDataKeyRequest), arg0) +func (mr *MockKMSAPIMockRecorder) GenerateDataKeyRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GenerateDataKeyRequest", reflect.TypeOf((*MockKMSAPI)(nil).GenerateDataKeyRequest), arg0) } // GenerateDataKeyWithoutPlaintext mocks base method -func (_m *MockKMSAPI) GenerateDataKeyWithoutPlaintext(_param0 *kms.GenerateDataKeyWithoutPlaintextInput) (*kms.GenerateDataKeyWithoutPlaintextOutput, error) { - ret := _m.ctrl.Call(_m, "GenerateDataKeyWithoutPlaintext", _param0) +func (m *MockKMSAPI) GenerateDataKeyWithoutPlaintext(arg0 *kms.GenerateDataKeyWithoutPlaintextInput) (*kms.GenerateDataKeyWithoutPlaintextOutput, error) { + 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 { - return _mr.mock.ctrl.RecordCall(_mr.mock, "GenerateDataKeyWithoutPlaintext", reflect.TypeOf((*MockKMSAPI)(nil).GenerateDataKeyWithoutPlaintext), arg0) +func (mr *MockKMSAPIMockRecorder) GenerateDataKeyWithoutPlaintext(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GenerateDataKeyWithoutPlaintext", reflect.TypeOf((*MockKMSAPI)(nil).GenerateDataKeyWithoutPlaintext), arg0) } // GenerateDataKeyWithoutPlaintextWithContext mocks base method -func (_m *MockKMSAPI) GenerateDataKeyWithoutPlaintextWithContext(_param0 aws.Context, _param1 *kms.GenerateDataKeyWithoutPlaintextInput, _param2 ...request.Option) (*kms.GenerateDataKeyWithoutPlaintextOutput, error) { - _s := []interface{}{_param0, _param1} - for _, _x := range _param2 { - _s = append(_s, _x) +func (m *MockKMSAPI) GenerateDataKeyWithoutPlaintextWithContext(arg0 aws.Context, arg1 *kms.GenerateDataKeyWithoutPlaintextInput, arg2 ...request.Option) (*kms.GenerateDataKeyWithoutPlaintextOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) } - ret := _m.ctrl.Call(_m, "GenerateDataKeyWithoutPlaintextWithContext", _s...) + 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 { - _s := append([]interface{}{arg0, arg1}, arg2...) - return _mr.mock.ctrl.RecordCall(_mr.mock, "GenerateDataKeyWithoutPlaintextWithContext", reflect.TypeOf((*MockKMSAPI)(nil).GenerateDataKeyWithoutPlaintextWithContext), _s...) +func (mr *MockKMSAPIMockRecorder) GenerateDataKeyWithoutPlaintextWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GenerateDataKeyWithoutPlaintextWithContext", reflect.TypeOf((*MockKMSAPI)(nil).GenerateDataKeyWithoutPlaintextWithContext), varargs...) } // GenerateDataKeyWithoutPlaintextRequest mocks base method -func (_m *MockKMSAPI) GenerateDataKeyWithoutPlaintextRequest(_param0 *kms.GenerateDataKeyWithoutPlaintextInput) (*request.Request, *kms.GenerateDataKeyWithoutPlaintextOutput) { - ret := _m.ctrl.Call(_m, "GenerateDataKeyWithoutPlaintextRequest", _param0) +func (m *MockKMSAPI) GenerateDataKeyWithoutPlaintextRequest(arg0 *kms.GenerateDataKeyWithoutPlaintextInput) (*request.Request, *kms.GenerateDataKeyWithoutPlaintextOutput) { + 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 { - return _mr.mock.ctrl.RecordCall(_mr.mock, "GenerateDataKeyWithoutPlaintextRequest", reflect.TypeOf((*MockKMSAPI)(nil).GenerateDataKeyWithoutPlaintextRequest), arg0) +func (mr *MockKMSAPIMockRecorder) GenerateDataKeyWithoutPlaintextRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GenerateDataKeyWithoutPlaintextRequest", reflect.TypeOf((*MockKMSAPI)(nil).GenerateDataKeyWithoutPlaintextRequest), arg0) } // GenerateRandom mocks base method -func (_m *MockKMSAPI) GenerateRandom(_param0 *kms.GenerateRandomInput) (*kms.GenerateRandomOutput, error) { - ret := _m.ctrl.Call(_m, "GenerateRandom", _param0) +func (m *MockKMSAPI) GenerateRandom(arg0 *kms.GenerateRandomInput) (*kms.GenerateRandomOutput, error) { + 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 { - return _mr.mock.ctrl.RecordCall(_mr.mock, "GenerateRandom", reflect.TypeOf((*MockKMSAPI)(nil).GenerateRandom), arg0) +func (mr *MockKMSAPIMockRecorder) GenerateRandom(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GenerateRandom", reflect.TypeOf((*MockKMSAPI)(nil).GenerateRandom), arg0) } // GenerateRandomWithContext mocks base method -func (_m *MockKMSAPI) GenerateRandomWithContext(_param0 aws.Context, _param1 *kms.GenerateRandomInput, _param2 ...request.Option) (*kms.GenerateRandomOutput, error) { - _s := []interface{}{_param0, _param1} - for _, _x := range _param2 { - _s = append(_s, _x) +func (m *MockKMSAPI) GenerateRandomWithContext(arg0 aws.Context, arg1 *kms.GenerateRandomInput, arg2 ...request.Option) (*kms.GenerateRandomOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) } - ret := _m.ctrl.Call(_m, "GenerateRandomWithContext", _s...) + 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 { - _s := append([]interface{}{arg0, arg1}, arg2...) - return _mr.mock.ctrl.RecordCall(_mr.mock, "GenerateRandomWithContext", reflect.TypeOf((*MockKMSAPI)(nil).GenerateRandomWithContext), _s...) +func (mr *MockKMSAPIMockRecorder) GenerateRandomWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GenerateRandomWithContext", reflect.TypeOf((*MockKMSAPI)(nil).GenerateRandomWithContext), varargs...) } // GenerateRandomRequest mocks base method -func (_m *MockKMSAPI) GenerateRandomRequest(_param0 *kms.GenerateRandomInput) (*request.Request, *kms.GenerateRandomOutput) { - ret := _m.ctrl.Call(_m, "GenerateRandomRequest", _param0) +func (m *MockKMSAPI) GenerateRandomRequest(arg0 *kms.GenerateRandomInput) (*request.Request, *kms.GenerateRandomOutput) { + 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 { - return _mr.mock.ctrl.RecordCall(_mr.mock, "GenerateRandomRequest", reflect.TypeOf((*MockKMSAPI)(nil).GenerateRandomRequest), arg0) +func (mr *MockKMSAPIMockRecorder) GenerateRandomRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GenerateRandomRequest", reflect.TypeOf((*MockKMSAPI)(nil).GenerateRandomRequest), arg0) } // GetKeyPolicy mocks base method -func (_m *MockKMSAPI) GetKeyPolicy(_param0 *kms.GetKeyPolicyInput) (*kms.GetKeyPolicyOutput, error) { - ret := _m.ctrl.Call(_m, "GetKeyPolicy", _param0) +func (m *MockKMSAPI) GetKeyPolicy(arg0 *kms.GetKeyPolicyInput) (*kms.GetKeyPolicyOutput, error) { + 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 { - return _mr.mock.ctrl.RecordCall(_mr.mock, "GetKeyPolicy", reflect.TypeOf((*MockKMSAPI)(nil).GetKeyPolicy), arg0) +func (mr *MockKMSAPIMockRecorder) GetKeyPolicy(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetKeyPolicy", reflect.TypeOf((*MockKMSAPI)(nil).GetKeyPolicy), arg0) } // GetKeyPolicyWithContext mocks base method -func (_m *MockKMSAPI) GetKeyPolicyWithContext(_param0 aws.Context, _param1 *kms.GetKeyPolicyInput, _param2 ...request.Option) (*kms.GetKeyPolicyOutput, error) { - _s := []interface{}{_param0, _param1} - for _, _x := range _param2 { - _s = append(_s, _x) +func (m *MockKMSAPI) GetKeyPolicyWithContext(arg0 aws.Context, arg1 *kms.GetKeyPolicyInput, arg2 ...request.Option) (*kms.GetKeyPolicyOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) } - ret := _m.ctrl.Call(_m, "GetKeyPolicyWithContext", _s...) + 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 { - _s := append([]interface{}{arg0, arg1}, arg2...) - return _mr.mock.ctrl.RecordCall(_mr.mock, "GetKeyPolicyWithContext", reflect.TypeOf((*MockKMSAPI)(nil).GetKeyPolicyWithContext), _s...) +func (mr *MockKMSAPIMockRecorder) GetKeyPolicyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetKeyPolicyWithContext", reflect.TypeOf((*MockKMSAPI)(nil).GetKeyPolicyWithContext), varargs...) } // GetKeyPolicyRequest mocks base method -func (_m *MockKMSAPI) GetKeyPolicyRequest(_param0 *kms.GetKeyPolicyInput) (*request.Request, *kms.GetKeyPolicyOutput) { - ret := _m.ctrl.Call(_m, "GetKeyPolicyRequest", _param0) +func (m *MockKMSAPI) GetKeyPolicyRequest(arg0 *kms.GetKeyPolicyInput) (*request.Request, *kms.GetKeyPolicyOutput) { + 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 { - return _mr.mock.ctrl.RecordCall(_mr.mock, "GetKeyPolicyRequest", reflect.TypeOf((*MockKMSAPI)(nil).GetKeyPolicyRequest), arg0) +func (mr *MockKMSAPIMockRecorder) GetKeyPolicyRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetKeyPolicyRequest", reflect.TypeOf((*MockKMSAPI)(nil).GetKeyPolicyRequest), arg0) } // GetKeyRotationStatus mocks base method -func (_m *MockKMSAPI) GetKeyRotationStatus(_param0 *kms.GetKeyRotationStatusInput) (*kms.GetKeyRotationStatusOutput, error) { - ret := _m.ctrl.Call(_m, "GetKeyRotationStatus", _param0) +func (m *MockKMSAPI) GetKeyRotationStatus(arg0 *kms.GetKeyRotationStatusInput) (*kms.GetKeyRotationStatusOutput, error) { + 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 { - return _mr.mock.ctrl.RecordCall(_mr.mock, "GetKeyRotationStatus", reflect.TypeOf((*MockKMSAPI)(nil).GetKeyRotationStatus), arg0) +func (mr *MockKMSAPIMockRecorder) GetKeyRotationStatus(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetKeyRotationStatus", reflect.TypeOf((*MockKMSAPI)(nil).GetKeyRotationStatus), arg0) } // GetKeyRotationStatusWithContext mocks base method -func (_m *MockKMSAPI) GetKeyRotationStatusWithContext(_param0 aws.Context, _param1 *kms.GetKeyRotationStatusInput, _param2 ...request.Option) (*kms.GetKeyRotationStatusOutput, error) { - _s := []interface{}{_param0, _param1} - for _, _x := range _param2 { - _s = append(_s, _x) +func (m *MockKMSAPI) GetKeyRotationStatusWithContext(arg0 aws.Context, arg1 *kms.GetKeyRotationStatusInput, arg2 ...request.Option) (*kms.GetKeyRotationStatusOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) } - ret := _m.ctrl.Call(_m, "GetKeyRotationStatusWithContext", _s...) + 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 { - _s := append([]interface{}{arg0, arg1}, arg2...) - return _mr.mock.ctrl.RecordCall(_mr.mock, "GetKeyRotationStatusWithContext", reflect.TypeOf((*MockKMSAPI)(nil).GetKeyRotationStatusWithContext), _s...) +func (mr *MockKMSAPIMockRecorder) GetKeyRotationStatusWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetKeyRotationStatusWithContext", reflect.TypeOf((*MockKMSAPI)(nil).GetKeyRotationStatusWithContext), varargs...) } // GetKeyRotationStatusRequest mocks base method -func (_m *MockKMSAPI) GetKeyRotationStatusRequest(_param0 *kms.GetKeyRotationStatusInput) (*request.Request, *kms.GetKeyRotationStatusOutput) { - ret := _m.ctrl.Call(_m, "GetKeyRotationStatusRequest", _param0) +func (m *MockKMSAPI) GetKeyRotationStatusRequest(arg0 *kms.GetKeyRotationStatusInput) (*request.Request, *kms.GetKeyRotationStatusOutput) { + 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 { - return _mr.mock.ctrl.RecordCall(_mr.mock, "GetKeyRotationStatusRequest", reflect.TypeOf((*MockKMSAPI)(nil).GetKeyRotationStatusRequest), arg0) +func (mr *MockKMSAPIMockRecorder) GetKeyRotationStatusRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetKeyRotationStatusRequest", reflect.TypeOf((*MockKMSAPI)(nil).GetKeyRotationStatusRequest), arg0) } // GetParametersForImport mocks base method -func (_m *MockKMSAPI) GetParametersForImport(_param0 *kms.GetParametersForImportInput) (*kms.GetParametersForImportOutput, error) { - ret := _m.ctrl.Call(_m, "GetParametersForImport", _param0) +func (m *MockKMSAPI) GetParametersForImport(arg0 *kms.GetParametersForImportInput) (*kms.GetParametersForImportOutput, error) { + 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 { - return _mr.mock.ctrl.RecordCall(_mr.mock, "GetParametersForImport", reflect.TypeOf((*MockKMSAPI)(nil).GetParametersForImport), arg0) +func (mr *MockKMSAPIMockRecorder) GetParametersForImport(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetParametersForImport", reflect.TypeOf((*MockKMSAPI)(nil).GetParametersForImport), arg0) } // GetParametersForImportWithContext mocks base method -func (_m *MockKMSAPI) GetParametersForImportWithContext(_param0 aws.Context, _param1 *kms.GetParametersForImportInput, _param2 ...request.Option) (*kms.GetParametersForImportOutput, error) { - _s := []interface{}{_param0, _param1} - for _, _x := range _param2 { - _s = append(_s, _x) +func (m *MockKMSAPI) GetParametersForImportWithContext(arg0 aws.Context, arg1 *kms.GetParametersForImportInput, arg2 ...request.Option) (*kms.GetParametersForImportOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) } - ret := _m.ctrl.Call(_m, "GetParametersForImportWithContext", _s...) + 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 { - _s := append([]interface{}{arg0, arg1}, arg2...) - return _mr.mock.ctrl.RecordCall(_mr.mock, "GetParametersForImportWithContext", reflect.TypeOf((*MockKMSAPI)(nil).GetParametersForImportWithContext), _s...) +func (mr *MockKMSAPIMockRecorder) GetParametersForImportWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetParametersForImportWithContext", reflect.TypeOf((*MockKMSAPI)(nil).GetParametersForImportWithContext), varargs...) } // GetParametersForImportRequest mocks base method -func (_m *MockKMSAPI) GetParametersForImportRequest(_param0 *kms.GetParametersForImportInput) (*request.Request, *kms.GetParametersForImportOutput) { - ret := _m.ctrl.Call(_m, "GetParametersForImportRequest", _param0) +func (m *MockKMSAPI) GetParametersForImportRequest(arg0 *kms.GetParametersForImportInput) (*request.Request, *kms.GetParametersForImportOutput) { + 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 { - return _mr.mock.ctrl.RecordCall(_mr.mock, "GetParametersForImportRequest", reflect.TypeOf((*MockKMSAPI)(nil).GetParametersForImportRequest), arg0) +func (mr *MockKMSAPIMockRecorder) GetParametersForImportRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetParametersForImportRequest", reflect.TypeOf((*MockKMSAPI)(nil).GetParametersForImportRequest), arg0) } // ImportKeyMaterial mocks base method -func (_m *MockKMSAPI) ImportKeyMaterial(_param0 *kms.ImportKeyMaterialInput) (*kms.ImportKeyMaterialOutput, error) { - ret := _m.ctrl.Call(_m, "ImportKeyMaterial", _param0) +func (m *MockKMSAPI) ImportKeyMaterial(arg0 *kms.ImportKeyMaterialInput) (*kms.ImportKeyMaterialOutput, error) { + 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 { - return _mr.mock.ctrl.RecordCall(_mr.mock, "ImportKeyMaterial", reflect.TypeOf((*MockKMSAPI)(nil).ImportKeyMaterial), arg0) +func (mr *MockKMSAPIMockRecorder) ImportKeyMaterial(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportKeyMaterial", reflect.TypeOf((*MockKMSAPI)(nil).ImportKeyMaterial), arg0) } // ImportKeyMaterialWithContext mocks base method -func (_m *MockKMSAPI) ImportKeyMaterialWithContext(_param0 aws.Context, _param1 *kms.ImportKeyMaterialInput, _param2 ...request.Option) (*kms.ImportKeyMaterialOutput, error) { - _s := []interface{}{_param0, _param1} - for _, _x := range _param2 { - _s = append(_s, _x) +func (m *MockKMSAPI) ImportKeyMaterialWithContext(arg0 aws.Context, arg1 *kms.ImportKeyMaterialInput, arg2 ...request.Option) (*kms.ImportKeyMaterialOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) } - ret := _m.ctrl.Call(_m, "ImportKeyMaterialWithContext", _s...) + 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 { - _s := append([]interface{}{arg0, arg1}, arg2...) - return _mr.mock.ctrl.RecordCall(_mr.mock, "ImportKeyMaterialWithContext", reflect.TypeOf((*MockKMSAPI)(nil).ImportKeyMaterialWithContext), _s...) +func (mr *MockKMSAPIMockRecorder) ImportKeyMaterialWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportKeyMaterialWithContext", reflect.TypeOf((*MockKMSAPI)(nil).ImportKeyMaterialWithContext), varargs...) } // ImportKeyMaterialRequest mocks base method -func (_m *MockKMSAPI) ImportKeyMaterialRequest(_param0 *kms.ImportKeyMaterialInput) (*request.Request, *kms.ImportKeyMaterialOutput) { - ret := _m.ctrl.Call(_m, "ImportKeyMaterialRequest", _param0) +func (m *MockKMSAPI) ImportKeyMaterialRequest(arg0 *kms.ImportKeyMaterialInput) (*request.Request, *kms.ImportKeyMaterialOutput) { + 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 { - return _mr.mock.ctrl.RecordCall(_mr.mock, "ImportKeyMaterialRequest", reflect.TypeOf((*MockKMSAPI)(nil).ImportKeyMaterialRequest), arg0) +func (mr *MockKMSAPIMockRecorder) ImportKeyMaterialRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportKeyMaterialRequest", reflect.TypeOf((*MockKMSAPI)(nil).ImportKeyMaterialRequest), arg0) } // ListAliases mocks base method -func (_m *MockKMSAPI) ListAliases(_param0 *kms.ListAliasesInput) (*kms.ListAliasesOutput, error) { - ret := _m.ctrl.Call(_m, "ListAliases", _param0) +func (m *MockKMSAPI) ListAliases(arg0 *kms.ListAliasesInput) (*kms.ListAliasesOutput, error) { + 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 { - return _mr.mock.ctrl.RecordCall(_mr.mock, "ListAliases", reflect.TypeOf((*MockKMSAPI)(nil).ListAliases), arg0) +func (mr *MockKMSAPIMockRecorder) ListAliases(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAliases", reflect.TypeOf((*MockKMSAPI)(nil).ListAliases), arg0) } // ListAliasesWithContext mocks base method -func (_m *MockKMSAPI) ListAliasesWithContext(_param0 aws.Context, _param1 *kms.ListAliasesInput, _param2 ...request.Option) (*kms.ListAliasesOutput, error) { - _s := []interface{}{_param0, _param1} - for _, _x := range _param2 { - _s = append(_s, _x) +func (m *MockKMSAPI) ListAliasesWithContext(arg0 aws.Context, arg1 *kms.ListAliasesInput, arg2 ...request.Option) (*kms.ListAliasesOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) } - ret := _m.ctrl.Call(_m, "ListAliasesWithContext", _s...) + 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 { - _s := append([]interface{}{arg0, arg1}, arg2...) - return _mr.mock.ctrl.RecordCall(_mr.mock, "ListAliasesWithContext", reflect.TypeOf((*MockKMSAPI)(nil).ListAliasesWithContext), _s...) +func (mr *MockKMSAPIMockRecorder) ListAliasesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAliasesWithContext", reflect.TypeOf((*MockKMSAPI)(nil).ListAliasesWithContext), varargs...) } // ListAliasesRequest mocks base method -func (_m *MockKMSAPI) ListAliasesRequest(_param0 *kms.ListAliasesInput) (*request.Request, *kms.ListAliasesOutput) { - ret := _m.ctrl.Call(_m, "ListAliasesRequest", _param0) +func (m *MockKMSAPI) ListAliasesRequest(arg0 *kms.ListAliasesInput) (*request.Request, *kms.ListAliasesOutput) { + 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 { - return _mr.mock.ctrl.RecordCall(_mr.mock, "ListAliasesRequest", reflect.TypeOf((*MockKMSAPI)(nil).ListAliasesRequest), arg0) +func (mr *MockKMSAPIMockRecorder) ListAliasesRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAliasesRequest", reflect.TypeOf((*MockKMSAPI)(nil).ListAliasesRequest), arg0) } // ListAliasesPages mocks base method -func (_m *MockKMSAPI) ListAliasesPages(_param0 *kms.ListAliasesInput, _param1 func(*kms.ListAliasesOutput, bool) bool) error { - ret := _m.ctrl.Call(_m, "ListAliasesPages", _param0, _param1) +func (m *MockKMSAPI) ListAliasesPages(arg0 *kms.ListAliasesInput, arg1 func(*kms.ListAliasesOutput, bool) bool) error { + 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 { - return _mr.mock.ctrl.RecordCall(_mr.mock, "ListAliasesPages", reflect.TypeOf((*MockKMSAPI)(nil).ListAliasesPages), arg0, arg1) +func (mr *MockKMSAPIMockRecorder) ListAliasesPages(arg0, arg1 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAliasesPages", reflect.TypeOf((*MockKMSAPI)(nil).ListAliasesPages), arg0, arg1) } // ListAliasesPagesWithContext mocks base method -func (_m *MockKMSAPI) ListAliasesPagesWithContext(_param0 aws.Context, _param1 *kms.ListAliasesInput, _param2 func(*kms.ListAliasesOutput, bool) bool, _param3 ...request.Option) error { - _s := []interface{}{_param0, _param1, _param2} - for _, _x := range _param3 { - _s = append(_s, _x) +func (m *MockKMSAPI) ListAliasesPagesWithContext(arg0 aws.Context, arg1 *kms.ListAliasesInput, arg2 func(*kms.ListAliasesOutput, bool) bool, arg3 ...request.Option) error { + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) } - ret := _m.ctrl.Call(_m, "ListAliasesPagesWithContext", _s...) + 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 { - _s := append([]interface{}{arg0, arg1, arg2}, arg3...) - return _mr.mock.ctrl.RecordCall(_mr.mock, "ListAliasesPagesWithContext", reflect.TypeOf((*MockKMSAPI)(nil).ListAliasesPagesWithContext), _s...) +func (mr *MockKMSAPIMockRecorder) ListAliasesPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAliasesPagesWithContext", reflect.TypeOf((*MockKMSAPI)(nil).ListAliasesPagesWithContext), varargs...) } // ListGrants mocks base method -func (_m *MockKMSAPI) ListGrants(_param0 *kms.ListGrantsInput) (*kms.ListGrantsResponse, error) { - ret := _m.ctrl.Call(_m, "ListGrants", _param0) +func (m *MockKMSAPI) ListGrants(arg0 *kms.ListGrantsInput) (*kms.ListGrantsResponse, error) { + 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 { - return _mr.mock.ctrl.RecordCall(_mr.mock, "ListGrants", reflect.TypeOf((*MockKMSAPI)(nil).ListGrants), arg0) +func (mr *MockKMSAPIMockRecorder) ListGrants(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListGrants", reflect.TypeOf((*MockKMSAPI)(nil).ListGrants), arg0) } // ListGrantsWithContext mocks base method -func (_m *MockKMSAPI) ListGrantsWithContext(_param0 aws.Context, _param1 *kms.ListGrantsInput, _param2 ...request.Option) (*kms.ListGrantsResponse, error) { - _s := []interface{}{_param0, _param1} - for _, _x := range _param2 { - _s = append(_s, _x) +func (m *MockKMSAPI) ListGrantsWithContext(arg0 aws.Context, arg1 *kms.ListGrantsInput, arg2 ...request.Option) (*kms.ListGrantsResponse, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) } - ret := _m.ctrl.Call(_m, "ListGrantsWithContext", _s...) + 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 { - _s := append([]interface{}{arg0, arg1}, arg2...) - return _mr.mock.ctrl.RecordCall(_mr.mock, "ListGrantsWithContext", reflect.TypeOf((*MockKMSAPI)(nil).ListGrantsWithContext), _s...) +func (mr *MockKMSAPIMockRecorder) ListGrantsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListGrantsWithContext", reflect.TypeOf((*MockKMSAPI)(nil).ListGrantsWithContext), varargs...) } // ListGrantsRequest mocks base method -func (_m *MockKMSAPI) ListGrantsRequest(_param0 *kms.ListGrantsInput) (*request.Request, *kms.ListGrantsResponse) { - ret := _m.ctrl.Call(_m, "ListGrantsRequest", _param0) +func (m *MockKMSAPI) ListGrantsRequest(arg0 *kms.ListGrantsInput) (*request.Request, *kms.ListGrantsResponse) { + 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 { - return _mr.mock.ctrl.RecordCall(_mr.mock, "ListGrantsRequest", reflect.TypeOf((*MockKMSAPI)(nil).ListGrantsRequest), arg0) +func (mr *MockKMSAPIMockRecorder) ListGrantsRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListGrantsRequest", reflect.TypeOf((*MockKMSAPI)(nil).ListGrantsRequest), arg0) } // ListGrantsPages mocks base method -func (_m *MockKMSAPI) ListGrantsPages(_param0 *kms.ListGrantsInput, _param1 func(*kms.ListGrantsResponse, bool) bool) error { - ret := _m.ctrl.Call(_m, "ListGrantsPages", _param0, _param1) +func (m *MockKMSAPI) ListGrantsPages(arg0 *kms.ListGrantsInput, arg1 func(*kms.ListGrantsResponse, bool) bool) error { + 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 { - return _mr.mock.ctrl.RecordCall(_mr.mock, "ListGrantsPages", reflect.TypeOf((*MockKMSAPI)(nil).ListGrantsPages), arg0, arg1) +func (mr *MockKMSAPIMockRecorder) ListGrantsPages(arg0, arg1 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListGrantsPages", reflect.TypeOf((*MockKMSAPI)(nil).ListGrantsPages), arg0, arg1) } // ListGrantsPagesWithContext mocks base method -func (_m *MockKMSAPI) ListGrantsPagesWithContext(_param0 aws.Context, _param1 *kms.ListGrantsInput, _param2 func(*kms.ListGrantsResponse, bool) bool, _param3 ...request.Option) error { - _s := []interface{}{_param0, _param1, _param2} - for _, _x := range _param3 { - _s = append(_s, _x) +func (m *MockKMSAPI) ListGrantsPagesWithContext(arg0 aws.Context, arg1 *kms.ListGrantsInput, arg2 func(*kms.ListGrantsResponse, bool) bool, arg3 ...request.Option) error { + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) } - ret := _m.ctrl.Call(_m, "ListGrantsPagesWithContext", _s...) + 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 { - _s := append([]interface{}{arg0, arg1, arg2}, arg3...) - return _mr.mock.ctrl.RecordCall(_mr.mock, "ListGrantsPagesWithContext", reflect.TypeOf((*MockKMSAPI)(nil).ListGrantsPagesWithContext), _s...) +func (mr *MockKMSAPIMockRecorder) ListGrantsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListGrantsPagesWithContext", reflect.TypeOf((*MockKMSAPI)(nil).ListGrantsPagesWithContext), varargs...) } // ListKeyPolicies mocks base method -func (_m *MockKMSAPI) ListKeyPolicies(_param0 *kms.ListKeyPoliciesInput) (*kms.ListKeyPoliciesOutput, error) { - ret := _m.ctrl.Call(_m, "ListKeyPolicies", _param0) +func (m *MockKMSAPI) ListKeyPolicies(arg0 *kms.ListKeyPoliciesInput) (*kms.ListKeyPoliciesOutput, error) { + 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 { - return _mr.mock.ctrl.RecordCall(_mr.mock, "ListKeyPolicies", reflect.TypeOf((*MockKMSAPI)(nil).ListKeyPolicies), arg0) +func (mr *MockKMSAPIMockRecorder) ListKeyPolicies(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListKeyPolicies", reflect.TypeOf((*MockKMSAPI)(nil).ListKeyPolicies), arg0) } // ListKeyPoliciesWithContext mocks base method -func (_m *MockKMSAPI) ListKeyPoliciesWithContext(_param0 aws.Context, _param1 *kms.ListKeyPoliciesInput, _param2 ...request.Option) (*kms.ListKeyPoliciesOutput, error) { - _s := []interface{}{_param0, _param1} - for _, _x := range _param2 { - _s = append(_s, _x) +func (m *MockKMSAPI) ListKeyPoliciesWithContext(arg0 aws.Context, arg1 *kms.ListKeyPoliciesInput, arg2 ...request.Option) (*kms.ListKeyPoliciesOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) } - ret := _m.ctrl.Call(_m, "ListKeyPoliciesWithContext", _s...) + 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 { - _s := append([]interface{}{arg0, arg1}, arg2...) - return _mr.mock.ctrl.RecordCall(_mr.mock, "ListKeyPoliciesWithContext", reflect.TypeOf((*MockKMSAPI)(nil).ListKeyPoliciesWithContext), _s...) +func (mr *MockKMSAPIMockRecorder) ListKeyPoliciesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListKeyPoliciesWithContext", reflect.TypeOf((*MockKMSAPI)(nil).ListKeyPoliciesWithContext), varargs...) } // ListKeyPoliciesRequest mocks base method -func (_m *MockKMSAPI) ListKeyPoliciesRequest(_param0 *kms.ListKeyPoliciesInput) (*request.Request, *kms.ListKeyPoliciesOutput) { - ret := _m.ctrl.Call(_m, "ListKeyPoliciesRequest", _param0) +func (m *MockKMSAPI) ListKeyPoliciesRequest(arg0 *kms.ListKeyPoliciesInput) (*request.Request, *kms.ListKeyPoliciesOutput) { + 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 { - return _mr.mock.ctrl.RecordCall(_mr.mock, "ListKeyPoliciesRequest", reflect.TypeOf((*MockKMSAPI)(nil).ListKeyPoliciesRequest), arg0) +func (mr *MockKMSAPIMockRecorder) ListKeyPoliciesRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListKeyPoliciesRequest", reflect.TypeOf((*MockKMSAPI)(nil).ListKeyPoliciesRequest), arg0) } // ListKeyPoliciesPages mocks base method -func (_m *MockKMSAPI) ListKeyPoliciesPages(_param0 *kms.ListKeyPoliciesInput, _param1 func(*kms.ListKeyPoliciesOutput, bool) bool) error { - ret := _m.ctrl.Call(_m, "ListKeyPoliciesPages", _param0, _param1) +func (m *MockKMSAPI) ListKeyPoliciesPages(arg0 *kms.ListKeyPoliciesInput, arg1 func(*kms.ListKeyPoliciesOutput, bool) bool) error { + 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 { - return _mr.mock.ctrl.RecordCall(_mr.mock, "ListKeyPoliciesPages", reflect.TypeOf((*MockKMSAPI)(nil).ListKeyPoliciesPages), arg0, arg1) +func (mr *MockKMSAPIMockRecorder) ListKeyPoliciesPages(arg0, arg1 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListKeyPoliciesPages", reflect.TypeOf((*MockKMSAPI)(nil).ListKeyPoliciesPages), arg0, arg1) } // ListKeyPoliciesPagesWithContext mocks base method -func (_m *MockKMSAPI) ListKeyPoliciesPagesWithContext(_param0 aws.Context, _param1 *kms.ListKeyPoliciesInput, _param2 func(*kms.ListKeyPoliciesOutput, bool) bool, _param3 ...request.Option) error { - _s := []interface{}{_param0, _param1, _param2} - for _, _x := range _param3 { - _s = append(_s, _x) +func (m *MockKMSAPI) ListKeyPoliciesPagesWithContext(arg0 aws.Context, arg1 *kms.ListKeyPoliciesInput, arg2 func(*kms.ListKeyPoliciesOutput, bool) bool, arg3 ...request.Option) error { + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) } - ret := _m.ctrl.Call(_m, "ListKeyPoliciesPagesWithContext", _s...) + 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 { - _s := append([]interface{}{arg0, arg1, arg2}, arg3...) - return _mr.mock.ctrl.RecordCall(_mr.mock, "ListKeyPoliciesPagesWithContext", reflect.TypeOf((*MockKMSAPI)(nil).ListKeyPoliciesPagesWithContext), _s...) +func (mr *MockKMSAPIMockRecorder) ListKeyPoliciesPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListKeyPoliciesPagesWithContext", reflect.TypeOf((*MockKMSAPI)(nil).ListKeyPoliciesPagesWithContext), varargs...) } // ListKeys mocks base method -func (_m *MockKMSAPI) ListKeys(_param0 *kms.ListKeysInput) (*kms.ListKeysOutput, error) { - ret := _m.ctrl.Call(_m, "ListKeys", _param0) +func (m *MockKMSAPI) ListKeys(arg0 *kms.ListKeysInput) (*kms.ListKeysOutput, error) { + 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 { - return _mr.mock.ctrl.RecordCall(_mr.mock, "ListKeys", reflect.TypeOf((*MockKMSAPI)(nil).ListKeys), arg0) +func (mr *MockKMSAPIMockRecorder) ListKeys(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListKeys", reflect.TypeOf((*MockKMSAPI)(nil).ListKeys), arg0) } // ListKeysWithContext mocks base method -func (_m *MockKMSAPI) ListKeysWithContext(_param0 aws.Context, _param1 *kms.ListKeysInput, _param2 ...request.Option) (*kms.ListKeysOutput, error) { - _s := []interface{}{_param0, _param1} - for _, _x := range _param2 { - _s = append(_s, _x) +func (m *MockKMSAPI) ListKeysWithContext(arg0 aws.Context, arg1 *kms.ListKeysInput, arg2 ...request.Option) (*kms.ListKeysOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) } - ret := _m.ctrl.Call(_m, "ListKeysWithContext", _s...) + 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 { - _s := append([]interface{}{arg0, arg1}, arg2...) - return _mr.mock.ctrl.RecordCall(_mr.mock, "ListKeysWithContext", reflect.TypeOf((*MockKMSAPI)(nil).ListKeysWithContext), _s...) +func (mr *MockKMSAPIMockRecorder) ListKeysWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListKeysWithContext", reflect.TypeOf((*MockKMSAPI)(nil).ListKeysWithContext), varargs...) } // ListKeysRequest mocks base method -func (_m *MockKMSAPI) ListKeysRequest(_param0 *kms.ListKeysInput) (*request.Request, *kms.ListKeysOutput) { - ret := _m.ctrl.Call(_m, "ListKeysRequest", _param0) +func (m *MockKMSAPI) ListKeysRequest(arg0 *kms.ListKeysInput) (*request.Request, *kms.ListKeysOutput) { + 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 { - return _mr.mock.ctrl.RecordCall(_mr.mock, "ListKeysRequest", reflect.TypeOf((*MockKMSAPI)(nil).ListKeysRequest), arg0) +func (mr *MockKMSAPIMockRecorder) ListKeysRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListKeysRequest", reflect.TypeOf((*MockKMSAPI)(nil).ListKeysRequest), arg0) } // ListKeysPages mocks base method -func (_m *MockKMSAPI) ListKeysPages(_param0 *kms.ListKeysInput, _param1 func(*kms.ListKeysOutput, bool) bool) error { - ret := _m.ctrl.Call(_m, "ListKeysPages", _param0, _param1) +func (m *MockKMSAPI) ListKeysPages(arg0 *kms.ListKeysInput, arg1 func(*kms.ListKeysOutput, bool) bool) error { + 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 { - return _mr.mock.ctrl.RecordCall(_mr.mock, "ListKeysPages", reflect.TypeOf((*MockKMSAPI)(nil).ListKeysPages), arg0, arg1) +func (mr *MockKMSAPIMockRecorder) ListKeysPages(arg0, arg1 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListKeysPages", reflect.TypeOf((*MockKMSAPI)(nil).ListKeysPages), arg0, arg1) } // ListKeysPagesWithContext mocks base method -func (_m *MockKMSAPI) ListKeysPagesWithContext(_param0 aws.Context, _param1 *kms.ListKeysInput, _param2 func(*kms.ListKeysOutput, bool) bool, _param3 ...request.Option) error { - _s := []interface{}{_param0, _param1, _param2} - for _, _x := range _param3 { - _s = append(_s, _x) +func (m *MockKMSAPI) ListKeysPagesWithContext(arg0 aws.Context, arg1 *kms.ListKeysInput, arg2 func(*kms.ListKeysOutput, bool) bool, arg3 ...request.Option) error { + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) } - ret := _m.ctrl.Call(_m, "ListKeysPagesWithContext", _s...) + 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 { - _s := append([]interface{}{arg0, arg1, arg2}, arg3...) - return _mr.mock.ctrl.RecordCall(_mr.mock, "ListKeysPagesWithContext", reflect.TypeOf((*MockKMSAPI)(nil).ListKeysPagesWithContext), _s...) +func (mr *MockKMSAPIMockRecorder) ListKeysPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListKeysPagesWithContext", reflect.TypeOf((*MockKMSAPI)(nil).ListKeysPagesWithContext), varargs...) } // ListResourceTags mocks base method -func (_m *MockKMSAPI) ListResourceTags(_param0 *kms.ListResourceTagsInput) (*kms.ListResourceTagsOutput, error) { - ret := _m.ctrl.Call(_m, "ListResourceTags", _param0) +func (m *MockKMSAPI) ListResourceTags(arg0 *kms.ListResourceTagsInput) (*kms.ListResourceTagsOutput, error) { + 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 { - return _mr.mock.ctrl.RecordCall(_mr.mock, "ListResourceTags", reflect.TypeOf((*MockKMSAPI)(nil).ListResourceTags), arg0) +func (mr *MockKMSAPIMockRecorder) ListResourceTags(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListResourceTags", reflect.TypeOf((*MockKMSAPI)(nil).ListResourceTags), arg0) } // ListResourceTagsWithContext mocks base method -func (_m *MockKMSAPI) ListResourceTagsWithContext(_param0 aws.Context, _param1 *kms.ListResourceTagsInput, _param2 ...request.Option) (*kms.ListResourceTagsOutput, error) { - _s := []interface{}{_param0, _param1} - for _, _x := range _param2 { - _s = append(_s, _x) +func (m *MockKMSAPI) ListResourceTagsWithContext(arg0 aws.Context, arg1 *kms.ListResourceTagsInput, arg2 ...request.Option) (*kms.ListResourceTagsOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) } - ret := _m.ctrl.Call(_m, "ListResourceTagsWithContext", _s...) + 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 { - _s := append([]interface{}{arg0, arg1}, arg2...) - return _mr.mock.ctrl.RecordCall(_mr.mock, "ListResourceTagsWithContext", reflect.TypeOf((*MockKMSAPI)(nil).ListResourceTagsWithContext), _s...) +func (mr *MockKMSAPIMockRecorder) ListResourceTagsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListResourceTagsWithContext", reflect.TypeOf((*MockKMSAPI)(nil).ListResourceTagsWithContext), varargs...) } // ListResourceTagsRequest mocks base method -func (_m *MockKMSAPI) ListResourceTagsRequest(_param0 *kms.ListResourceTagsInput) (*request.Request, *kms.ListResourceTagsOutput) { - ret := _m.ctrl.Call(_m, "ListResourceTagsRequest", _param0) +func (m *MockKMSAPI) ListResourceTagsRequest(arg0 *kms.ListResourceTagsInput) (*request.Request, *kms.ListResourceTagsOutput) { + 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 { - return _mr.mock.ctrl.RecordCall(_mr.mock, "ListResourceTagsRequest", reflect.TypeOf((*MockKMSAPI)(nil).ListResourceTagsRequest), arg0) +func (mr *MockKMSAPIMockRecorder) ListResourceTagsRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListResourceTagsRequest", reflect.TypeOf((*MockKMSAPI)(nil).ListResourceTagsRequest), arg0) } // ListRetirableGrants mocks base method -func (_m *MockKMSAPI) ListRetirableGrants(_param0 *kms.ListRetirableGrantsInput) (*kms.ListGrantsResponse, error) { - ret := _m.ctrl.Call(_m, "ListRetirableGrants", _param0) +func (m *MockKMSAPI) ListRetirableGrants(arg0 *kms.ListRetirableGrantsInput) (*kms.ListGrantsResponse, error) { + 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 { - return _mr.mock.ctrl.RecordCall(_mr.mock, "ListRetirableGrants", reflect.TypeOf((*MockKMSAPI)(nil).ListRetirableGrants), arg0) +func (mr *MockKMSAPIMockRecorder) ListRetirableGrants(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListRetirableGrants", reflect.TypeOf((*MockKMSAPI)(nil).ListRetirableGrants), arg0) } // ListRetirableGrantsWithContext mocks base method -func (_m *MockKMSAPI) ListRetirableGrantsWithContext(_param0 aws.Context, _param1 *kms.ListRetirableGrantsInput, _param2 ...request.Option) (*kms.ListGrantsResponse, error) { - _s := []interface{}{_param0, _param1} - for _, _x := range _param2 { - _s = append(_s, _x) +func (m *MockKMSAPI) ListRetirableGrantsWithContext(arg0 aws.Context, arg1 *kms.ListRetirableGrantsInput, arg2 ...request.Option) (*kms.ListGrantsResponse, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) } - ret := _m.ctrl.Call(_m, "ListRetirableGrantsWithContext", _s...) + 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 { - _s := append([]interface{}{arg0, arg1}, arg2...) - return _mr.mock.ctrl.RecordCall(_mr.mock, "ListRetirableGrantsWithContext", reflect.TypeOf((*MockKMSAPI)(nil).ListRetirableGrantsWithContext), _s...) +func (mr *MockKMSAPIMockRecorder) ListRetirableGrantsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListRetirableGrantsWithContext", reflect.TypeOf((*MockKMSAPI)(nil).ListRetirableGrantsWithContext), varargs...) } // ListRetirableGrantsRequest mocks base method -func (_m *MockKMSAPI) ListRetirableGrantsRequest(_param0 *kms.ListRetirableGrantsInput) (*request.Request, *kms.ListGrantsResponse) { - ret := _m.ctrl.Call(_m, "ListRetirableGrantsRequest", _param0) +func (m *MockKMSAPI) ListRetirableGrantsRequest(arg0 *kms.ListRetirableGrantsInput) (*request.Request, *kms.ListGrantsResponse) { + 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 { - return _mr.mock.ctrl.RecordCall(_mr.mock, "ListRetirableGrantsRequest", reflect.TypeOf((*MockKMSAPI)(nil).ListRetirableGrantsRequest), arg0) +func (mr *MockKMSAPIMockRecorder) ListRetirableGrantsRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListRetirableGrantsRequest", reflect.TypeOf((*MockKMSAPI)(nil).ListRetirableGrantsRequest), arg0) } // PutKeyPolicy mocks base method -func (_m *MockKMSAPI) PutKeyPolicy(_param0 *kms.PutKeyPolicyInput) (*kms.PutKeyPolicyOutput, error) { - ret := _m.ctrl.Call(_m, "PutKeyPolicy", _param0) +func (m *MockKMSAPI) PutKeyPolicy(arg0 *kms.PutKeyPolicyInput) (*kms.PutKeyPolicyOutput, error) { + 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 { - return _mr.mock.ctrl.RecordCall(_mr.mock, "PutKeyPolicy", reflect.TypeOf((*MockKMSAPI)(nil).PutKeyPolicy), arg0) +func (mr *MockKMSAPIMockRecorder) PutKeyPolicy(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutKeyPolicy", reflect.TypeOf((*MockKMSAPI)(nil).PutKeyPolicy), arg0) } // PutKeyPolicyWithContext mocks base method -func (_m *MockKMSAPI) PutKeyPolicyWithContext(_param0 aws.Context, _param1 *kms.PutKeyPolicyInput, _param2 ...request.Option) (*kms.PutKeyPolicyOutput, error) { - _s := []interface{}{_param0, _param1} - for _, _x := range _param2 { - _s = append(_s, _x) +func (m *MockKMSAPI) PutKeyPolicyWithContext(arg0 aws.Context, arg1 *kms.PutKeyPolicyInput, arg2 ...request.Option) (*kms.PutKeyPolicyOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) } - ret := _m.ctrl.Call(_m, "PutKeyPolicyWithContext", _s...) + 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 { - _s := append([]interface{}{arg0, arg1}, arg2...) - return _mr.mock.ctrl.RecordCall(_mr.mock, "PutKeyPolicyWithContext", reflect.TypeOf((*MockKMSAPI)(nil).PutKeyPolicyWithContext), _s...) +func (mr *MockKMSAPIMockRecorder) PutKeyPolicyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutKeyPolicyWithContext", reflect.TypeOf((*MockKMSAPI)(nil).PutKeyPolicyWithContext), varargs...) } // PutKeyPolicyRequest mocks base method -func (_m *MockKMSAPI) PutKeyPolicyRequest(_param0 *kms.PutKeyPolicyInput) (*request.Request, *kms.PutKeyPolicyOutput) { - ret := _m.ctrl.Call(_m, "PutKeyPolicyRequest", _param0) +func (m *MockKMSAPI) PutKeyPolicyRequest(arg0 *kms.PutKeyPolicyInput) (*request.Request, *kms.PutKeyPolicyOutput) { + 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 { - return _mr.mock.ctrl.RecordCall(_mr.mock, "PutKeyPolicyRequest", reflect.TypeOf((*MockKMSAPI)(nil).PutKeyPolicyRequest), arg0) +func (mr *MockKMSAPIMockRecorder) PutKeyPolicyRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutKeyPolicyRequest", reflect.TypeOf((*MockKMSAPI)(nil).PutKeyPolicyRequest), arg0) } // ReEncrypt mocks base method -func (_m *MockKMSAPI) ReEncrypt(_param0 *kms.ReEncryptInput) (*kms.ReEncryptOutput, error) { - ret := _m.ctrl.Call(_m, "ReEncrypt", _param0) +func (m *MockKMSAPI) ReEncrypt(arg0 *kms.ReEncryptInput) (*kms.ReEncryptOutput, error) { + 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 { - return _mr.mock.ctrl.RecordCall(_mr.mock, "ReEncrypt", reflect.TypeOf((*MockKMSAPI)(nil).ReEncrypt), arg0) +func (mr *MockKMSAPIMockRecorder) ReEncrypt(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReEncrypt", reflect.TypeOf((*MockKMSAPI)(nil).ReEncrypt), arg0) } // ReEncryptWithContext mocks base method -func (_m *MockKMSAPI) ReEncryptWithContext(_param0 aws.Context, _param1 *kms.ReEncryptInput, _param2 ...request.Option) (*kms.ReEncryptOutput, error) { - _s := []interface{}{_param0, _param1} - for _, _x := range _param2 { - _s = append(_s, _x) +func (m *MockKMSAPI) ReEncryptWithContext(arg0 aws.Context, arg1 *kms.ReEncryptInput, arg2 ...request.Option) (*kms.ReEncryptOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) } - ret := _m.ctrl.Call(_m, "ReEncryptWithContext", _s...) + 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 { - _s := append([]interface{}{arg0, arg1}, arg2...) - return _mr.mock.ctrl.RecordCall(_mr.mock, "ReEncryptWithContext", reflect.TypeOf((*MockKMSAPI)(nil).ReEncryptWithContext), _s...) +func (mr *MockKMSAPIMockRecorder) ReEncryptWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReEncryptWithContext", reflect.TypeOf((*MockKMSAPI)(nil).ReEncryptWithContext), varargs...) } // ReEncryptRequest mocks base method -func (_m *MockKMSAPI) ReEncryptRequest(_param0 *kms.ReEncryptInput) (*request.Request, *kms.ReEncryptOutput) { - ret := _m.ctrl.Call(_m, "ReEncryptRequest", _param0) +func (m *MockKMSAPI) ReEncryptRequest(arg0 *kms.ReEncryptInput) (*request.Request, *kms.ReEncryptOutput) { + 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 { - return _mr.mock.ctrl.RecordCall(_mr.mock, "ReEncryptRequest", reflect.TypeOf((*MockKMSAPI)(nil).ReEncryptRequest), arg0) +func (mr *MockKMSAPIMockRecorder) ReEncryptRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReEncryptRequest", reflect.TypeOf((*MockKMSAPI)(nil).ReEncryptRequest), arg0) } // RetireGrant mocks base method -func (_m *MockKMSAPI) RetireGrant(_param0 *kms.RetireGrantInput) (*kms.RetireGrantOutput, error) { - ret := _m.ctrl.Call(_m, "RetireGrant", _param0) +func (m *MockKMSAPI) RetireGrant(arg0 *kms.RetireGrantInput) (*kms.RetireGrantOutput, error) { + 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 { - return _mr.mock.ctrl.RecordCall(_mr.mock, "RetireGrant", reflect.TypeOf((*MockKMSAPI)(nil).RetireGrant), arg0) +func (mr *MockKMSAPIMockRecorder) RetireGrant(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RetireGrant", reflect.TypeOf((*MockKMSAPI)(nil).RetireGrant), arg0) } // RetireGrantWithContext mocks base method -func (_m *MockKMSAPI) RetireGrantWithContext(_param0 aws.Context, _param1 *kms.RetireGrantInput, _param2 ...request.Option) (*kms.RetireGrantOutput, error) { - _s := []interface{}{_param0, _param1} - for _, _x := range _param2 { - _s = append(_s, _x) +func (m *MockKMSAPI) RetireGrantWithContext(arg0 aws.Context, arg1 *kms.RetireGrantInput, arg2 ...request.Option) (*kms.RetireGrantOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) } - ret := _m.ctrl.Call(_m, "RetireGrantWithContext", _s...) + 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 { - _s := append([]interface{}{arg0, arg1}, arg2...) - return _mr.mock.ctrl.RecordCall(_mr.mock, "RetireGrantWithContext", reflect.TypeOf((*MockKMSAPI)(nil).RetireGrantWithContext), _s...) +func (mr *MockKMSAPIMockRecorder) RetireGrantWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RetireGrantWithContext", reflect.TypeOf((*MockKMSAPI)(nil).RetireGrantWithContext), varargs...) } // RetireGrantRequest mocks base method -func (_m *MockKMSAPI) RetireGrantRequest(_param0 *kms.RetireGrantInput) (*request.Request, *kms.RetireGrantOutput) { - ret := _m.ctrl.Call(_m, "RetireGrantRequest", _param0) +func (m *MockKMSAPI) RetireGrantRequest(arg0 *kms.RetireGrantInput) (*request.Request, *kms.RetireGrantOutput) { + 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 { - return _mr.mock.ctrl.RecordCall(_mr.mock, "RetireGrantRequest", reflect.TypeOf((*MockKMSAPI)(nil).RetireGrantRequest), arg0) +func (mr *MockKMSAPIMockRecorder) RetireGrantRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RetireGrantRequest", reflect.TypeOf((*MockKMSAPI)(nil).RetireGrantRequest), arg0) } // RevokeGrant mocks base method -func (_m *MockKMSAPI) RevokeGrant(_param0 *kms.RevokeGrantInput) (*kms.RevokeGrantOutput, error) { - ret := _m.ctrl.Call(_m, "RevokeGrant", _param0) +func (m *MockKMSAPI) RevokeGrant(arg0 *kms.RevokeGrantInput) (*kms.RevokeGrantOutput, error) { + 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 { - return _mr.mock.ctrl.RecordCall(_mr.mock, "RevokeGrant", reflect.TypeOf((*MockKMSAPI)(nil).RevokeGrant), arg0) +func (mr *MockKMSAPIMockRecorder) RevokeGrant(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RevokeGrant", reflect.TypeOf((*MockKMSAPI)(nil).RevokeGrant), arg0) } // RevokeGrantWithContext mocks base method -func (_m *MockKMSAPI) RevokeGrantWithContext(_param0 aws.Context, _param1 *kms.RevokeGrantInput, _param2 ...request.Option) (*kms.RevokeGrantOutput, error) { - _s := []interface{}{_param0, _param1} - for _, _x := range _param2 { - _s = append(_s, _x) +func (m *MockKMSAPI) RevokeGrantWithContext(arg0 aws.Context, arg1 *kms.RevokeGrantInput, arg2 ...request.Option) (*kms.RevokeGrantOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) } - ret := _m.ctrl.Call(_m, "RevokeGrantWithContext", _s...) + 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 { - _s := append([]interface{}{arg0, arg1}, arg2...) - return _mr.mock.ctrl.RecordCall(_mr.mock, "RevokeGrantWithContext", reflect.TypeOf((*MockKMSAPI)(nil).RevokeGrantWithContext), _s...) +func (mr *MockKMSAPIMockRecorder) RevokeGrantWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RevokeGrantWithContext", reflect.TypeOf((*MockKMSAPI)(nil).RevokeGrantWithContext), varargs...) } // RevokeGrantRequest mocks base method -func (_m *MockKMSAPI) RevokeGrantRequest(_param0 *kms.RevokeGrantInput) (*request.Request, *kms.RevokeGrantOutput) { - ret := _m.ctrl.Call(_m, "RevokeGrantRequest", _param0) +func (m *MockKMSAPI) RevokeGrantRequest(arg0 *kms.RevokeGrantInput) (*request.Request, *kms.RevokeGrantOutput) { + 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 { - return _mr.mock.ctrl.RecordCall(_mr.mock, "RevokeGrantRequest", reflect.TypeOf((*MockKMSAPI)(nil).RevokeGrantRequest), arg0) +func (mr *MockKMSAPIMockRecorder) RevokeGrantRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RevokeGrantRequest", reflect.TypeOf((*MockKMSAPI)(nil).RevokeGrantRequest), arg0) } // ScheduleKeyDeletion mocks base method -func (_m *MockKMSAPI) ScheduleKeyDeletion(_param0 *kms.ScheduleKeyDeletionInput) (*kms.ScheduleKeyDeletionOutput, error) { - ret := _m.ctrl.Call(_m, "ScheduleKeyDeletion", _param0) +func (m *MockKMSAPI) ScheduleKeyDeletion(arg0 *kms.ScheduleKeyDeletionInput) (*kms.ScheduleKeyDeletionOutput, error) { + 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 { - return _mr.mock.ctrl.RecordCall(_mr.mock, "ScheduleKeyDeletion", reflect.TypeOf((*MockKMSAPI)(nil).ScheduleKeyDeletion), arg0) +func (mr *MockKMSAPIMockRecorder) ScheduleKeyDeletion(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScheduleKeyDeletion", reflect.TypeOf((*MockKMSAPI)(nil).ScheduleKeyDeletion), arg0) } // ScheduleKeyDeletionWithContext mocks base method -func (_m *MockKMSAPI) ScheduleKeyDeletionWithContext(_param0 aws.Context, _param1 *kms.ScheduleKeyDeletionInput, _param2 ...request.Option) (*kms.ScheduleKeyDeletionOutput, error) { - _s := []interface{}{_param0, _param1} - for _, _x := range _param2 { - _s = append(_s, _x) +func (m *MockKMSAPI) ScheduleKeyDeletionWithContext(arg0 aws.Context, arg1 *kms.ScheduleKeyDeletionInput, arg2 ...request.Option) (*kms.ScheduleKeyDeletionOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) } - ret := _m.ctrl.Call(_m, "ScheduleKeyDeletionWithContext", _s...) + 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 { - _s := append([]interface{}{arg0, arg1}, arg2...) - return _mr.mock.ctrl.RecordCall(_mr.mock, "ScheduleKeyDeletionWithContext", reflect.TypeOf((*MockKMSAPI)(nil).ScheduleKeyDeletionWithContext), _s...) +func (mr *MockKMSAPIMockRecorder) ScheduleKeyDeletionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScheduleKeyDeletionWithContext", reflect.TypeOf((*MockKMSAPI)(nil).ScheduleKeyDeletionWithContext), varargs...) } // ScheduleKeyDeletionRequest mocks base method -func (_m *MockKMSAPI) ScheduleKeyDeletionRequest(_param0 *kms.ScheduleKeyDeletionInput) (*request.Request, *kms.ScheduleKeyDeletionOutput) { - ret := _m.ctrl.Call(_m, "ScheduleKeyDeletionRequest", _param0) +func (m *MockKMSAPI) ScheduleKeyDeletionRequest(arg0 *kms.ScheduleKeyDeletionInput) (*request.Request, *kms.ScheduleKeyDeletionOutput) { + 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 { - return _mr.mock.ctrl.RecordCall(_mr.mock, "ScheduleKeyDeletionRequest", reflect.TypeOf((*MockKMSAPI)(nil).ScheduleKeyDeletionRequest), arg0) +func (mr *MockKMSAPIMockRecorder) ScheduleKeyDeletionRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScheduleKeyDeletionRequest", reflect.TypeOf((*MockKMSAPI)(nil).ScheduleKeyDeletionRequest), arg0) } // TagResource mocks base method -func (_m *MockKMSAPI) TagResource(_param0 *kms.TagResourceInput) (*kms.TagResourceOutput, error) { - ret := _m.ctrl.Call(_m, "TagResource", _param0) +func (m *MockKMSAPI) TagResource(arg0 *kms.TagResourceInput) (*kms.TagResourceOutput, error) { + 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 { - return _mr.mock.ctrl.RecordCall(_mr.mock, "TagResource", reflect.TypeOf((*MockKMSAPI)(nil).TagResource), arg0) +func (mr *MockKMSAPIMockRecorder) TagResource(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TagResource", reflect.TypeOf((*MockKMSAPI)(nil).TagResource), arg0) } // TagResourceWithContext mocks base method -func (_m *MockKMSAPI) TagResourceWithContext(_param0 aws.Context, _param1 *kms.TagResourceInput, _param2 ...request.Option) (*kms.TagResourceOutput, error) { - _s := []interface{}{_param0, _param1} - for _, _x := range _param2 { - _s = append(_s, _x) +func (m *MockKMSAPI) TagResourceWithContext(arg0 aws.Context, arg1 *kms.TagResourceInput, arg2 ...request.Option) (*kms.TagResourceOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) } - ret := _m.ctrl.Call(_m, "TagResourceWithContext", _s...) + 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 { - _s := append([]interface{}{arg0, arg1}, arg2...) - return _mr.mock.ctrl.RecordCall(_mr.mock, "TagResourceWithContext", reflect.TypeOf((*MockKMSAPI)(nil).TagResourceWithContext), _s...) +func (mr *MockKMSAPIMockRecorder) TagResourceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TagResourceWithContext", reflect.TypeOf((*MockKMSAPI)(nil).TagResourceWithContext), varargs...) } // TagResourceRequest mocks base method -func (_m *MockKMSAPI) TagResourceRequest(_param0 *kms.TagResourceInput) (*request.Request, *kms.TagResourceOutput) { - ret := _m.ctrl.Call(_m, "TagResourceRequest", _param0) +func (m *MockKMSAPI) TagResourceRequest(arg0 *kms.TagResourceInput) (*request.Request, *kms.TagResourceOutput) { + 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 { - return _mr.mock.ctrl.RecordCall(_mr.mock, "TagResourceRequest", reflect.TypeOf((*MockKMSAPI)(nil).TagResourceRequest), arg0) +func (mr *MockKMSAPIMockRecorder) TagResourceRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TagResourceRequest", reflect.TypeOf((*MockKMSAPI)(nil).TagResourceRequest), arg0) } // UntagResource mocks base method -func (_m *MockKMSAPI) UntagResource(_param0 *kms.UntagResourceInput) (*kms.UntagResourceOutput, error) { - ret := _m.ctrl.Call(_m, "UntagResource", _param0) +func (m *MockKMSAPI) UntagResource(arg0 *kms.UntagResourceInput) (*kms.UntagResourceOutput, error) { + 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 { - return _mr.mock.ctrl.RecordCall(_mr.mock, "UntagResource", reflect.TypeOf((*MockKMSAPI)(nil).UntagResource), arg0) +func (mr *MockKMSAPIMockRecorder) UntagResource(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UntagResource", reflect.TypeOf((*MockKMSAPI)(nil).UntagResource), arg0) } // UntagResourceWithContext mocks base method -func (_m *MockKMSAPI) UntagResourceWithContext(_param0 aws.Context, _param1 *kms.UntagResourceInput, _param2 ...request.Option) (*kms.UntagResourceOutput, error) { - _s := []interface{}{_param0, _param1} - for _, _x := range _param2 { - _s = append(_s, _x) +func (m *MockKMSAPI) UntagResourceWithContext(arg0 aws.Context, arg1 *kms.UntagResourceInput, arg2 ...request.Option) (*kms.UntagResourceOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) } - ret := _m.ctrl.Call(_m, "UntagResourceWithContext", _s...) + 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 { - _s := append([]interface{}{arg0, arg1}, arg2...) - return _mr.mock.ctrl.RecordCall(_mr.mock, "UntagResourceWithContext", reflect.TypeOf((*MockKMSAPI)(nil).UntagResourceWithContext), _s...) +func (mr *MockKMSAPIMockRecorder) UntagResourceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UntagResourceWithContext", reflect.TypeOf((*MockKMSAPI)(nil).UntagResourceWithContext), varargs...) } // UntagResourceRequest mocks base method -func (_m *MockKMSAPI) UntagResourceRequest(_param0 *kms.UntagResourceInput) (*request.Request, *kms.UntagResourceOutput) { - ret := _m.ctrl.Call(_m, "UntagResourceRequest", _param0) +func (m *MockKMSAPI) UntagResourceRequest(arg0 *kms.UntagResourceInput) (*request.Request, *kms.UntagResourceOutput) { + 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 { - return _mr.mock.ctrl.RecordCall(_mr.mock, "UntagResourceRequest", reflect.TypeOf((*MockKMSAPI)(nil).UntagResourceRequest), arg0) +func (mr *MockKMSAPIMockRecorder) UntagResourceRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UntagResourceRequest", reflect.TypeOf((*MockKMSAPI)(nil).UntagResourceRequest), arg0) } // UpdateAlias mocks base method -func (_m *MockKMSAPI) UpdateAlias(_param0 *kms.UpdateAliasInput) (*kms.UpdateAliasOutput, error) { - ret := _m.ctrl.Call(_m, "UpdateAlias", _param0) +func (m *MockKMSAPI) UpdateAlias(arg0 *kms.UpdateAliasInput) (*kms.UpdateAliasOutput, error) { + 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 { - return _mr.mock.ctrl.RecordCall(_mr.mock, "UpdateAlias", reflect.TypeOf((*MockKMSAPI)(nil).UpdateAlias), arg0) +func (mr *MockKMSAPIMockRecorder) UpdateAlias(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateAlias", reflect.TypeOf((*MockKMSAPI)(nil).UpdateAlias), arg0) } // UpdateAliasWithContext mocks base method -func (_m *MockKMSAPI) UpdateAliasWithContext(_param0 aws.Context, _param1 *kms.UpdateAliasInput, _param2 ...request.Option) (*kms.UpdateAliasOutput, error) { - _s := []interface{}{_param0, _param1} - for _, _x := range _param2 { - _s = append(_s, _x) +func (m *MockKMSAPI) UpdateAliasWithContext(arg0 aws.Context, arg1 *kms.UpdateAliasInput, arg2 ...request.Option) (*kms.UpdateAliasOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) } - ret := _m.ctrl.Call(_m, "UpdateAliasWithContext", _s...) + 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 { - _s := append([]interface{}{arg0, arg1}, arg2...) - return _mr.mock.ctrl.RecordCall(_mr.mock, "UpdateAliasWithContext", reflect.TypeOf((*MockKMSAPI)(nil).UpdateAliasWithContext), _s...) +func (mr *MockKMSAPIMockRecorder) UpdateAliasWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateAliasWithContext", reflect.TypeOf((*MockKMSAPI)(nil).UpdateAliasWithContext), varargs...) } // UpdateAliasRequest mocks base method -func (_m *MockKMSAPI) UpdateAliasRequest(_param0 *kms.UpdateAliasInput) (*request.Request, *kms.UpdateAliasOutput) { - ret := _m.ctrl.Call(_m, "UpdateAliasRequest", _param0) +func (m *MockKMSAPI) UpdateAliasRequest(arg0 *kms.UpdateAliasInput) (*request.Request, *kms.UpdateAliasOutput) { + 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 { - return _mr.mock.ctrl.RecordCall(_mr.mock, "UpdateAliasRequest", reflect.TypeOf((*MockKMSAPI)(nil).UpdateAliasRequest), arg0) +func (mr *MockKMSAPIMockRecorder) UpdateAliasRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateAliasRequest", reflect.TypeOf((*MockKMSAPI)(nil).UpdateAliasRequest), arg0) } // UpdateKeyDescription mocks base method -func (_m *MockKMSAPI) UpdateKeyDescription(_param0 *kms.UpdateKeyDescriptionInput) (*kms.UpdateKeyDescriptionOutput, error) { - ret := _m.ctrl.Call(_m, "UpdateKeyDescription", _param0) +func (m *MockKMSAPI) UpdateKeyDescription(arg0 *kms.UpdateKeyDescriptionInput) (*kms.UpdateKeyDescriptionOutput, error) { + 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 { - return _mr.mock.ctrl.RecordCall(_mr.mock, "UpdateKeyDescription", reflect.TypeOf((*MockKMSAPI)(nil).UpdateKeyDescription), arg0) +func (mr *MockKMSAPIMockRecorder) UpdateKeyDescription(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateKeyDescription", reflect.TypeOf((*MockKMSAPI)(nil).UpdateKeyDescription), arg0) } // UpdateKeyDescriptionWithContext mocks base method -func (_m *MockKMSAPI) UpdateKeyDescriptionWithContext(_param0 aws.Context, _param1 *kms.UpdateKeyDescriptionInput, _param2 ...request.Option) (*kms.UpdateKeyDescriptionOutput, error) { - _s := []interface{}{_param0, _param1} - for _, _x := range _param2 { - _s = append(_s, _x) +func (m *MockKMSAPI) UpdateKeyDescriptionWithContext(arg0 aws.Context, arg1 *kms.UpdateKeyDescriptionInput, arg2 ...request.Option) (*kms.UpdateKeyDescriptionOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) } - ret := _m.ctrl.Call(_m, "UpdateKeyDescriptionWithContext", _s...) + 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 { - _s := append([]interface{}{arg0, arg1}, arg2...) - return _mr.mock.ctrl.RecordCall(_mr.mock, "UpdateKeyDescriptionWithContext", reflect.TypeOf((*MockKMSAPI)(nil).UpdateKeyDescriptionWithContext), _s...) +func (mr *MockKMSAPIMockRecorder) UpdateKeyDescriptionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateKeyDescriptionWithContext", reflect.TypeOf((*MockKMSAPI)(nil).UpdateKeyDescriptionWithContext), varargs...) } // UpdateKeyDescriptionRequest mocks base method -func (_m *MockKMSAPI) UpdateKeyDescriptionRequest(_param0 *kms.UpdateKeyDescriptionInput) (*request.Request, *kms.UpdateKeyDescriptionOutput) { - ret := _m.ctrl.Call(_m, "UpdateKeyDescriptionRequest", _param0) +func (m *MockKMSAPI) UpdateKeyDescriptionRequest(arg0 *kms.UpdateKeyDescriptionInput) (*request.Request, *kms.UpdateKeyDescriptionOutput) { + 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 { - return _mr.mock.ctrl.RecordCall(_mr.mock, "UpdateKeyDescriptionRequest", reflect.TypeOf((*MockKMSAPI)(nil).UpdateKeyDescriptionRequest), arg0) +func (mr *MockKMSAPIMockRecorder) UpdateKeyDescriptionRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateKeyDescriptionRequest", reflect.TypeOf((*MockKMSAPI)(nil).UpdateKeyDescriptionRequest), arg0) }