From 17e1dde5848e247e57a62c462941a79e8196b12a Mon Sep 17 00:00:00 2001 From: Repository CI Date: Sat, 21 Oct 2023 02:21:28 +0000 Subject: [PATCH] Automatic ci update Version into v1.46.1 --- aws-sdk.version | 2 +- go.mod | 2 +- go.sum | 2 + .../applicationdiscoveryservicemock/mock.go | 315 ++++++++++++++++++ service/connectmock/mock.go | 50 +++ service/ssmmock/mock.go | 50 +++ 6 files changed, 419 insertions(+), 2 deletions(-) diff --git a/aws-sdk.version b/aws-sdk.version index 71eb27cd..f50b71f0 100755 --- a/aws-sdk.version +++ b/aws-sdk.version @@ -1 +1 @@ -v1.46.0 +v1.46.1 diff --git a/go.mod b/go.mod index bd93411b..e049ae2e 100644 --- a/go.mod +++ b/go.mod @@ -3,7 +3,7 @@ module github.com/Itarix/aws-sdk-go-mocks go 1.15 require ( - github.com/aws/aws-sdk-go v1.46.0 + github.com/aws/aws-sdk-go v1.46.1 github.com/davecgh/go-spew v1.1.1 // indirect github.com/golang/mock v1.4.4 github.com/pmezard/go-difflib v1.0.0 // indirect diff --git a/go.sum b/go.sum index a4ca88ac..b968890d 100644 --- a/go.sum +++ b/go.sum @@ -2282,6 +2282,8 @@ github.com/aws/aws-sdk-go v1.45.28 h1:p2ATcaK6ffSw4yZ2UAGzgRyRXwKyOJY6ZCiKqj5miJ github.com/aws/aws-sdk-go v1.45.28/go.mod h1:aVsgQcEevwlmQ7qHE9I3h+dtQgpqhFB+i8Phjh7fkwI= github.com/aws/aws-sdk-go v1.46.0 h1:Igh7W8P+sA6mXJ9yhreOSweefLapcqekhxQlY1llxcM= github.com/aws/aws-sdk-go v1.46.0/go.mod h1:aVsgQcEevwlmQ7qHE9I3h+dtQgpqhFB+i8Phjh7fkwI= +github.com/aws/aws-sdk-go v1.46.1 h1:U26quvBWFZMQuultLw5tloW4GnmWaChEwMZNq8uYatw= +github.com/aws/aws-sdk-go v1.46.1/go.mod h1:aVsgQcEevwlmQ7qHE9I3h+dtQgpqhFB+i8Phjh7fkwI= github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= diff --git a/service/applicationdiscoveryservicemock/mock.go b/service/applicationdiscoveryservicemock/mock.go index ef861387..c4526e4f 100644 --- a/service/applicationdiscoveryservicemock/mock.go +++ b/service/applicationdiscoveryservicemock/mock.go @@ -85,6 +85,56 @@ func (mr *MockApplicationDiscoveryServiceAPIMockRecorder) AssociateConfiguration return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateConfigurationItemsToApplicationWithContext", reflect.TypeOf((*MockApplicationDiscoveryServiceAPI)(nil).AssociateConfigurationItemsToApplicationWithContext), varargs...) } +// BatchDeleteAgents mocks base method +func (m *MockApplicationDiscoveryServiceAPI) BatchDeleteAgents(arg0 *applicationdiscoveryservice.BatchDeleteAgentsInput) (*applicationdiscoveryservice.BatchDeleteAgentsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BatchDeleteAgents", arg0) + ret0, _ := ret[0].(*applicationdiscoveryservice.BatchDeleteAgentsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// BatchDeleteAgents indicates an expected call of BatchDeleteAgents +func (mr *MockApplicationDiscoveryServiceAPIMockRecorder) BatchDeleteAgents(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchDeleteAgents", reflect.TypeOf((*MockApplicationDiscoveryServiceAPI)(nil).BatchDeleteAgents), arg0) +} + +// BatchDeleteAgentsRequest mocks base method +func (m *MockApplicationDiscoveryServiceAPI) BatchDeleteAgentsRequest(arg0 *applicationdiscoveryservice.BatchDeleteAgentsInput) (*request.Request, *applicationdiscoveryservice.BatchDeleteAgentsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BatchDeleteAgentsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*applicationdiscoveryservice.BatchDeleteAgentsOutput) + return ret0, ret1 +} + +// BatchDeleteAgentsRequest indicates an expected call of BatchDeleteAgentsRequest +func (mr *MockApplicationDiscoveryServiceAPIMockRecorder) BatchDeleteAgentsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchDeleteAgentsRequest", reflect.TypeOf((*MockApplicationDiscoveryServiceAPI)(nil).BatchDeleteAgentsRequest), arg0) +} + +// BatchDeleteAgentsWithContext mocks base method +func (m *MockApplicationDiscoveryServiceAPI) BatchDeleteAgentsWithContext(arg0 context.Context, arg1 *applicationdiscoveryservice.BatchDeleteAgentsInput, arg2 ...request.Option) (*applicationdiscoveryservice.BatchDeleteAgentsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "BatchDeleteAgentsWithContext", varargs...) + ret0, _ := ret[0].(*applicationdiscoveryservice.BatchDeleteAgentsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// BatchDeleteAgentsWithContext indicates an expected call of BatchDeleteAgentsWithContext +func (mr *MockApplicationDiscoveryServiceAPIMockRecorder) BatchDeleteAgentsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchDeleteAgentsWithContext", reflect.TypeOf((*MockApplicationDiscoveryServiceAPI)(nil).BatchDeleteAgentsWithContext), varargs...) +} + // BatchDeleteImportData mocks base method func (m *MockApplicationDiscoveryServiceAPI) BatchDeleteImportData(arg0 *applicationdiscoveryservice.BatchDeleteImportDataInput) (*applicationdiscoveryservice.BatchDeleteImportDataOutput, error) { m.ctrl.T.Helper() @@ -350,6 +400,39 @@ func (mr *MockApplicationDiscoveryServiceAPIMockRecorder) DescribeAgents(arg0 in return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAgents", reflect.TypeOf((*MockApplicationDiscoveryServiceAPI)(nil).DescribeAgents), arg0) } +// DescribeAgentsPages mocks base method +func (m *MockApplicationDiscoveryServiceAPI) DescribeAgentsPages(arg0 *applicationdiscoveryservice.DescribeAgentsInput, arg1 func(*applicationdiscoveryservice.DescribeAgentsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeAgentsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeAgentsPages indicates an expected call of DescribeAgentsPages +func (mr *MockApplicationDiscoveryServiceAPIMockRecorder) DescribeAgentsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAgentsPages", reflect.TypeOf((*MockApplicationDiscoveryServiceAPI)(nil).DescribeAgentsPages), arg0, arg1) +} + +// DescribeAgentsPagesWithContext mocks base method +func (m *MockApplicationDiscoveryServiceAPI) DescribeAgentsPagesWithContext(arg0 context.Context, arg1 *applicationdiscoveryservice.DescribeAgentsInput, arg2 func(*applicationdiscoveryservice.DescribeAgentsOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeAgentsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeAgentsPagesWithContext indicates an expected call of DescribeAgentsPagesWithContext +func (mr *MockApplicationDiscoveryServiceAPIMockRecorder) DescribeAgentsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAgentsPagesWithContext", reflect.TypeOf((*MockApplicationDiscoveryServiceAPI)(nil).DescribeAgentsPagesWithContext), varargs...) +} + // DescribeAgentsRequest mocks base method func (m *MockApplicationDiscoveryServiceAPI) DescribeAgentsRequest(arg0 *applicationdiscoveryservice.DescribeAgentsInput) (*request.Request, *applicationdiscoveryservice.DescribeAgentsOutput) { m.ctrl.T.Helper() @@ -385,6 +468,56 @@ func (mr *MockApplicationDiscoveryServiceAPIMockRecorder) DescribeAgentsWithCont return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAgentsWithContext", reflect.TypeOf((*MockApplicationDiscoveryServiceAPI)(nil).DescribeAgentsWithContext), varargs...) } +// DescribeBatchDeleteConfigurationTask mocks base method +func (m *MockApplicationDiscoveryServiceAPI) DescribeBatchDeleteConfigurationTask(arg0 *applicationdiscoveryservice.DescribeBatchDeleteConfigurationTaskInput) (*applicationdiscoveryservice.DescribeBatchDeleteConfigurationTaskOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeBatchDeleteConfigurationTask", arg0) + ret0, _ := ret[0].(*applicationdiscoveryservice.DescribeBatchDeleteConfigurationTaskOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeBatchDeleteConfigurationTask indicates an expected call of DescribeBatchDeleteConfigurationTask +func (mr *MockApplicationDiscoveryServiceAPIMockRecorder) DescribeBatchDeleteConfigurationTask(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeBatchDeleteConfigurationTask", reflect.TypeOf((*MockApplicationDiscoveryServiceAPI)(nil).DescribeBatchDeleteConfigurationTask), arg0) +} + +// DescribeBatchDeleteConfigurationTaskRequest mocks base method +func (m *MockApplicationDiscoveryServiceAPI) DescribeBatchDeleteConfigurationTaskRequest(arg0 *applicationdiscoveryservice.DescribeBatchDeleteConfigurationTaskInput) (*request.Request, *applicationdiscoveryservice.DescribeBatchDeleteConfigurationTaskOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeBatchDeleteConfigurationTaskRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*applicationdiscoveryservice.DescribeBatchDeleteConfigurationTaskOutput) + return ret0, ret1 +} + +// DescribeBatchDeleteConfigurationTaskRequest indicates an expected call of DescribeBatchDeleteConfigurationTaskRequest +func (mr *MockApplicationDiscoveryServiceAPIMockRecorder) DescribeBatchDeleteConfigurationTaskRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeBatchDeleteConfigurationTaskRequest", reflect.TypeOf((*MockApplicationDiscoveryServiceAPI)(nil).DescribeBatchDeleteConfigurationTaskRequest), arg0) +} + +// DescribeBatchDeleteConfigurationTaskWithContext mocks base method +func (m *MockApplicationDiscoveryServiceAPI) DescribeBatchDeleteConfigurationTaskWithContext(arg0 context.Context, arg1 *applicationdiscoveryservice.DescribeBatchDeleteConfigurationTaskInput, arg2 ...request.Option) (*applicationdiscoveryservice.DescribeBatchDeleteConfigurationTaskOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeBatchDeleteConfigurationTaskWithContext", varargs...) + ret0, _ := ret[0].(*applicationdiscoveryservice.DescribeBatchDeleteConfigurationTaskOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeBatchDeleteConfigurationTaskWithContext indicates an expected call of DescribeBatchDeleteConfigurationTaskWithContext +func (mr *MockApplicationDiscoveryServiceAPIMockRecorder) DescribeBatchDeleteConfigurationTaskWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeBatchDeleteConfigurationTaskWithContext", reflect.TypeOf((*MockApplicationDiscoveryServiceAPI)(nil).DescribeBatchDeleteConfigurationTaskWithContext), varargs...) +} + // DescribeConfigurations mocks base method func (m *MockApplicationDiscoveryServiceAPI) DescribeConfigurations(arg0 *applicationdiscoveryservice.DescribeConfigurationsInput) (*applicationdiscoveryservice.DescribeConfigurationsOutput, error) { m.ctrl.T.Helper() @@ -533,6 +666,39 @@ func (mr *MockApplicationDiscoveryServiceAPIMockRecorder) DescribeExportConfigur return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeExportConfigurations", reflect.TypeOf((*MockApplicationDiscoveryServiceAPI)(nil).DescribeExportConfigurations), arg0) } +// DescribeExportConfigurationsPages mocks base method +func (m *MockApplicationDiscoveryServiceAPI) DescribeExportConfigurationsPages(arg0 *applicationdiscoveryservice.DescribeExportConfigurationsInput, arg1 func(*applicationdiscoveryservice.DescribeExportConfigurationsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeExportConfigurationsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeExportConfigurationsPages indicates an expected call of DescribeExportConfigurationsPages +func (mr *MockApplicationDiscoveryServiceAPIMockRecorder) DescribeExportConfigurationsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeExportConfigurationsPages", reflect.TypeOf((*MockApplicationDiscoveryServiceAPI)(nil).DescribeExportConfigurationsPages), arg0, arg1) +} + +// DescribeExportConfigurationsPagesWithContext mocks base method +func (m *MockApplicationDiscoveryServiceAPI) DescribeExportConfigurationsPagesWithContext(arg0 context.Context, arg1 *applicationdiscoveryservice.DescribeExportConfigurationsInput, arg2 func(*applicationdiscoveryservice.DescribeExportConfigurationsOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeExportConfigurationsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeExportConfigurationsPagesWithContext indicates an expected call of DescribeExportConfigurationsPagesWithContext +func (mr *MockApplicationDiscoveryServiceAPIMockRecorder) DescribeExportConfigurationsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeExportConfigurationsPagesWithContext", reflect.TypeOf((*MockApplicationDiscoveryServiceAPI)(nil).DescribeExportConfigurationsPagesWithContext), varargs...) +} + // DescribeExportConfigurationsRequest mocks base method func (m *MockApplicationDiscoveryServiceAPI) DescribeExportConfigurationsRequest(arg0 *applicationdiscoveryservice.DescribeExportConfigurationsInput) (*request.Request, *applicationdiscoveryservice.DescribeExportConfigurationsOutput) { m.ctrl.T.Helper() @@ -583,6 +749,39 @@ func (mr *MockApplicationDiscoveryServiceAPIMockRecorder) DescribeExportTasks(ar return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeExportTasks", reflect.TypeOf((*MockApplicationDiscoveryServiceAPI)(nil).DescribeExportTasks), arg0) } +// DescribeExportTasksPages mocks base method +func (m *MockApplicationDiscoveryServiceAPI) DescribeExportTasksPages(arg0 *applicationdiscoveryservice.DescribeExportTasksInput, arg1 func(*applicationdiscoveryservice.DescribeExportTasksOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeExportTasksPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeExportTasksPages indicates an expected call of DescribeExportTasksPages +func (mr *MockApplicationDiscoveryServiceAPIMockRecorder) DescribeExportTasksPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeExportTasksPages", reflect.TypeOf((*MockApplicationDiscoveryServiceAPI)(nil).DescribeExportTasksPages), arg0, arg1) +} + +// DescribeExportTasksPagesWithContext mocks base method +func (m *MockApplicationDiscoveryServiceAPI) DescribeExportTasksPagesWithContext(arg0 context.Context, arg1 *applicationdiscoveryservice.DescribeExportTasksInput, arg2 func(*applicationdiscoveryservice.DescribeExportTasksOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeExportTasksPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeExportTasksPagesWithContext indicates an expected call of DescribeExportTasksPagesWithContext +func (mr *MockApplicationDiscoveryServiceAPIMockRecorder) DescribeExportTasksPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeExportTasksPagesWithContext", reflect.TypeOf((*MockApplicationDiscoveryServiceAPI)(nil).DescribeExportTasksPagesWithContext), varargs...) +} + // DescribeExportTasksRequest mocks base method func (m *MockApplicationDiscoveryServiceAPI) DescribeExportTasksRequest(arg0 *applicationdiscoveryservice.DescribeExportTasksInput) (*request.Request, *applicationdiscoveryservice.DescribeExportTasksOutput) { m.ctrl.T.Helper() @@ -716,6 +915,39 @@ func (mr *MockApplicationDiscoveryServiceAPIMockRecorder) DescribeTags(arg0 inte return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTags", reflect.TypeOf((*MockApplicationDiscoveryServiceAPI)(nil).DescribeTags), arg0) } +// DescribeTagsPages mocks base method +func (m *MockApplicationDiscoveryServiceAPI) DescribeTagsPages(arg0 *applicationdiscoveryservice.DescribeTagsInput, arg1 func(*applicationdiscoveryservice.DescribeTagsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeTagsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeTagsPages indicates an expected call of DescribeTagsPages +func (mr *MockApplicationDiscoveryServiceAPIMockRecorder) DescribeTagsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTagsPages", reflect.TypeOf((*MockApplicationDiscoveryServiceAPI)(nil).DescribeTagsPages), arg0, arg1) +} + +// DescribeTagsPagesWithContext mocks base method +func (m *MockApplicationDiscoveryServiceAPI) DescribeTagsPagesWithContext(arg0 context.Context, arg1 *applicationdiscoveryservice.DescribeTagsInput, arg2 func(*applicationdiscoveryservice.DescribeTagsOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeTagsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeTagsPagesWithContext indicates an expected call of DescribeTagsPagesWithContext +func (mr *MockApplicationDiscoveryServiceAPIMockRecorder) DescribeTagsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTagsPagesWithContext", reflect.TypeOf((*MockApplicationDiscoveryServiceAPI)(nil).DescribeTagsPagesWithContext), varargs...) +} + // DescribeTagsRequest mocks base method func (m *MockApplicationDiscoveryServiceAPI) DescribeTagsRequest(arg0 *applicationdiscoveryservice.DescribeTagsInput) (*request.Request, *applicationdiscoveryservice.DescribeTagsOutput) { m.ctrl.T.Helper() @@ -916,6 +1148,39 @@ func (mr *MockApplicationDiscoveryServiceAPIMockRecorder) ListConfigurations(arg return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListConfigurations", reflect.TypeOf((*MockApplicationDiscoveryServiceAPI)(nil).ListConfigurations), arg0) } +// ListConfigurationsPages mocks base method +func (m *MockApplicationDiscoveryServiceAPI) ListConfigurationsPages(arg0 *applicationdiscoveryservice.ListConfigurationsInput, arg1 func(*applicationdiscoveryservice.ListConfigurationsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListConfigurationsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListConfigurationsPages indicates an expected call of ListConfigurationsPages +func (mr *MockApplicationDiscoveryServiceAPIMockRecorder) ListConfigurationsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListConfigurationsPages", reflect.TypeOf((*MockApplicationDiscoveryServiceAPI)(nil).ListConfigurationsPages), arg0, arg1) +} + +// ListConfigurationsPagesWithContext mocks base method +func (m *MockApplicationDiscoveryServiceAPI) ListConfigurationsPagesWithContext(arg0 context.Context, arg1 *applicationdiscoveryservice.ListConfigurationsInput, arg2 func(*applicationdiscoveryservice.ListConfigurationsOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListConfigurationsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListConfigurationsPagesWithContext indicates an expected call of ListConfigurationsPagesWithContext +func (mr *MockApplicationDiscoveryServiceAPIMockRecorder) ListConfigurationsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListConfigurationsPagesWithContext", reflect.TypeOf((*MockApplicationDiscoveryServiceAPI)(nil).ListConfigurationsPagesWithContext), varargs...) +} + // ListConfigurationsRequest mocks base method func (m *MockApplicationDiscoveryServiceAPI) ListConfigurationsRequest(arg0 *applicationdiscoveryservice.ListConfigurationsInput) (*request.Request, *applicationdiscoveryservice.ListConfigurationsOutput) { m.ctrl.T.Helper() @@ -1001,6 +1266,56 @@ func (mr *MockApplicationDiscoveryServiceAPIMockRecorder) ListServerNeighborsWit return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListServerNeighborsWithContext", reflect.TypeOf((*MockApplicationDiscoveryServiceAPI)(nil).ListServerNeighborsWithContext), varargs...) } +// StartBatchDeleteConfigurationTask mocks base method +func (m *MockApplicationDiscoveryServiceAPI) StartBatchDeleteConfigurationTask(arg0 *applicationdiscoveryservice.StartBatchDeleteConfigurationTaskInput) (*applicationdiscoveryservice.StartBatchDeleteConfigurationTaskOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "StartBatchDeleteConfigurationTask", arg0) + ret0, _ := ret[0].(*applicationdiscoveryservice.StartBatchDeleteConfigurationTaskOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// StartBatchDeleteConfigurationTask indicates an expected call of StartBatchDeleteConfigurationTask +func (mr *MockApplicationDiscoveryServiceAPIMockRecorder) StartBatchDeleteConfigurationTask(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartBatchDeleteConfigurationTask", reflect.TypeOf((*MockApplicationDiscoveryServiceAPI)(nil).StartBatchDeleteConfigurationTask), arg0) +} + +// StartBatchDeleteConfigurationTaskRequest mocks base method +func (m *MockApplicationDiscoveryServiceAPI) StartBatchDeleteConfigurationTaskRequest(arg0 *applicationdiscoveryservice.StartBatchDeleteConfigurationTaskInput) (*request.Request, *applicationdiscoveryservice.StartBatchDeleteConfigurationTaskOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "StartBatchDeleteConfigurationTaskRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*applicationdiscoveryservice.StartBatchDeleteConfigurationTaskOutput) + return ret0, ret1 +} + +// StartBatchDeleteConfigurationTaskRequest indicates an expected call of StartBatchDeleteConfigurationTaskRequest +func (mr *MockApplicationDiscoveryServiceAPIMockRecorder) StartBatchDeleteConfigurationTaskRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartBatchDeleteConfigurationTaskRequest", reflect.TypeOf((*MockApplicationDiscoveryServiceAPI)(nil).StartBatchDeleteConfigurationTaskRequest), arg0) +} + +// StartBatchDeleteConfigurationTaskWithContext mocks base method +func (m *MockApplicationDiscoveryServiceAPI) StartBatchDeleteConfigurationTaskWithContext(arg0 context.Context, arg1 *applicationdiscoveryservice.StartBatchDeleteConfigurationTaskInput, arg2 ...request.Option) (*applicationdiscoveryservice.StartBatchDeleteConfigurationTaskOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "StartBatchDeleteConfigurationTaskWithContext", varargs...) + ret0, _ := ret[0].(*applicationdiscoveryservice.StartBatchDeleteConfigurationTaskOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// StartBatchDeleteConfigurationTaskWithContext indicates an expected call of StartBatchDeleteConfigurationTaskWithContext +func (mr *MockApplicationDiscoveryServiceAPIMockRecorder) StartBatchDeleteConfigurationTaskWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartBatchDeleteConfigurationTaskWithContext", reflect.TypeOf((*MockApplicationDiscoveryServiceAPI)(nil).StartBatchDeleteConfigurationTaskWithContext), varargs...) +} + // StartContinuousExport mocks base method func (m *MockApplicationDiscoveryServiceAPI) StartContinuousExport(arg0 *applicationdiscoveryservice.StartContinuousExportInput) (*applicationdiscoveryservice.StartContinuousExportOutput, error) { m.ctrl.T.Helper() diff --git a/service/connectmock/mock.go b/service/connectmock/mock.go index 0008bdc1..a76b55b5 100644 --- a/service/connectmock/mock.go +++ b/service/connectmock/mock.go @@ -10916,6 +10916,56 @@ func (mr *MockConnectAPIMockRecorder) UpdatePhoneNumber(arg0 interface{}) *gomoc return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatePhoneNumber", reflect.TypeOf((*MockConnectAPI)(nil).UpdatePhoneNumber), arg0) } +// UpdatePhoneNumberMetadata mocks base method +func (m *MockConnectAPI) UpdatePhoneNumberMetadata(arg0 *connect.UpdatePhoneNumberMetadataInput) (*connect.UpdatePhoneNumberMetadataOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdatePhoneNumberMetadata", arg0) + ret0, _ := ret[0].(*connect.UpdatePhoneNumberMetadataOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdatePhoneNumberMetadata indicates an expected call of UpdatePhoneNumberMetadata +func (mr *MockConnectAPIMockRecorder) UpdatePhoneNumberMetadata(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatePhoneNumberMetadata", reflect.TypeOf((*MockConnectAPI)(nil).UpdatePhoneNumberMetadata), arg0) +} + +// UpdatePhoneNumberMetadataRequest mocks base method +func (m *MockConnectAPI) UpdatePhoneNumberMetadataRequest(arg0 *connect.UpdatePhoneNumberMetadataInput) (*request.Request, *connect.UpdatePhoneNumberMetadataOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdatePhoneNumberMetadataRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*connect.UpdatePhoneNumberMetadataOutput) + return ret0, ret1 +} + +// UpdatePhoneNumberMetadataRequest indicates an expected call of UpdatePhoneNumberMetadataRequest +func (mr *MockConnectAPIMockRecorder) UpdatePhoneNumberMetadataRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatePhoneNumberMetadataRequest", reflect.TypeOf((*MockConnectAPI)(nil).UpdatePhoneNumberMetadataRequest), arg0) +} + +// UpdatePhoneNumberMetadataWithContext mocks base method +func (m *MockConnectAPI) UpdatePhoneNumberMetadataWithContext(arg0 context.Context, arg1 *connect.UpdatePhoneNumberMetadataInput, arg2 ...request.Option) (*connect.UpdatePhoneNumberMetadataOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "UpdatePhoneNumberMetadataWithContext", varargs...) + ret0, _ := ret[0].(*connect.UpdatePhoneNumberMetadataOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdatePhoneNumberMetadataWithContext indicates an expected call of UpdatePhoneNumberMetadataWithContext +func (mr *MockConnectAPIMockRecorder) UpdatePhoneNumberMetadataWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatePhoneNumberMetadataWithContext", reflect.TypeOf((*MockConnectAPI)(nil).UpdatePhoneNumberMetadataWithContext), varargs...) +} + // UpdatePhoneNumberRequest mocks base method func (m *MockConnectAPI) UpdatePhoneNumberRequest(arg0 *connect.UpdatePhoneNumberInput) (*request.Request, *connect.UpdatePhoneNumberOutput) { m.ctrl.T.Helper() diff --git a/service/ssmmock/mock.go b/service/ssmmock/mock.go index 620c4907..aaa0c6a7 100644 --- a/service/ssmmock/mock.go +++ b/service/ssmmock/mock.go @@ -935,6 +935,56 @@ func (mr *MockSSMAPIMockRecorder) DeleteMaintenanceWindowWithContext(arg0, arg1 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteMaintenanceWindowWithContext", reflect.TypeOf((*MockSSMAPI)(nil).DeleteMaintenanceWindowWithContext), varargs...) } +// DeleteOpsItem mocks base method +func (m *MockSSMAPI) DeleteOpsItem(arg0 *ssm.DeleteOpsItemInput) (*ssm.DeleteOpsItemOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteOpsItem", arg0) + ret0, _ := ret[0].(*ssm.DeleteOpsItemOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteOpsItem indicates an expected call of DeleteOpsItem +func (mr *MockSSMAPIMockRecorder) DeleteOpsItem(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteOpsItem", reflect.TypeOf((*MockSSMAPI)(nil).DeleteOpsItem), arg0) +} + +// DeleteOpsItemRequest mocks base method +func (m *MockSSMAPI) DeleteOpsItemRequest(arg0 *ssm.DeleteOpsItemInput) (*request.Request, *ssm.DeleteOpsItemOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteOpsItemRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ssm.DeleteOpsItemOutput) + return ret0, ret1 +} + +// DeleteOpsItemRequest indicates an expected call of DeleteOpsItemRequest +func (mr *MockSSMAPIMockRecorder) DeleteOpsItemRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteOpsItemRequest", reflect.TypeOf((*MockSSMAPI)(nil).DeleteOpsItemRequest), arg0) +} + +// DeleteOpsItemWithContext mocks base method +func (m *MockSSMAPI) DeleteOpsItemWithContext(arg0 context.Context, arg1 *ssm.DeleteOpsItemInput, arg2 ...request.Option) (*ssm.DeleteOpsItemOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteOpsItemWithContext", varargs...) + ret0, _ := ret[0].(*ssm.DeleteOpsItemOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteOpsItemWithContext indicates an expected call of DeleteOpsItemWithContext +func (mr *MockSSMAPIMockRecorder) DeleteOpsItemWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteOpsItemWithContext", reflect.TypeOf((*MockSSMAPI)(nil).DeleteOpsItemWithContext), varargs...) +} + // DeleteOpsMetadata mocks base method func (m *MockSSMAPI) DeleteOpsMetadata(arg0 *ssm.DeleteOpsMetadataInput) (*ssm.DeleteOpsMetadataOutput, error) { m.ctrl.T.Helper()