diff --git a/.mockery.yaml b/.mockery.yaml index cef6f61d..aa6f5e4f 100644 --- a/.mockery.yaml +++ b/.mockery.yaml @@ -25,4 +25,9 @@ packages: interfaces: ClientService: config: - mockname: "MockIam{{.InterfaceName}}" \ No newline at end of file + mockname: "MockIam{{.InterfaceName}}" + github.com/cloudera/terraform-provider-cdp/cdp-sdk-go/gen/dw/client/operations: + interfaces: + ClientService: + config: + mockname: "MockDw{{.InterfaceName}}" diff --git a/mocks/github.com/cloudera/terraform-provider-cdp/cdp-sdk-go/gen/dw/client/operations/MockDwClientService.go b/mocks/github.com/cloudera/terraform-provider-cdp/cdp-sdk-go/gen/dw/client/operations/MockDwClientService.go new file mode 100644 index 00000000..4222a24c --- /dev/null +++ b/mocks/github.com/cloudera/terraform-provider-cdp/cdp-sdk-go/gen/dw/client/operations/MockDwClientService.go @@ -0,0 +1,6566 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + operations "github.com/cloudera/terraform-provider-cdp/cdp-sdk-go/gen/dw/client/operations" + runtime "github.com/go-openapi/runtime" + mock "github.com/stretchr/testify/mock" +) + +// MockDwClientService is an autogenerated mock type for the ClientService type +type MockDwClientService struct { + mock.Mock +} + +type MockDwClientService_Expecter struct { + mock *mock.Mock +} + +func (_m *MockDwClientService) EXPECT() *MockDwClientService_Expecter { + return &MockDwClientService_Expecter{mock: &_m.Mock} +} + +// AddUser provides a mock function with given fields: params, opts +func (_m *MockDwClientService) AddUser(params *operations.AddUserParams, opts ...operations.ClientOption) (*operations.AddUserOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for AddUser") + } + + var r0 *operations.AddUserOK + var r1 error + if rf, ok := ret.Get(0).(func(*operations.AddUserParams, ...operations.ClientOption) (*operations.AddUserOK, error)); ok { + return rf(params, opts...) + } + if rf, ok := ret.Get(0).(func(*operations.AddUserParams, ...operations.ClientOption) *operations.AddUserOK); ok { + r0 = rf(params, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*operations.AddUserOK) + } + } + + if rf, ok := ret.Get(1).(func(*operations.AddUserParams, ...operations.ClientOption) error); ok { + r1 = rf(params, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDwClientService_AddUser_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddUser' +type MockDwClientService_AddUser_Call struct { + *mock.Call +} + +// AddUser is a helper method to define mock.On call +// - params *operations.AddUserParams +// - opts ...operations.ClientOption +func (_e *MockDwClientService_Expecter) AddUser(params interface{}, opts ...interface{}) *MockDwClientService_AddUser_Call { + return &MockDwClientService_AddUser_Call{Call: _e.mock.On("AddUser", + append([]interface{}{params}, opts...)...)} +} + +func (_c *MockDwClientService_AddUser_Call) Run(run func(params *operations.AddUserParams, opts ...operations.ClientOption)) *MockDwClientService_AddUser_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]operations.ClientOption, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(operations.ClientOption) + } + } + run(args[0].(*operations.AddUserParams), variadicArgs...) + }) + return _c +} + +func (_c *MockDwClientService_AddUser_Call) Return(_a0 *operations.AddUserOK, _a1 error) *MockDwClientService_AddUser_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDwClientService_AddUser_Call) RunAndReturn(run func(*operations.AddUserParams, ...operations.ClientOption) (*operations.AddUserOK, error)) *MockDwClientService_AddUser_Call { + _c.Call.Return(run) + return _c +} + +// BackupCluster provides a mock function with given fields: params, opts +func (_m *MockDwClientService) BackupCluster(params *operations.BackupClusterParams, opts ...operations.ClientOption) (*operations.BackupClusterOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for BackupCluster") + } + + var r0 *operations.BackupClusterOK + var r1 error + if rf, ok := ret.Get(0).(func(*operations.BackupClusterParams, ...operations.ClientOption) (*operations.BackupClusterOK, error)); ok { + return rf(params, opts...) + } + if rf, ok := ret.Get(0).(func(*operations.BackupClusterParams, ...operations.ClientOption) *operations.BackupClusterOK); ok { + r0 = rf(params, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*operations.BackupClusterOK) + } + } + + if rf, ok := ret.Get(1).(func(*operations.BackupClusterParams, ...operations.ClientOption) error); ok { + r1 = rf(params, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDwClientService_BackupCluster_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BackupCluster' +type MockDwClientService_BackupCluster_Call struct { + *mock.Call +} + +// BackupCluster is a helper method to define mock.On call +// - params *operations.BackupClusterParams +// - opts ...operations.ClientOption +func (_e *MockDwClientService_Expecter) BackupCluster(params interface{}, opts ...interface{}) *MockDwClientService_BackupCluster_Call { + return &MockDwClientService_BackupCluster_Call{Call: _e.mock.On("BackupCluster", + append([]interface{}{params}, opts...)...)} +} + +func (_c *MockDwClientService_BackupCluster_Call) Run(run func(params *operations.BackupClusterParams, opts ...operations.ClientOption)) *MockDwClientService_BackupCluster_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]operations.ClientOption, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(operations.ClientOption) + } + } + run(args[0].(*operations.BackupClusterParams), variadicArgs...) + }) + return _c +} + +func (_c *MockDwClientService_BackupCluster_Call) Return(_a0 *operations.BackupClusterOK, _a1 error) *MockDwClientService_BackupCluster_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDwClientService_BackupCluster_Call) RunAndReturn(run func(*operations.BackupClusterParams, ...operations.ClientOption) (*operations.BackupClusterOK, error)) *MockDwClientService_BackupCluster_Call { + _c.Call.Return(run) + return _c +} + +// CreateAwsCluster provides a mock function with given fields: params, opts +func (_m *MockDwClientService) CreateAwsCluster(params *operations.CreateAwsClusterParams, opts ...operations.ClientOption) (*operations.CreateAwsClusterOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for CreateAwsCluster") + } + + var r0 *operations.CreateAwsClusterOK + var r1 error + if rf, ok := ret.Get(0).(func(*operations.CreateAwsClusterParams, ...operations.ClientOption) (*operations.CreateAwsClusterOK, error)); ok { + return rf(params, opts...) + } + if rf, ok := ret.Get(0).(func(*operations.CreateAwsClusterParams, ...operations.ClientOption) *operations.CreateAwsClusterOK); ok { + r0 = rf(params, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*operations.CreateAwsClusterOK) + } + } + + if rf, ok := ret.Get(1).(func(*operations.CreateAwsClusterParams, ...operations.ClientOption) error); ok { + r1 = rf(params, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDwClientService_CreateAwsCluster_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateAwsCluster' +type MockDwClientService_CreateAwsCluster_Call struct { + *mock.Call +} + +// CreateAwsCluster is a helper method to define mock.On call +// - params *operations.CreateAwsClusterParams +// - opts ...operations.ClientOption +func (_e *MockDwClientService_Expecter) CreateAwsCluster(params interface{}, opts ...interface{}) *MockDwClientService_CreateAwsCluster_Call { + return &MockDwClientService_CreateAwsCluster_Call{Call: _e.mock.On("CreateAwsCluster", + append([]interface{}{params}, opts...)...)} +} + +func (_c *MockDwClientService_CreateAwsCluster_Call) Run(run func(params *operations.CreateAwsClusterParams, opts ...operations.ClientOption)) *MockDwClientService_CreateAwsCluster_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]operations.ClientOption, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(operations.ClientOption) + } + } + run(args[0].(*operations.CreateAwsClusterParams), variadicArgs...) + }) + return _c +} + +func (_c *MockDwClientService_CreateAwsCluster_Call) Return(_a0 *operations.CreateAwsClusterOK, _a1 error) *MockDwClientService_CreateAwsCluster_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDwClientService_CreateAwsCluster_Call) RunAndReturn(run func(*operations.CreateAwsClusterParams, ...operations.ClientOption) (*operations.CreateAwsClusterOK, error)) *MockDwClientService_CreateAwsCluster_Call { + _c.Call.Return(run) + return _c +} + +// CreateAzureCluster provides a mock function with given fields: params, opts +func (_m *MockDwClientService) CreateAzureCluster(params *operations.CreateAzureClusterParams, opts ...operations.ClientOption) (*operations.CreateAzureClusterOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for CreateAzureCluster") + } + + var r0 *operations.CreateAzureClusterOK + var r1 error + if rf, ok := ret.Get(0).(func(*operations.CreateAzureClusterParams, ...operations.ClientOption) (*operations.CreateAzureClusterOK, error)); ok { + return rf(params, opts...) + } + if rf, ok := ret.Get(0).(func(*operations.CreateAzureClusterParams, ...operations.ClientOption) *operations.CreateAzureClusterOK); ok { + r0 = rf(params, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*operations.CreateAzureClusterOK) + } + } + + if rf, ok := ret.Get(1).(func(*operations.CreateAzureClusterParams, ...operations.ClientOption) error); ok { + r1 = rf(params, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDwClientService_CreateAzureCluster_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateAzureCluster' +type MockDwClientService_CreateAzureCluster_Call struct { + *mock.Call +} + +// CreateAzureCluster is a helper method to define mock.On call +// - params *operations.CreateAzureClusterParams +// - opts ...operations.ClientOption +func (_e *MockDwClientService_Expecter) CreateAzureCluster(params interface{}, opts ...interface{}) *MockDwClientService_CreateAzureCluster_Call { + return &MockDwClientService_CreateAzureCluster_Call{Call: _e.mock.On("CreateAzureCluster", + append([]interface{}{params}, opts...)...)} +} + +func (_c *MockDwClientService_CreateAzureCluster_Call) Run(run func(params *operations.CreateAzureClusterParams, opts ...operations.ClientOption)) *MockDwClientService_CreateAzureCluster_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]operations.ClientOption, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(operations.ClientOption) + } + } + run(args[0].(*operations.CreateAzureClusterParams), variadicArgs...) + }) + return _c +} + +func (_c *MockDwClientService_CreateAzureCluster_Call) Return(_a0 *operations.CreateAzureClusterOK, _a1 error) *MockDwClientService_CreateAzureCluster_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDwClientService_CreateAzureCluster_Call) RunAndReturn(run func(*operations.CreateAzureClusterParams, ...operations.ClientOption) (*operations.CreateAzureClusterOK, error)) *MockDwClientService_CreateAzureCluster_Call { + _c.Call.Return(run) + return _c +} + +// CreateBackup provides a mock function with given fields: params, opts +func (_m *MockDwClientService) CreateBackup(params *operations.CreateBackupParams, opts ...operations.ClientOption) (*operations.CreateBackupOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for CreateBackup") + } + + var r0 *operations.CreateBackupOK + var r1 error + if rf, ok := ret.Get(0).(func(*operations.CreateBackupParams, ...operations.ClientOption) (*operations.CreateBackupOK, error)); ok { + return rf(params, opts...) + } + if rf, ok := ret.Get(0).(func(*operations.CreateBackupParams, ...operations.ClientOption) *operations.CreateBackupOK); ok { + r0 = rf(params, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*operations.CreateBackupOK) + } + } + + if rf, ok := ret.Get(1).(func(*operations.CreateBackupParams, ...operations.ClientOption) error); ok { + r1 = rf(params, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDwClientService_CreateBackup_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateBackup' +type MockDwClientService_CreateBackup_Call struct { + *mock.Call +} + +// CreateBackup is a helper method to define mock.On call +// - params *operations.CreateBackupParams +// - opts ...operations.ClientOption +func (_e *MockDwClientService_Expecter) CreateBackup(params interface{}, opts ...interface{}) *MockDwClientService_CreateBackup_Call { + return &MockDwClientService_CreateBackup_Call{Call: _e.mock.On("CreateBackup", + append([]interface{}{params}, opts...)...)} +} + +func (_c *MockDwClientService_CreateBackup_Call) Run(run func(params *operations.CreateBackupParams, opts ...operations.ClientOption)) *MockDwClientService_CreateBackup_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]operations.ClientOption, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(operations.ClientOption) + } + } + run(args[0].(*operations.CreateBackupParams), variadicArgs...) + }) + return _c +} + +func (_c *MockDwClientService_CreateBackup_Call) Return(_a0 *operations.CreateBackupOK, _a1 error) *MockDwClientService_CreateBackup_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDwClientService_CreateBackup_Call) RunAndReturn(run func(*operations.CreateBackupParams, ...operations.ClientOption) (*operations.CreateBackupOK, error)) *MockDwClientService_CreateBackup_Call { + _c.Call.Return(run) + return _c +} + +// CreateCluster provides a mock function with given fields: params, opts +func (_m *MockDwClientService) CreateCluster(params *operations.CreateClusterParams, opts ...operations.ClientOption) (*operations.CreateClusterOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for CreateCluster") + } + + var r0 *operations.CreateClusterOK + var r1 error + if rf, ok := ret.Get(0).(func(*operations.CreateClusterParams, ...operations.ClientOption) (*operations.CreateClusterOK, error)); ok { + return rf(params, opts...) + } + if rf, ok := ret.Get(0).(func(*operations.CreateClusterParams, ...operations.ClientOption) *operations.CreateClusterOK); ok { + r0 = rf(params, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*operations.CreateClusterOK) + } + } + + if rf, ok := ret.Get(1).(func(*operations.CreateClusterParams, ...operations.ClientOption) error); ok { + r1 = rf(params, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDwClientService_CreateCluster_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateCluster' +type MockDwClientService_CreateCluster_Call struct { + *mock.Call +} + +// CreateCluster is a helper method to define mock.On call +// - params *operations.CreateClusterParams +// - opts ...operations.ClientOption +func (_e *MockDwClientService_Expecter) CreateCluster(params interface{}, opts ...interface{}) *MockDwClientService_CreateCluster_Call { + return &MockDwClientService_CreateCluster_Call{Call: _e.mock.On("CreateCluster", + append([]interface{}{params}, opts...)...)} +} + +func (_c *MockDwClientService_CreateCluster_Call) Run(run func(params *operations.CreateClusterParams, opts ...operations.ClientOption)) *MockDwClientService_CreateCluster_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]operations.ClientOption, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(operations.ClientOption) + } + } + run(args[0].(*operations.CreateClusterParams), variadicArgs...) + }) + return _c +} + +func (_c *MockDwClientService_CreateCluster_Call) Return(_a0 *operations.CreateClusterOK, _a1 error) *MockDwClientService_CreateCluster_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDwClientService_CreateCluster_Call) RunAndReturn(run func(*operations.CreateClusterParams, ...operations.ClientOption) (*operations.CreateClusterOK, error)) *MockDwClientService_CreateCluster_Call { + _c.Call.Return(run) + return _c +} + +// CreateClusterDiagnosticDataJob provides a mock function with given fields: params, opts +func (_m *MockDwClientService) CreateClusterDiagnosticDataJob(params *operations.CreateClusterDiagnosticDataJobParams, opts ...operations.ClientOption) (*operations.CreateClusterDiagnosticDataJobOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for CreateClusterDiagnosticDataJob") + } + + var r0 *operations.CreateClusterDiagnosticDataJobOK + var r1 error + if rf, ok := ret.Get(0).(func(*operations.CreateClusterDiagnosticDataJobParams, ...operations.ClientOption) (*operations.CreateClusterDiagnosticDataJobOK, error)); ok { + return rf(params, opts...) + } + if rf, ok := ret.Get(0).(func(*operations.CreateClusterDiagnosticDataJobParams, ...operations.ClientOption) *operations.CreateClusterDiagnosticDataJobOK); ok { + r0 = rf(params, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*operations.CreateClusterDiagnosticDataJobOK) + } + } + + if rf, ok := ret.Get(1).(func(*operations.CreateClusterDiagnosticDataJobParams, ...operations.ClientOption) error); ok { + r1 = rf(params, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDwClientService_CreateClusterDiagnosticDataJob_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateClusterDiagnosticDataJob' +type MockDwClientService_CreateClusterDiagnosticDataJob_Call struct { + *mock.Call +} + +// CreateClusterDiagnosticDataJob is a helper method to define mock.On call +// - params *operations.CreateClusterDiagnosticDataJobParams +// - opts ...operations.ClientOption +func (_e *MockDwClientService_Expecter) CreateClusterDiagnosticDataJob(params interface{}, opts ...interface{}) *MockDwClientService_CreateClusterDiagnosticDataJob_Call { + return &MockDwClientService_CreateClusterDiagnosticDataJob_Call{Call: _e.mock.On("CreateClusterDiagnosticDataJob", + append([]interface{}{params}, opts...)...)} +} + +func (_c *MockDwClientService_CreateClusterDiagnosticDataJob_Call) Run(run func(params *operations.CreateClusterDiagnosticDataJobParams, opts ...operations.ClientOption)) *MockDwClientService_CreateClusterDiagnosticDataJob_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]operations.ClientOption, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(operations.ClientOption) + } + } + run(args[0].(*operations.CreateClusterDiagnosticDataJobParams), variadicArgs...) + }) + return _c +} + +func (_c *MockDwClientService_CreateClusterDiagnosticDataJob_Call) Return(_a0 *operations.CreateClusterDiagnosticDataJobOK, _a1 error) *MockDwClientService_CreateClusterDiagnosticDataJob_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDwClientService_CreateClusterDiagnosticDataJob_Call) RunAndReturn(run func(*operations.CreateClusterDiagnosticDataJobParams, ...operations.ClientOption) (*operations.CreateClusterDiagnosticDataJobOK, error)) *MockDwClientService_CreateClusterDiagnosticDataJob_Call { + _c.Call.Return(run) + return _c +} + +// CreateDataVisualization provides a mock function with given fields: params, opts +func (_m *MockDwClientService) CreateDataVisualization(params *operations.CreateDataVisualizationParams, opts ...operations.ClientOption) (*operations.CreateDataVisualizationOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for CreateDataVisualization") + } + + var r0 *operations.CreateDataVisualizationOK + var r1 error + if rf, ok := ret.Get(0).(func(*operations.CreateDataVisualizationParams, ...operations.ClientOption) (*operations.CreateDataVisualizationOK, error)); ok { + return rf(params, opts...) + } + if rf, ok := ret.Get(0).(func(*operations.CreateDataVisualizationParams, ...operations.ClientOption) *operations.CreateDataVisualizationOK); ok { + r0 = rf(params, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*operations.CreateDataVisualizationOK) + } + } + + if rf, ok := ret.Get(1).(func(*operations.CreateDataVisualizationParams, ...operations.ClientOption) error); ok { + r1 = rf(params, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDwClientService_CreateDataVisualization_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateDataVisualization' +type MockDwClientService_CreateDataVisualization_Call struct { + *mock.Call +} + +// CreateDataVisualization is a helper method to define mock.On call +// - params *operations.CreateDataVisualizationParams +// - opts ...operations.ClientOption +func (_e *MockDwClientService_Expecter) CreateDataVisualization(params interface{}, opts ...interface{}) *MockDwClientService_CreateDataVisualization_Call { + return &MockDwClientService_CreateDataVisualization_Call{Call: _e.mock.On("CreateDataVisualization", + append([]interface{}{params}, opts...)...)} +} + +func (_c *MockDwClientService_CreateDataVisualization_Call) Run(run func(params *operations.CreateDataVisualizationParams, opts ...operations.ClientOption)) *MockDwClientService_CreateDataVisualization_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]operations.ClientOption, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(operations.ClientOption) + } + } + run(args[0].(*operations.CreateDataVisualizationParams), variadicArgs...) + }) + return _c +} + +func (_c *MockDwClientService_CreateDataVisualization_Call) Return(_a0 *operations.CreateDataVisualizationOK, _a1 error) *MockDwClientService_CreateDataVisualization_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDwClientService_CreateDataVisualization_Call) RunAndReturn(run func(*operations.CreateDataVisualizationParams, ...operations.ClientOption) (*operations.CreateDataVisualizationOK, error)) *MockDwClientService_CreateDataVisualization_Call { + _c.Call.Return(run) + return _c +} + +// CreateDbc provides a mock function with given fields: params, opts +func (_m *MockDwClientService) CreateDbc(params *operations.CreateDbcParams, opts ...operations.ClientOption) (*operations.CreateDbcOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for CreateDbc") + } + + var r0 *operations.CreateDbcOK + var r1 error + if rf, ok := ret.Get(0).(func(*operations.CreateDbcParams, ...operations.ClientOption) (*operations.CreateDbcOK, error)); ok { + return rf(params, opts...) + } + if rf, ok := ret.Get(0).(func(*operations.CreateDbcParams, ...operations.ClientOption) *operations.CreateDbcOK); ok { + r0 = rf(params, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*operations.CreateDbcOK) + } + } + + if rf, ok := ret.Get(1).(func(*operations.CreateDbcParams, ...operations.ClientOption) error); ok { + r1 = rf(params, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDwClientService_CreateDbc_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateDbc' +type MockDwClientService_CreateDbc_Call struct { + *mock.Call +} + +// CreateDbc is a helper method to define mock.On call +// - params *operations.CreateDbcParams +// - opts ...operations.ClientOption +func (_e *MockDwClientService_Expecter) CreateDbc(params interface{}, opts ...interface{}) *MockDwClientService_CreateDbc_Call { + return &MockDwClientService_CreateDbc_Call{Call: _e.mock.On("CreateDbc", + append([]interface{}{params}, opts...)...)} +} + +func (_c *MockDwClientService_CreateDbc_Call) Run(run func(params *operations.CreateDbcParams, opts ...operations.ClientOption)) *MockDwClientService_CreateDbc_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]operations.ClientOption, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(operations.ClientOption) + } + } + run(args[0].(*operations.CreateDbcParams), variadicArgs...) + }) + return _c +} + +func (_c *MockDwClientService_CreateDbc_Call) Return(_a0 *operations.CreateDbcOK, _a1 error) *MockDwClientService_CreateDbc_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDwClientService_CreateDbc_Call) RunAndReturn(run func(*operations.CreateDbcParams, ...operations.ClientOption) (*operations.CreateDbcOK, error)) *MockDwClientService_CreateDbc_Call { + _c.Call.Return(run) + return _c +} + +// CreateDbcDiagnosticDataJob provides a mock function with given fields: params, opts +func (_m *MockDwClientService) CreateDbcDiagnosticDataJob(params *operations.CreateDbcDiagnosticDataJobParams, opts ...operations.ClientOption) (*operations.CreateDbcDiagnosticDataJobOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for CreateDbcDiagnosticDataJob") + } + + var r0 *operations.CreateDbcDiagnosticDataJobOK + var r1 error + if rf, ok := ret.Get(0).(func(*operations.CreateDbcDiagnosticDataJobParams, ...operations.ClientOption) (*operations.CreateDbcDiagnosticDataJobOK, error)); ok { + return rf(params, opts...) + } + if rf, ok := ret.Get(0).(func(*operations.CreateDbcDiagnosticDataJobParams, ...operations.ClientOption) *operations.CreateDbcDiagnosticDataJobOK); ok { + r0 = rf(params, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*operations.CreateDbcDiagnosticDataJobOK) + } + } + + if rf, ok := ret.Get(1).(func(*operations.CreateDbcDiagnosticDataJobParams, ...operations.ClientOption) error); ok { + r1 = rf(params, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDwClientService_CreateDbcDiagnosticDataJob_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateDbcDiagnosticDataJob' +type MockDwClientService_CreateDbcDiagnosticDataJob_Call struct { + *mock.Call +} + +// CreateDbcDiagnosticDataJob is a helper method to define mock.On call +// - params *operations.CreateDbcDiagnosticDataJobParams +// - opts ...operations.ClientOption +func (_e *MockDwClientService_Expecter) CreateDbcDiagnosticDataJob(params interface{}, opts ...interface{}) *MockDwClientService_CreateDbcDiagnosticDataJob_Call { + return &MockDwClientService_CreateDbcDiagnosticDataJob_Call{Call: _e.mock.On("CreateDbcDiagnosticDataJob", + append([]interface{}{params}, opts...)...)} +} + +func (_c *MockDwClientService_CreateDbcDiagnosticDataJob_Call) Run(run func(params *operations.CreateDbcDiagnosticDataJobParams, opts ...operations.ClientOption)) *MockDwClientService_CreateDbcDiagnosticDataJob_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]operations.ClientOption, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(operations.ClientOption) + } + } + run(args[0].(*operations.CreateDbcDiagnosticDataJobParams), variadicArgs...) + }) + return _c +} + +func (_c *MockDwClientService_CreateDbcDiagnosticDataJob_Call) Return(_a0 *operations.CreateDbcDiagnosticDataJobOK, _a1 error) *MockDwClientService_CreateDbcDiagnosticDataJob_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDwClientService_CreateDbcDiagnosticDataJob_Call) RunAndReturn(run func(*operations.CreateDbcDiagnosticDataJobParams, ...operations.ClientOption) (*operations.CreateDbcDiagnosticDataJobOK, error)) *MockDwClientService_CreateDbcDiagnosticDataJob_Call { + _c.Call.Return(run) + return _c +} + +// CreatePrivateCluster provides a mock function with given fields: params, opts +func (_m *MockDwClientService) CreatePrivateCluster(params *operations.CreatePrivateClusterParams, opts ...operations.ClientOption) (*operations.CreatePrivateClusterOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for CreatePrivateCluster") + } + + var r0 *operations.CreatePrivateClusterOK + var r1 error + if rf, ok := ret.Get(0).(func(*operations.CreatePrivateClusterParams, ...operations.ClientOption) (*operations.CreatePrivateClusterOK, error)); ok { + return rf(params, opts...) + } + if rf, ok := ret.Get(0).(func(*operations.CreatePrivateClusterParams, ...operations.ClientOption) *operations.CreatePrivateClusterOK); ok { + r0 = rf(params, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*operations.CreatePrivateClusterOK) + } + } + + if rf, ok := ret.Get(1).(func(*operations.CreatePrivateClusterParams, ...operations.ClientOption) error); ok { + r1 = rf(params, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDwClientService_CreatePrivateCluster_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreatePrivateCluster' +type MockDwClientService_CreatePrivateCluster_Call struct { + *mock.Call +} + +// CreatePrivateCluster is a helper method to define mock.On call +// - params *operations.CreatePrivateClusterParams +// - opts ...operations.ClientOption +func (_e *MockDwClientService_Expecter) CreatePrivateCluster(params interface{}, opts ...interface{}) *MockDwClientService_CreatePrivateCluster_Call { + return &MockDwClientService_CreatePrivateCluster_Call{Call: _e.mock.On("CreatePrivateCluster", + append([]interface{}{params}, opts...)...)} +} + +func (_c *MockDwClientService_CreatePrivateCluster_Call) Run(run func(params *operations.CreatePrivateClusterParams, opts ...operations.ClientOption)) *MockDwClientService_CreatePrivateCluster_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]operations.ClientOption, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(operations.ClientOption) + } + } + run(args[0].(*operations.CreatePrivateClusterParams), variadicArgs...) + }) + return _c +} + +func (_c *MockDwClientService_CreatePrivateCluster_Call) Return(_a0 *operations.CreatePrivateClusterOK, _a1 error) *MockDwClientService_CreatePrivateCluster_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDwClientService_CreatePrivateCluster_Call) RunAndReturn(run func(*operations.CreatePrivateClusterParams, ...operations.ClientOption) (*operations.CreatePrivateClusterOK, error)) *MockDwClientService_CreatePrivateCluster_Call { + _c.Call.Return(run) + return _c +} + +// CreateVw provides a mock function with given fields: params, opts +func (_m *MockDwClientService) CreateVw(params *operations.CreateVwParams, opts ...operations.ClientOption) (*operations.CreateVwOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for CreateVw") + } + + var r0 *operations.CreateVwOK + var r1 error + if rf, ok := ret.Get(0).(func(*operations.CreateVwParams, ...operations.ClientOption) (*operations.CreateVwOK, error)); ok { + return rf(params, opts...) + } + if rf, ok := ret.Get(0).(func(*operations.CreateVwParams, ...operations.ClientOption) *operations.CreateVwOK); ok { + r0 = rf(params, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*operations.CreateVwOK) + } + } + + if rf, ok := ret.Get(1).(func(*operations.CreateVwParams, ...operations.ClientOption) error); ok { + r1 = rf(params, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDwClientService_CreateVw_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateVw' +type MockDwClientService_CreateVw_Call struct { + *mock.Call +} + +// CreateVw is a helper method to define mock.On call +// - params *operations.CreateVwParams +// - opts ...operations.ClientOption +func (_e *MockDwClientService_Expecter) CreateVw(params interface{}, opts ...interface{}) *MockDwClientService_CreateVw_Call { + return &MockDwClientService_CreateVw_Call{Call: _e.mock.On("CreateVw", + append([]interface{}{params}, opts...)...)} +} + +func (_c *MockDwClientService_CreateVw_Call) Run(run func(params *operations.CreateVwParams, opts ...operations.ClientOption)) *MockDwClientService_CreateVw_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]operations.ClientOption, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(operations.ClientOption) + } + } + run(args[0].(*operations.CreateVwParams), variadicArgs...) + }) + return _c +} + +func (_c *MockDwClientService_CreateVw_Call) Return(_a0 *operations.CreateVwOK, _a1 error) *MockDwClientService_CreateVw_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDwClientService_CreateVw_Call) RunAndReturn(run func(*operations.CreateVwParams, ...operations.ClientOption) (*operations.CreateVwOK, error)) *MockDwClientService_CreateVw_Call { + _c.Call.Return(run) + return _c +} + +// CreateVwDiagnosticDataJob provides a mock function with given fields: params, opts +func (_m *MockDwClientService) CreateVwDiagnosticDataJob(params *operations.CreateVwDiagnosticDataJobParams, opts ...operations.ClientOption) (*operations.CreateVwDiagnosticDataJobOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for CreateVwDiagnosticDataJob") + } + + var r0 *operations.CreateVwDiagnosticDataJobOK + var r1 error + if rf, ok := ret.Get(0).(func(*operations.CreateVwDiagnosticDataJobParams, ...operations.ClientOption) (*operations.CreateVwDiagnosticDataJobOK, error)); ok { + return rf(params, opts...) + } + if rf, ok := ret.Get(0).(func(*operations.CreateVwDiagnosticDataJobParams, ...operations.ClientOption) *operations.CreateVwDiagnosticDataJobOK); ok { + r0 = rf(params, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*operations.CreateVwDiagnosticDataJobOK) + } + } + + if rf, ok := ret.Get(1).(func(*operations.CreateVwDiagnosticDataJobParams, ...operations.ClientOption) error); ok { + r1 = rf(params, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDwClientService_CreateVwDiagnosticDataJob_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateVwDiagnosticDataJob' +type MockDwClientService_CreateVwDiagnosticDataJob_Call struct { + *mock.Call +} + +// CreateVwDiagnosticDataJob is a helper method to define mock.On call +// - params *operations.CreateVwDiagnosticDataJobParams +// - opts ...operations.ClientOption +func (_e *MockDwClientService_Expecter) CreateVwDiagnosticDataJob(params interface{}, opts ...interface{}) *MockDwClientService_CreateVwDiagnosticDataJob_Call { + return &MockDwClientService_CreateVwDiagnosticDataJob_Call{Call: _e.mock.On("CreateVwDiagnosticDataJob", + append([]interface{}{params}, opts...)...)} +} + +func (_c *MockDwClientService_CreateVwDiagnosticDataJob_Call) Run(run func(params *operations.CreateVwDiagnosticDataJobParams, opts ...operations.ClientOption)) *MockDwClientService_CreateVwDiagnosticDataJob_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]operations.ClientOption, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(operations.ClientOption) + } + } + run(args[0].(*operations.CreateVwDiagnosticDataJobParams), variadicArgs...) + }) + return _c +} + +func (_c *MockDwClientService_CreateVwDiagnosticDataJob_Call) Return(_a0 *operations.CreateVwDiagnosticDataJobOK, _a1 error) *MockDwClientService_CreateVwDiagnosticDataJob_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDwClientService_CreateVwDiagnosticDataJob_Call) RunAndReturn(run func(*operations.CreateVwDiagnosticDataJobParams, ...operations.ClientOption) (*operations.CreateVwDiagnosticDataJobOK, error)) *MockDwClientService_CreateVwDiagnosticDataJob_Call { + _c.Call.Return(run) + return _c +} + +// DeleteBackup provides a mock function with given fields: params, opts +func (_m *MockDwClientService) DeleteBackup(params *operations.DeleteBackupParams, opts ...operations.ClientOption) (*operations.DeleteBackupOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for DeleteBackup") + } + + var r0 *operations.DeleteBackupOK + var r1 error + if rf, ok := ret.Get(0).(func(*operations.DeleteBackupParams, ...operations.ClientOption) (*operations.DeleteBackupOK, error)); ok { + return rf(params, opts...) + } + if rf, ok := ret.Get(0).(func(*operations.DeleteBackupParams, ...operations.ClientOption) *operations.DeleteBackupOK); ok { + r0 = rf(params, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*operations.DeleteBackupOK) + } + } + + if rf, ok := ret.Get(1).(func(*operations.DeleteBackupParams, ...operations.ClientOption) error); ok { + r1 = rf(params, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDwClientService_DeleteBackup_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteBackup' +type MockDwClientService_DeleteBackup_Call struct { + *mock.Call +} + +// DeleteBackup is a helper method to define mock.On call +// - params *operations.DeleteBackupParams +// - opts ...operations.ClientOption +func (_e *MockDwClientService_Expecter) DeleteBackup(params interface{}, opts ...interface{}) *MockDwClientService_DeleteBackup_Call { + return &MockDwClientService_DeleteBackup_Call{Call: _e.mock.On("DeleteBackup", + append([]interface{}{params}, opts...)...)} +} + +func (_c *MockDwClientService_DeleteBackup_Call) Run(run func(params *operations.DeleteBackupParams, opts ...operations.ClientOption)) *MockDwClientService_DeleteBackup_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]operations.ClientOption, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(operations.ClientOption) + } + } + run(args[0].(*operations.DeleteBackupParams), variadicArgs...) + }) + return _c +} + +func (_c *MockDwClientService_DeleteBackup_Call) Return(_a0 *operations.DeleteBackupOK, _a1 error) *MockDwClientService_DeleteBackup_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDwClientService_DeleteBackup_Call) RunAndReturn(run func(*operations.DeleteBackupParams, ...operations.ClientOption) (*operations.DeleteBackupOK, error)) *MockDwClientService_DeleteBackup_Call { + _c.Call.Return(run) + return _c +} + +// DeleteCluster provides a mock function with given fields: params, opts +func (_m *MockDwClientService) DeleteCluster(params *operations.DeleteClusterParams, opts ...operations.ClientOption) (*operations.DeleteClusterOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for DeleteCluster") + } + + var r0 *operations.DeleteClusterOK + var r1 error + if rf, ok := ret.Get(0).(func(*operations.DeleteClusterParams, ...operations.ClientOption) (*operations.DeleteClusterOK, error)); ok { + return rf(params, opts...) + } + if rf, ok := ret.Get(0).(func(*operations.DeleteClusterParams, ...operations.ClientOption) *operations.DeleteClusterOK); ok { + r0 = rf(params, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*operations.DeleteClusterOK) + } + } + + if rf, ok := ret.Get(1).(func(*operations.DeleteClusterParams, ...operations.ClientOption) error); ok { + r1 = rf(params, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDwClientService_DeleteCluster_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteCluster' +type MockDwClientService_DeleteCluster_Call struct { + *mock.Call +} + +// DeleteCluster is a helper method to define mock.On call +// - params *operations.DeleteClusterParams +// - opts ...operations.ClientOption +func (_e *MockDwClientService_Expecter) DeleteCluster(params interface{}, opts ...interface{}) *MockDwClientService_DeleteCluster_Call { + return &MockDwClientService_DeleteCluster_Call{Call: _e.mock.On("DeleteCluster", + append([]interface{}{params}, opts...)...)} +} + +func (_c *MockDwClientService_DeleteCluster_Call) Run(run func(params *operations.DeleteClusterParams, opts ...operations.ClientOption)) *MockDwClientService_DeleteCluster_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]operations.ClientOption, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(operations.ClientOption) + } + } + run(args[0].(*operations.DeleteClusterParams), variadicArgs...) + }) + return _c +} + +func (_c *MockDwClientService_DeleteCluster_Call) Return(_a0 *operations.DeleteClusterOK, _a1 error) *MockDwClientService_DeleteCluster_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDwClientService_DeleteCluster_Call) RunAndReturn(run func(*operations.DeleteClusterParams, ...operations.ClientOption) (*operations.DeleteClusterOK, error)) *MockDwClientService_DeleteCluster_Call { + _c.Call.Return(run) + return _c +} + +// DeleteClusterDiagnosticDataJob provides a mock function with given fields: params, opts +func (_m *MockDwClientService) DeleteClusterDiagnosticDataJob(params *operations.DeleteClusterDiagnosticDataJobParams, opts ...operations.ClientOption) (*operations.DeleteClusterDiagnosticDataJobOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for DeleteClusterDiagnosticDataJob") + } + + var r0 *operations.DeleteClusterDiagnosticDataJobOK + var r1 error + if rf, ok := ret.Get(0).(func(*operations.DeleteClusterDiagnosticDataJobParams, ...operations.ClientOption) (*operations.DeleteClusterDiagnosticDataJobOK, error)); ok { + return rf(params, opts...) + } + if rf, ok := ret.Get(0).(func(*operations.DeleteClusterDiagnosticDataJobParams, ...operations.ClientOption) *operations.DeleteClusterDiagnosticDataJobOK); ok { + r0 = rf(params, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*operations.DeleteClusterDiagnosticDataJobOK) + } + } + + if rf, ok := ret.Get(1).(func(*operations.DeleteClusterDiagnosticDataJobParams, ...operations.ClientOption) error); ok { + r1 = rf(params, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDwClientService_DeleteClusterDiagnosticDataJob_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteClusterDiagnosticDataJob' +type MockDwClientService_DeleteClusterDiagnosticDataJob_Call struct { + *mock.Call +} + +// DeleteClusterDiagnosticDataJob is a helper method to define mock.On call +// - params *operations.DeleteClusterDiagnosticDataJobParams +// - opts ...operations.ClientOption +func (_e *MockDwClientService_Expecter) DeleteClusterDiagnosticDataJob(params interface{}, opts ...interface{}) *MockDwClientService_DeleteClusterDiagnosticDataJob_Call { + return &MockDwClientService_DeleteClusterDiagnosticDataJob_Call{Call: _e.mock.On("DeleteClusterDiagnosticDataJob", + append([]interface{}{params}, opts...)...)} +} + +func (_c *MockDwClientService_DeleteClusterDiagnosticDataJob_Call) Run(run func(params *operations.DeleteClusterDiagnosticDataJobParams, opts ...operations.ClientOption)) *MockDwClientService_DeleteClusterDiagnosticDataJob_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]operations.ClientOption, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(operations.ClientOption) + } + } + run(args[0].(*operations.DeleteClusterDiagnosticDataJobParams), variadicArgs...) + }) + return _c +} + +func (_c *MockDwClientService_DeleteClusterDiagnosticDataJob_Call) Return(_a0 *operations.DeleteClusterDiagnosticDataJobOK, _a1 error) *MockDwClientService_DeleteClusterDiagnosticDataJob_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDwClientService_DeleteClusterDiagnosticDataJob_Call) RunAndReturn(run func(*operations.DeleteClusterDiagnosticDataJobParams, ...operations.ClientOption) (*operations.DeleteClusterDiagnosticDataJobOK, error)) *MockDwClientService_DeleteClusterDiagnosticDataJob_Call { + _c.Call.Return(run) + return _c +} + +// DeleteDataVisualization provides a mock function with given fields: params, opts +func (_m *MockDwClientService) DeleteDataVisualization(params *operations.DeleteDataVisualizationParams, opts ...operations.ClientOption) (*operations.DeleteDataVisualizationOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for DeleteDataVisualization") + } + + var r0 *operations.DeleteDataVisualizationOK + var r1 error + if rf, ok := ret.Get(0).(func(*operations.DeleteDataVisualizationParams, ...operations.ClientOption) (*operations.DeleteDataVisualizationOK, error)); ok { + return rf(params, opts...) + } + if rf, ok := ret.Get(0).(func(*operations.DeleteDataVisualizationParams, ...operations.ClientOption) *operations.DeleteDataVisualizationOK); ok { + r0 = rf(params, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*operations.DeleteDataVisualizationOK) + } + } + + if rf, ok := ret.Get(1).(func(*operations.DeleteDataVisualizationParams, ...operations.ClientOption) error); ok { + r1 = rf(params, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDwClientService_DeleteDataVisualization_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteDataVisualization' +type MockDwClientService_DeleteDataVisualization_Call struct { + *mock.Call +} + +// DeleteDataVisualization is a helper method to define mock.On call +// - params *operations.DeleteDataVisualizationParams +// - opts ...operations.ClientOption +func (_e *MockDwClientService_Expecter) DeleteDataVisualization(params interface{}, opts ...interface{}) *MockDwClientService_DeleteDataVisualization_Call { + return &MockDwClientService_DeleteDataVisualization_Call{Call: _e.mock.On("DeleteDataVisualization", + append([]interface{}{params}, opts...)...)} +} + +func (_c *MockDwClientService_DeleteDataVisualization_Call) Run(run func(params *operations.DeleteDataVisualizationParams, opts ...operations.ClientOption)) *MockDwClientService_DeleteDataVisualization_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]operations.ClientOption, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(operations.ClientOption) + } + } + run(args[0].(*operations.DeleteDataVisualizationParams), variadicArgs...) + }) + return _c +} + +func (_c *MockDwClientService_DeleteDataVisualization_Call) Return(_a0 *operations.DeleteDataVisualizationOK, _a1 error) *MockDwClientService_DeleteDataVisualization_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDwClientService_DeleteDataVisualization_Call) RunAndReturn(run func(*operations.DeleteDataVisualizationParams, ...operations.ClientOption) (*operations.DeleteDataVisualizationOK, error)) *MockDwClientService_DeleteDataVisualization_Call { + _c.Call.Return(run) + return _c +} + +// DeleteDbc provides a mock function with given fields: params, opts +func (_m *MockDwClientService) DeleteDbc(params *operations.DeleteDbcParams, opts ...operations.ClientOption) (*operations.DeleteDbcOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for DeleteDbc") + } + + var r0 *operations.DeleteDbcOK + var r1 error + if rf, ok := ret.Get(0).(func(*operations.DeleteDbcParams, ...operations.ClientOption) (*operations.DeleteDbcOK, error)); ok { + return rf(params, opts...) + } + if rf, ok := ret.Get(0).(func(*operations.DeleteDbcParams, ...operations.ClientOption) *operations.DeleteDbcOK); ok { + r0 = rf(params, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*operations.DeleteDbcOK) + } + } + + if rf, ok := ret.Get(1).(func(*operations.DeleteDbcParams, ...operations.ClientOption) error); ok { + r1 = rf(params, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDwClientService_DeleteDbc_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteDbc' +type MockDwClientService_DeleteDbc_Call struct { + *mock.Call +} + +// DeleteDbc is a helper method to define mock.On call +// - params *operations.DeleteDbcParams +// - opts ...operations.ClientOption +func (_e *MockDwClientService_Expecter) DeleteDbc(params interface{}, opts ...interface{}) *MockDwClientService_DeleteDbc_Call { + return &MockDwClientService_DeleteDbc_Call{Call: _e.mock.On("DeleteDbc", + append([]interface{}{params}, opts...)...)} +} + +func (_c *MockDwClientService_DeleteDbc_Call) Run(run func(params *operations.DeleteDbcParams, opts ...operations.ClientOption)) *MockDwClientService_DeleteDbc_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]operations.ClientOption, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(operations.ClientOption) + } + } + run(args[0].(*operations.DeleteDbcParams), variadicArgs...) + }) + return _c +} + +func (_c *MockDwClientService_DeleteDbc_Call) Return(_a0 *operations.DeleteDbcOK, _a1 error) *MockDwClientService_DeleteDbc_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDwClientService_DeleteDbc_Call) RunAndReturn(run func(*operations.DeleteDbcParams, ...operations.ClientOption) (*operations.DeleteDbcOK, error)) *MockDwClientService_DeleteDbc_Call { + _c.Call.Return(run) + return _c +} + +// DeleteDbcDiagnosticDataJob provides a mock function with given fields: params, opts +func (_m *MockDwClientService) DeleteDbcDiagnosticDataJob(params *operations.DeleteDbcDiagnosticDataJobParams, opts ...operations.ClientOption) (*operations.DeleteDbcDiagnosticDataJobOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for DeleteDbcDiagnosticDataJob") + } + + var r0 *operations.DeleteDbcDiagnosticDataJobOK + var r1 error + if rf, ok := ret.Get(0).(func(*operations.DeleteDbcDiagnosticDataJobParams, ...operations.ClientOption) (*operations.DeleteDbcDiagnosticDataJobOK, error)); ok { + return rf(params, opts...) + } + if rf, ok := ret.Get(0).(func(*operations.DeleteDbcDiagnosticDataJobParams, ...operations.ClientOption) *operations.DeleteDbcDiagnosticDataJobOK); ok { + r0 = rf(params, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*operations.DeleteDbcDiagnosticDataJobOK) + } + } + + if rf, ok := ret.Get(1).(func(*operations.DeleteDbcDiagnosticDataJobParams, ...operations.ClientOption) error); ok { + r1 = rf(params, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDwClientService_DeleteDbcDiagnosticDataJob_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteDbcDiagnosticDataJob' +type MockDwClientService_DeleteDbcDiagnosticDataJob_Call struct { + *mock.Call +} + +// DeleteDbcDiagnosticDataJob is a helper method to define mock.On call +// - params *operations.DeleteDbcDiagnosticDataJobParams +// - opts ...operations.ClientOption +func (_e *MockDwClientService_Expecter) DeleteDbcDiagnosticDataJob(params interface{}, opts ...interface{}) *MockDwClientService_DeleteDbcDiagnosticDataJob_Call { + return &MockDwClientService_DeleteDbcDiagnosticDataJob_Call{Call: _e.mock.On("DeleteDbcDiagnosticDataJob", + append([]interface{}{params}, opts...)...)} +} + +func (_c *MockDwClientService_DeleteDbcDiagnosticDataJob_Call) Run(run func(params *operations.DeleteDbcDiagnosticDataJobParams, opts ...operations.ClientOption)) *MockDwClientService_DeleteDbcDiagnosticDataJob_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]operations.ClientOption, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(operations.ClientOption) + } + } + run(args[0].(*operations.DeleteDbcDiagnosticDataJobParams), variadicArgs...) + }) + return _c +} + +func (_c *MockDwClientService_DeleteDbcDiagnosticDataJob_Call) Return(_a0 *operations.DeleteDbcDiagnosticDataJobOK, _a1 error) *MockDwClientService_DeleteDbcDiagnosticDataJob_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDwClientService_DeleteDbcDiagnosticDataJob_Call) RunAndReturn(run func(*operations.DeleteDbcDiagnosticDataJobParams, ...operations.ClientOption) (*operations.DeleteDbcDiagnosticDataJobOK, error)) *MockDwClientService_DeleteDbcDiagnosticDataJob_Call { + _c.Call.Return(run) + return _c +} + +// DeleteUser provides a mock function with given fields: params, opts +func (_m *MockDwClientService) DeleteUser(params *operations.DeleteUserParams, opts ...operations.ClientOption) (*operations.DeleteUserOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for DeleteUser") + } + + var r0 *operations.DeleteUserOK + var r1 error + if rf, ok := ret.Get(0).(func(*operations.DeleteUserParams, ...operations.ClientOption) (*operations.DeleteUserOK, error)); ok { + return rf(params, opts...) + } + if rf, ok := ret.Get(0).(func(*operations.DeleteUserParams, ...operations.ClientOption) *operations.DeleteUserOK); ok { + r0 = rf(params, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*operations.DeleteUserOK) + } + } + + if rf, ok := ret.Get(1).(func(*operations.DeleteUserParams, ...operations.ClientOption) error); ok { + r1 = rf(params, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDwClientService_DeleteUser_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteUser' +type MockDwClientService_DeleteUser_Call struct { + *mock.Call +} + +// DeleteUser is a helper method to define mock.On call +// - params *operations.DeleteUserParams +// - opts ...operations.ClientOption +func (_e *MockDwClientService_Expecter) DeleteUser(params interface{}, opts ...interface{}) *MockDwClientService_DeleteUser_Call { + return &MockDwClientService_DeleteUser_Call{Call: _e.mock.On("DeleteUser", + append([]interface{}{params}, opts...)...)} +} + +func (_c *MockDwClientService_DeleteUser_Call) Run(run func(params *operations.DeleteUserParams, opts ...operations.ClientOption)) *MockDwClientService_DeleteUser_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]operations.ClientOption, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(operations.ClientOption) + } + } + run(args[0].(*operations.DeleteUserParams), variadicArgs...) + }) + return _c +} + +func (_c *MockDwClientService_DeleteUser_Call) Return(_a0 *operations.DeleteUserOK, _a1 error) *MockDwClientService_DeleteUser_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDwClientService_DeleteUser_Call) RunAndReturn(run func(*operations.DeleteUserParams, ...operations.ClientOption) (*operations.DeleteUserOK, error)) *MockDwClientService_DeleteUser_Call { + _c.Call.Return(run) + return _c +} + +// DeleteVw provides a mock function with given fields: params, opts +func (_m *MockDwClientService) DeleteVw(params *operations.DeleteVwParams, opts ...operations.ClientOption) (*operations.DeleteVwOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for DeleteVw") + } + + var r0 *operations.DeleteVwOK + var r1 error + if rf, ok := ret.Get(0).(func(*operations.DeleteVwParams, ...operations.ClientOption) (*operations.DeleteVwOK, error)); ok { + return rf(params, opts...) + } + if rf, ok := ret.Get(0).(func(*operations.DeleteVwParams, ...operations.ClientOption) *operations.DeleteVwOK); ok { + r0 = rf(params, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*operations.DeleteVwOK) + } + } + + if rf, ok := ret.Get(1).(func(*operations.DeleteVwParams, ...operations.ClientOption) error); ok { + r1 = rf(params, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDwClientService_DeleteVw_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteVw' +type MockDwClientService_DeleteVw_Call struct { + *mock.Call +} + +// DeleteVw is a helper method to define mock.On call +// - params *operations.DeleteVwParams +// - opts ...operations.ClientOption +func (_e *MockDwClientService_Expecter) DeleteVw(params interface{}, opts ...interface{}) *MockDwClientService_DeleteVw_Call { + return &MockDwClientService_DeleteVw_Call{Call: _e.mock.On("DeleteVw", + append([]interface{}{params}, opts...)...)} +} + +func (_c *MockDwClientService_DeleteVw_Call) Run(run func(params *operations.DeleteVwParams, opts ...operations.ClientOption)) *MockDwClientService_DeleteVw_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]operations.ClientOption, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(operations.ClientOption) + } + } + run(args[0].(*operations.DeleteVwParams), variadicArgs...) + }) + return _c +} + +func (_c *MockDwClientService_DeleteVw_Call) Return(_a0 *operations.DeleteVwOK, _a1 error) *MockDwClientService_DeleteVw_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDwClientService_DeleteVw_Call) RunAndReturn(run func(*operations.DeleteVwParams, ...operations.ClientOption) (*operations.DeleteVwOK, error)) *MockDwClientService_DeleteVw_Call { + _c.Call.Return(run) + return _c +} + +// DeleteVwDiagnosticDataJob provides a mock function with given fields: params, opts +func (_m *MockDwClientService) DeleteVwDiagnosticDataJob(params *operations.DeleteVwDiagnosticDataJobParams, opts ...operations.ClientOption) (*operations.DeleteVwDiagnosticDataJobOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for DeleteVwDiagnosticDataJob") + } + + var r0 *operations.DeleteVwDiagnosticDataJobOK + var r1 error + if rf, ok := ret.Get(0).(func(*operations.DeleteVwDiagnosticDataJobParams, ...operations.ClientOption) (*operations.DeleteVwDiagnosticDataJobOK, error)); ok { + return rf(params, opts...) + } + if rf, ok := ret.Get(0).(func(*operations.DeleteVwDiagnosticDataJobParams, ...operations.ClientOption) *operations.DeleteVwDiagnosticDataJobOK); ok { + r0 = rf(params, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*operations.DeleteVwDiagnosticDataJobOK) + } + } + + if rf, ok := ret.Get(1).(func(*operations.DeleteVwDiagnosticDataJobParams, ...operations.ClientOption) error); ok { + r1 = rf(params, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDwClientService_DeleteVwDiagnosticDataJob_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteVwDiagnosticDataJob' +type MockDwClientService_DeleteVwDiagnosticDataJob_Call struct { + *mock.Call +} + +// DeleteVwDiagnosticDataJob is a helper method to define mock.On call +// - params *operations.DeleteVwDiagnosticDataJobParams +// - opts ...operations.ClientOption +func (_e *MockDwClientService_Expecter) DeleteVwDiagnosticDataJob(params interface{}, opts ...interface{}) *MockDwClientService_DeleteVwDiagnosticDataJob_Call { + return &MockDwClientService_DeleteVwDiagnosticDataJob_Call{Call: _e.mock.On("DeleteVwDiagnosticDataJob", + append([]interface{}{params}, opts...)...)} +} + +func (_c *MockDwClientService_DeleteVwDiagnosticDataJob_Call) Run(run func(params *operations.DeleteVwDiagnosticDataJobParams, opts ...operations.ClientOption)) *MockDwClientService_DeleteVwDiagnosticDataJob_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]operations.ClientOption, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(operations.ClientOption) + } + } + run(args[0].(*operations.DeleteVwDiagnosticDataJobParams), variadicArgs...) + }) + return _c +} + +func (_c *MockDwClientService_DeleteVwDiagnosticDataJob_Call) Return(_a0 *operations.DeleteVwDiagnosticDataJobOK, _a1 error) *MockDwClientService_DeleteVwDiagnosticDataJob_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDwClientService_DeleteVwDiagnosticDataJob_Call) RunAndReturn(run func(*operations.DeleteVwDiagnosticDataJobParams, ...operations.ClientOption) (*operations.DeleteVwDiagnosticDataJobOK, error)) *MockDwClientService_DeleteVwDiagnosticDataJob_Call { + _c.Call.Return(run) + return _c +} + +// DescribeAllowedInstanceTypes provides a mock function with given fields: params, opts +func (_m *MockDwClientService) DescribeAllowedInstanceTypes(params *operations.DescribeAllowedInstanceTypesParams, opts ...operations.ClientOption) (*operations.DescribeAllowedInstanceTypesOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for DescribeAllowedInstanceTypes") + } + + var r0 *operations.DescribeAllowedInstanceTypesOK + var r1 error + if rf, ok := ret.Get(0).(func(*operations.DescribeAllowedInstanceTypesParams, ...operations.ClientOption) (*operations.DescribeAllowedInstanceTypesOK, error)); ok { + return rf(params, opts...) + } + if rf, ok := ret.Get(0).(func(*operations.DescribeAllowedInstanceTypesParams, ...operations.ClientOption) *operations.DescribeAllowedInstanceTypesOK); ok { + r0 = rf(params, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*operations.DescribeAllowedInstanceTypesOK) + } + } + + if rf, ok := ret.Get(1).(func(*operations.DescribeAllowedInstanceTypesParams, ...operations.ClientOption) error); ok { + r1 = rf(params, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDwClientService_DescribeAllowedInstanceTypes_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeAllowedInstanceTypes' +type MockDwClientService_DescribeAllowedInstanceTypes_Call struct { + *mock.Call +} + +// DescribeAllowedInstanceTypes is a helper method to define mock.On call +// - params *operations.DescribeAllowedInstanceTypesParams +// - opts ...operations.ClientOption +func (_e *MockDwClientService_Expecter) DescribeAllowedInstanceTypes(params interface{}, opts ...interface{}) *MockDwClientService_DescribeAllowedInstanceTypes_Call { + return &MockDwClientService_DescribeAllowedInstanceTypes_Call{Call: _e.mock.On("DescribeAllowedInstanceTypes", + append([]interface{}{params}, opts...)...)} +} + +func (_c *MockDwClientService_DescribeAllowedInstanceTypes_Call) Run(run func(params *operations.DescribeAllowedInstanceTypesParams, opts ...operations.ClientOption)) *MockDwClientService_DescribeAllowedInstanceTypes_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]operations.ClientOption, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(operations.ClientOption) + } + } + run(args[0].(*operations.DescribeAllowedInstanceTypesParams), variadicArgs...) + }) + return _c +} + +func (_c *MockDwClientService_DescribeAllowedInstanceTypes_Call) Return(_a0 *operations.DescribeAllowedInstanceTypesOK, _a1 error) *MockDwClientService_DescribeAllowedInstanceTypes_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDwClientService_DescribeAllowedInstanceTypes_Call) RunAndReturn(run func(*operations.DescribeAllowedInstanceTypesParams, ...operations.ClientOption) (*operations.DescribeAllowedInstanceTypesOK, error)) *MockDwClientService_DescribeAllowedInstanceTypes_Call { + _c.Call.Return(run) + return _c +} + +// DescribeBackup provides a mock function with given fields: params, opts +func (_m *MockDwClientService) DescribeBackup(params *operations.DescribeBackupParams, opts ...operations.ClientOption) (*operations.DescribeBackupOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for DescribeBackup") + } + + var r0 *operations.DescribeBackupOK + var r1 error + if rf, ok := ret.Get(0).(func(*operations.DescribeBackupParams, ...operations.ClientOption) (*operations.DescribeBackupOK, error)); ok { + return rf(params, opts...) + } + if rf, ok := ret.Get(0).(func(*operations.DescribeBackupParams, ...operations.ClientOption) *operations.DescribeBackupOK); ok { + r0 = rf(params, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*operations.DescribeBackupOK) + } + } + + if rf, ok := ret.Get(1).(func(*operations.DescribeBackupParams, ...operations.ClientOption) error); ok { + r1 = rf(params, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDwClientService_DescribeBackup_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeBackup' +type MockDwClientService_DescribeBackup_Call struct { + *mock.Call +} + +// DescribeBackup is a helper method to define mock.On call +// - params *operations.DescribeBackupParams +// - opts ...operations.ClientOption +func (_e *MockDwClientService_Expecter) DescribeBackup(params interface{}, opts ...interface{}) *MockDwClientService_DescribeBackup_Call { + return &MockDwClientService_DescribeBackup_Call{Call: _e.mock.On("DescribeBackup", + append([]interface{}{params}, opts...)...)} +} + +func (_c *MockDwClientService_DescribeBackup_Call) Run(run func(params *operations.DescribeBackupParams, opts ...operations.ClientOption)) *MockDwClientService_DescribeBackup_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]operations.ClientOption, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(operations.ClientOption) + } + } + run(args[0].(*operations.DescribeBackupParams), variadicArgs...) + }) + return _c +} + +func (_c *MockDwClientService_DescribeBackup_Call) Return(_a0 *operations.DescribeBackupOK, _a1 error) *MockDwClientService_DescribeBackup_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDwClientService_DescribeBackup_Call) RunAndReturn(run func(*operations.DescribeBackupParams, ...operations.ClientOption) (*operations.DescribeBackupOK, error)) *MockDwClientService_DescribeBackup_Call { + _c.Call.Return(run) + return _c +} + +// DescribeCluster provides a mock function with given fields: params, opts +func (_m *MockDwClientService) DescribeCluster(params *operations.DescribeClusterParams, opts ...operations.ClientOption) (*operations.DescribeClusterOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for DescribeCluster") + } + + var r0 *operations.DescribeClusterOK + var r1 error + if rf, ok := ret.Get(0).(func(*operations.DescribeClusterParams, ...operations.ClientOption) (*operations.DescribeClusterOK, error)); ok { + return rf(params, opts...) + } + if rf, ok := ret.Get(0).(func(*operations.DescribeClusterParams, ...operations.ClientOption) *operations.DescribeClusterOK); ok { + r0 = rf(params, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*operations.DescribeClusterOK) + } + } + + if rf, ok := ret.Get(1).(func(*operations.DescribeClusterParams, ...operations.ClientOption) error); ok { + r1 = rf(params, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDwClientService_DescribeCluster_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeCluster' +type MockDwClientService_DescribeCluster_Call struct { + *mock.Call +} + +// DescribeCluster is a helper method to define mock.On call +// - params *operations.DescribeClusterParams +// - opts ...operations.ClientOption +func (_e *MockDwClientService_Expecter) DescribeCluster(params interface{}, opts ...interface{}) *MockDwClientService_DescribeCluster_Call { + return &MockDwClientService_DescribeCluster_Call{Call: _e.mock.On("DescribeCluster", + append([]interface{}{params}, opts...)...)} +} + +func (_c *MockDwClientService_DescribeCluster_Call) Run(run func(params *operations.DescribeClusterParams, opts ...operations.ClientOption)) *MockDwClientService_DescribeCluster_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]operations.ClientOption, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(operations.ClientOption) + } + } + run(args[0].(*operations.DescribeClusterParams), variadicArgs...) + }) + return _c +} + +func (_c *MockDwClientService_DescribeCluster_Call) Return(_a0 *operations.DescribeClusterOK, _a1 error) *MockDwClientService_DescribeCluster_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDwClientService_DescribeCluster_Call) RunAndReturn(run func(*operations.DescribeClusterParams, ...operations.ClientOption) (*operations.DescribeClusterOK, error)) *MockDwClientService_DescribeCluster_Call { + _c.Call.Return(run) + return _c +} + +// DescribeClusterDiagnosticDataJob provides a mock function with given fields: params, opts +func (_m *MockDwClientService) DescribeClusterDiagnosticDataJob(params *operations.DescribeClusterDiagnosticDataJobParams, opts ...operations.ClientOption) (*operations.DescribeClusterDiagnosticDataJobOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for DescribeClusterDiagnosticDataJob") + } + + var r0 *operations.DescribeClusterDiagnosticDataJobOK + var r1 error + if rf, ok := ret.Get(0).(func(*operations.DescribeClusterDiagnosticDataJobParams, ...operations.ClientOption) (*operations.DescribeClusterDiagnosticDataJobOK, error)); ok { + return rf(params, opts...) + } + if rf, ok := ret.Get(0).(func(*operations.DescribeClusterDiagnosticDataJobParams, ...operations.ClientOption) *operations.DescribeClusterDiagnosticDataJobOK); ok { + r0 = rf(params, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*operations.DescribeClusterDiagnosticDataJobOK) + } + } + + if rf, ok := ret.Get(1).(func(*operations.DescribeClusterDiagnosticDataJobParams, ...operations.ClientOption) error); ok { + r1 = rf(params, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDwClientService_DescribeClusterDiagnosticDataJob_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeClusterDiagnosticDataJob' +type MockDwClientService_DescribeClusterDiagnosticDataJob_Call struct { + *mock.Call +} + +// DescribeClusterDiagnosticDataJob is a helper method to define mock.On call +// - params *operations.DescribeClusterDiagnosticDataJobParams +// - opts ...operations.ClientOption +func (_e *MockDwClientService_Expecter) DescribeClusterDiagnosticDataJob(params interface{}, opts ...interface{}) *MockDwClientService_DescribeClusterDiagnosticDataJob_Call { + return &MockDwClientService_DescribeClusterDiagnosticDataJob_Call{Call: _e.mock.On("DescribeClusterDiagnosticDataJob", + append([]interface{}{params}, opts...)...)} +} + +func (_c *MockDwClientService_DescribeClusterDiagnosticDataJob_Call) Run(run func(params *operations.DescribeClusterDiagnosticDataJobParams, opts ...operations.ClientOption)) *MockDwClientService_DescribeClusterDiagnosticDataJob_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]operations.ClientOption, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(operations.ClientOption) + } + } + run(args[0].(*operations.DescribeClusterDiagnosticDataJobParams), variadicArgs...) + }) + return _c +} + +func (_c *MockDwClientService_DescribeClusterDiagnosticDataJob_Call) Return(_a0 *operations.DescribeClusterDiagnosticDataJobOK, _a1 error) *MockDwClientService_DescribeClusterDiagnosticDataJob_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDwClientService_DescribeClusterDiagnosticDataJob_Call) RunAndReturn(run func(*operations.DescribeClusterDiagnosticDataJobParams, ...operations.ClientOption) (*operations.DescribeClusterDiagnosticDataJobOK, error)) *MockDwClientService_DescribeClusterDiagnosticDataJob_Call { + _c.Call.Return(run) + return _c +} + +// DescribeConfig provides a mock function with given fields: params, opts +func (_m *MockDwClientService) DescribeConfig(params *operations.DescribeConfigParams, opts ...operations.ClientOption) (*operations.DescribeConfigOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for DescribeConfig") + } + + var r0 *operations.DescribeConfigOK + var r1 error + if rf, ok := ret.Get(0).(func(*operations.DescribeConfigParams, ...operations.ClientOption) (*operations.DescribeConfigOK, error)); ok { + return rf(params, opts...) + } + if rf, ok := ret.Get(0).(func(*operations.DescribeConfigParams, ...operations.ClientOption) *operations.DescribeConfigOK); ok { + r0 = rf(params, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*operations.DescribeConfigOK) + } + } + + if rf, ok := ret.Get(1).(func(*operations.DescribeConfigParams, ...operations.ClientOption) error); ok { + r1 = rf(params, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDwClientService_DescribeConfig_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeConfig' +type MockDwClientService_DescribeConfig_Call struct { + *mock.Call +} + +// DescribeConfig is a helper method to define mock.On call +// - params *operations.DescribeConfigParams +// - opts ...operations.ClientOption +func (_e *MockDwClientService_Expecter) DescribeConfig(params interface{}, opts ...interface{}) *MockDwClientService_DescribeConfig_Call { + return &MockDwClientService_DescribeConfig_Call{Call: _e.mock.On("DescribeConfig", + append([]interface{}{params}, opts...)...)} +} + +func (_c *MockDwClientService_DescribeConfig_Call) Run(run func(params *operations.DescribeConfigParams, opts ...operations.ClientOption)) *MockDwClientService_DescribeConfig_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]operations.ClientOption, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(operations.ClientOption) + } + } + run(args[0].(*operations.DescribeConfigParams), variadicArgs...) + }) + return _c +} + +func (_c *MockDwClientService_DescribeConfig_Call) Return(_a0 *operations.DescribeConfigOK, _a1 error) *MockDwClientService_DescribeConfig_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDwClientService_DescribeConfig_Call) RunAndReturn(run func(*operations.DescribeConfigParams, ...operations.ClientOption) (*operations.DescribeConfigOK, error)) *MockDwClientService_DescribeConfig_Call { + _c.Call.Return(run) + return _c +} + +// DescribeConfigDiff provides a mock function with given fields: params, opts +func (_m *MockDwClientService) DescribeConfigDiff(params *operations.DescribeConfigDiffParams, opts ...operations.ClientOption) (*operations.DescribeConfigDiffOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for DescribeConfigDiff") + } + + var r0 *operations.DescribeConfigDiffOK + var r1 error + if rf, ok := ret.Get(0).(func(*operations.DescribeConfigDiffParams, ...operations.ClientOption) (*operations.DescribeConfigDiffOK, error)); ok { + return rf(params, opts...) + } + if rf, ok := ret.Get(0).(func(*operations.DescribeConfigDiffParams, ...operations.ClientOption) *operations.DescribeConfigDiffOK); ok { + r0 = rf(params, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*operations.DescribeConfigDiffOK) + } + } + + if rf, ok := ret.Get(1).(func(*operations.DescribeConfigDiffParams, ...operations.ClientOption) error); ok { + r1 = rf(params, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDwClientService_DescribeConfigDiff_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeConfigDiff' +type MockDwClientService_DescribeConfigDiff_Call struct { + *mock.Call +} + +// DescribeConfigDiff is a helper method to define mock.On call +// - params *operations.DescribeConfigDiffParams +// - opts ...operations.ClientOption +func (_e *MockDwClientService_Expecter) DescribeConfigDiff(params interface{}, opts ...interface{}) *MockDwClientService_DescribeConfigDiff_Call { + return &MockDwClientService_DescribeConfigDiff_Call{Call: _e.mock.On("DescribeConfigDiff", + append([]interface{}{params}, opts...)...)} +} + +func (_c *MockDwClientService_DescribeConfigDiff_Call) Run(run func(params *operations.DescribeConfigDiffParams, opts ...operations.ClientOption)) *MockDwClientService_DescribeConfigDiff_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]operations.ClientOption, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(operations.ClientOption) + } + } + run(args[0].(*operations.DescribeConfigDiffParams), variadicArgs...) + }) + return _c +} + +func (_c *MockDwClientService_DescribeConfigDiff_Call) Return(_a0 *operations.DescribeConfigDiffOK, _a1 error) *MockDwClientService_DescribeConfigDiff_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDwClientService_DescribeConfigDiff_Call) RunAndReturn(run func(*operations.DescribeConfigDiffParams, ...operations.ClientOption) (*operations.DescribeConfigDiffOK, error)) *MockDwClientService_DescribeConfigDiff_Call { + _c.Call.Return(run) + return _c +} + +// DescribeDataVisualization provides a mock function with given fields: params, opts +func (_m *MockDwClientService) DescribeDataVisualization(params *operations.DescribeDataVisualizationParams, opts ...operations.ClientOption) (*operations.DescribeDataVisualizationOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for DescribeDataVisualization") + } + + var r0 *operations.DescribeDataVisualizationOK + var r1 error + if rf, ok := ret.Get(0).(func(*operations.DescribeDataVisualizationParams, ...operations.ClientOption) (*operations.DescribeDataVisualizationOK, error)); ok { + return rf(params, opts...) + } + if rf, ok := ret.Get(0).(func(*operations.DescribeDataVisualizationParams, ...operations.ClientOption) *operations.DescribeDataVisualizationOK); ok { + r0 = rf(params, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*operations.DescribeDataVisualizationOK) + } + } + + if rf, ok := ret.Get(1).(func(*operations.DescribeDataVisualizationParams, ...operations.ClientOption) error); ok { + r1 = rf(params, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDwClientService_DescribeDataVisualization_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeDataVisualization' +type MockDwClientService_DescribeDataVisualization_Call struct { + *mock.Call +} + +// DescribeDataVisualization is a helper method to define mock.On call +// - params *operations.DescribeDataVisualizationParams +// - opts ...operations.ClientOption +func (_e *MockDwClientService_Expecter) DescribeDataVisualization(params interface{}, opts ...interface{}) *MockDwClientService_DescribeDataVisualization_Call { + return &MockDwClientService_DescribeDataVisualization_Call{Call: _e.mock.On("DescribeDataVisualization", + append([]interface{}{params}, opts...)...)} +} + +func (_c *MockDwClientService_DescribeDataVisualization_Call) Run(run func(params *operations.DescribeDataVisualizationParams, opts ...operations.ClientOption)) *MockDwClientService_DescribeDataVisualization_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]operations.ClientOption, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(operations.ClientOption) + } + } + run(args[0].(*operations.DescribeDataVisualizationParams), variadicArgs...) + }) + return _c +} + +func (_c *MockDwClientService_DescribeDataVisualization_Call) Return(_a0 *operations.DescribeDataVisualizationOK, _a1 error) *MockDwClientService_DescribeDataVisualization_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDwClientService_DescribeDataVisualization_Call) RunAndReturn(run func(*operations.DescribeDataVisualizationParams, ...operations.ClientOption) (*operations.DescribeDataVisualizationOK, error)) *MockDwClientService_DescribeDataVisualization_Call { + _c.Call.Return(run) + return _c +} + +// DescribeDbc provides a mock function with given fields: params, opts +func (_m *MockDwClientService) DescribeDbc(params *operations.DescribeDbcParams, opts ...operations.ClientOption) (*operations.DescribeDbcOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for DescribeDbc") + } + + var r0 *operations.DescribeDbcOK + var r1 error + if rf, ok := ret.Get(0).(func(*operations.DescribeDbcParams, ...operations.ClientOption) (*operations.DescribeDbcOK, error)); ok { + return rf(params, opts...) + } + if rf, ok := ret.Get(0).(func(*operations.DescribeDbcParams, ...operations.ClientOption) *operations.DescribeDbcOK); ok { + r0 = rf(params, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*operations.DescribeDbcOK) + } + } + + if rf, ok := ret.Get(1).(func(*operations.DescribeDbcParams, ...operations.ClientOption) error); ok { + r1 = rf(params, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDwClientService_DescribeDbc_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeDbc' +type MockDwClientService_DescribeDbc_Call struct { + *mock.Call +} + +// DescribeDbc is a helper method to define mock.On call +// - params *operations.DescribeDbcParams +// - opts ...operations.ClientOption +func (_e *MockDwClientService_Expecter) DescribeDbc(params interface{}, opts ...interface{}) *MockDwClientService_DescribeDbc_Call { + return &MockDwClientService_DescribeDbc_Call{Call: _e.mock.On("DescribeDbc", + append([]interface{}{params}, opts...)...)} +} + +func (_c *MockDwClientService_DescribeDbc_Call) Run(run func(params *operations.DescribeDbcParams, opts ...operations.ClientOption)) *MockDwClientService_DescribeDbc_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]operations.ClientOption, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(operations.ClientOption) + } + } + run(args[0].(*operations.DescribeDbcParams), variadicArgs...) + }) + return _c +} + +func (_c *MockDwClientService_DescribeDbc_Call) Return(_a0 *operations.DescribeDbcOK, _a1 error) *MockDwClientService_DescribeDbc_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDwClientService_DescribeDbc_Call) RunAndReturn(run func(*operations.DescribeDbcParams, ...operations.ClientOption) (*operations.DescribeDbcOK, error)) *MockDwClientService_DescribeDbc_Call { + _c.Call.Return(run) + return _c +} + +// DescribeDbcConfig provides a mock function with given fields: params, opts +func (_m *MockDwClientService) DescribeDbcConfig(params *operations.DescribeDbcConfigParams, opts ...operations.ClientOption) (*operations.DescribeDbcConfigOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for DescribeDbcConfig") + } + + var r0 *operations.DescribeDbcConfigOK + var r1 error + if rf, ok := ret.Get(0).(func(*operations.DescribeDbcConfigParams, ...operations.ClientOption) (*operations.DescribeDbcConfigOK, error)); ok { + return rf(params, opts...) + } + if rf, ok := ret.Get(0).(func(*operations.DescribeDbcConfigParams, ...operations.ClientOption) *operations.DescribeDbcConfigOK); ok { + r0 = rf(params, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*operations.DescribeDbcConfigOK) + } + } + + if rf, ok := ret.Get(1).(func(*operations.DescribeDbcConfigParams, ...operations.ClientOption) error); ok { + r1 = rf(params, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDwClientService_DescribeDbcConfig_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeDbcConfig' +type MockDwClientService_DescribeDbcConfig_Call struct { + *mock.Call +} + +// DescribeDbcConfig is a helper method to define mock.On call +// - params *operations.DescribeDbcConfigParams +// - opts ...operations.ClientOption +func (_e *MockDwClientService_Expecter) DescribeDbcConfig(params interface{}, opts ...interface{}) *MockDwClientService_DescribeDbcConfig_Call { + return &MockDwClientService_DescribeDbcConfig_Call{Call: _e.mock.On("DescribeDbcConfig", + append([]interface{}{params}, opts...)...)} +} + +func (_c *MockDwClientService_DescribeDbcConfig_Call) Run(run func(params *operations.DescribeDbcConfigParams, opts ...operations.ClientOption)) *MockDwClientService_DescribeDbcConfig_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]operations.ClientOption, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(operations.ClientOption) + } + } + run(args[0].(*operations.DescribeDbcConfigParams), variadicArgs...) + }) + return _c +} + +func (_c *MockDwClientService_DescribeDbcConfig_Call) Return(_a0 *operations.DescribeDbcConfigOK, _a1 error) *MockDwClientService_DescribeDbcConfig_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDwClientService_DescribeDbcConfig_Call) RunAndReturn(run func(*operations.DescribeDbcConfigParams, ...operations.ClientOption) (*operations.DescribeDbcConfigOK, error)) *MockDwClientService_DescribeDbcConfig_Call { + _c.Call.Return(run) + return _c +} + +// DescribeDbcDiagnosticDataJob provides a mock function with given fields: params, opts +func (_m *MockDwClientService) DescribeDbcDiagnosticDataJob(params *operations.DescribeDbcDiagnosticDataJobParams, opts ...operations.ClientOption) (*operations.DescribeDbcDiagnosticDataJobOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for DescribeDbcDiagnosticDataJob") + } + + var r0 *operations.DescribeDbcDiagnosticDataJobOK + var r1 error + if rf, ok := ret.Get(0).(func(*operations.DescribeDbcDiagnosticDataJobParams, ...operations.ClientOption) (*operations.DescribeDbcDiagnosticDataJobOK, error)); ok { + return rf(params, opts...) + } + if rf, ok := ret.Get(0).(func(*operations.DescribeDbcDiagnosticDataJobParams, ...operations.ClientOption) *operations.DescribeDbcDiagnosticDataJobOK); ok { + r0 = rf(params, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*operations.DescribeDbcDiagnosticDataJobOK) + } + } + + if rf, ok := ret.Get(1).(func(*operations.DescribeDbcDiagnosticDataJobParams, ...operations.ClientOption) error); ok { + r1 = rf(params, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDwClientService_DescribeDbcDiagnosticDataJob_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeDbcDiagnosticDataJob' +type MockDwClientService_DescribeDbcDiagnosticDataJob_Call struct { + *mock.Call +} + +// DescribeDbcDiagnosticDataJob is a helper method to define mock.On call +// - params *operations.DescribeDbcDiagnosticDataJobParams +// - opts ...operations.ClientOption +func (_e *MockDwClientService_Expecter) DescribeDbcDiagnosticDataJob(params interface{}, opts ...interface{}) *MockDwClientService_DescribeDbcDiagnosticDataJob_Call { + return &MockDwClientService_DescribeDbcDiagnosticDataJob_Call{Call: _e.mock.On("DescribeDbcDiagnosticDataJob", + append([]interface{}{params}, opts...)...)} +} + +func (_c *MockDwClientService_DescribeDbcDiagnosticDataJob_Call) Run(run func(params *operations.DescribeDbcDiagnosticDataJobParams, opts ...operations.ClientOption)) *MockDwClientService_DescribeDbcDiagnosticDataJob_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]operations.ClientOption, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(operations.ClientOption) + } + } + run(args[0].(*operations.DescribeDbcDiagnosticDataJobParams), variadicArgs...) + }) + return _c +} + +func (_c *MockDwClientService_DescribeDbcDiagnosticDataJob_Call) Return(_a0 *operations.DescribeDbcDiagnosticDataJobOK, _a1 error) *MockDwClientService_DescribeDbcDiagnosticDataJob_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDwClientService_DescribeDbcDiagnosticDataJob_Call) RunAndReturn(run func(*operations.DescribeDbcDiagnosticDataJobParams, ...operations.ClientOption) (*operations.DescribeDbcDiagnosticDataJobOK, error)) *MockDwClientService_DescribeDbcDiagnosticDataJob_Call { + _c.Call.Return(run) + return _c +} + +// DescribeKubeconfig provides a mock function with given fields: params, opts +func (_m *MockDwClientService) DescribeKubeconfig(params *operations.DescribeKubeconfigParams, opts ...operations.ClientOption) (*operations.DescribeKubeconfigOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for DescribeKubeconfig") + } + + var r0 *operations.DescribeKubeconfigOK + var r1 error + if rf, ok := ret.Get(0).(func(*operations.DescribeKubeconfigParams, ...operations.ClientOption) (*operations.DescribeKubeconfigOK, error)); ok { + return rf(params, opts...) + } + if rf, ok := ret.Get(0).(func(*operations.DescribeKubeconfigParams, ...operations.ClientOption) *operations.DescribeKubeconfigOK); ok { + r0 = rf(params, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*operations.DescribeKubeconfigOK) + } + } + + if rf, ok := ret.Get(1).(func(*operations.DescribeKubeconfigParams, ...operations.ClientOption) error); ok { + r1 = rf(params, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDwClientService_DescribeKubeconfig_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeKubeconfig' +type MockDwClientService_DescribeKubeconfig_Call struct { + *mock.Call +} + +// DescribeKubeconfig is a helper method to define mock.On call +// - params *operations.DescribeKubeconfigParams +// - opts ...operations.ClientOption +func (_e *MockDwClientService_Expecter) DescribeKubeconfig(params interface{}, opts ...interface{}) *MockDwClientService_DescribeKubeconfig_Call { + return &MockDwClientService_DescribeKubeconfig_Call{Call: _e.mock.On("DescribeKubeconfig", + append([]interface{}{params}, opts...)...)} +} + +func (_c *MockDwClientService_DescribeKubeconfig_Call) Run(run func(params *operations.DescribeKubeconfigParams, opts ...operations.ClientOption)) *MockDwClientService_DescribeKubeconfig_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]operations.ClientOption, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(operations.ClientOption) + } + } + run(args[0].(*operations.DescribeKubeconfigParams), variadicArgs...) + }) + return _c +} + +func (_c *MockDwClientService_DescribeKubeconfig_Call) Return(_a0 *operations.DescribeKubeconfigOK, _a1 error) *MockDwClientService_DescribeKubeconfig_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDwClientService_DescribeKubeconfig_Call) RunAndReturn(run func(*operations.DescribeKubeconfigParams, ...operations.ClientOption) (*operations.DescribeKubeconfigOK, error)) *MockDwClientService_DescribeKubeconfig_Call { + _c.Call.Return(run) + return _c +} + +// DescribeRestore provides a mock function with given fields: params, opts +func (_m *MockDwClientService) DescribeRestore(params *operations.DescribeRestoreParams, opts ...operations.ClientOption) (*operations.DescribeRestoreOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for DescribeRestore") + } + + var r0 *operations.DescribeRestoreOK + var r1 error + if rf, ok := ret.Get(0).(func(*operations.DescribeRestoreParams, ...operations.ClientOption) (*operations.DescribeRestoreOK, error)); ok { + return rf(params, opts...) + } + if rf, ok := ret.Get(0).(func(*operations.DescribeRestoreParams, ...operations.ClientOption) *operations.DescribeRestoreOK); ok { + r0 = rf(params, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*operations.DescribeRestoreOK) + } + } + + if rf, ok := ret.Get(1).(func(*operations.DescribeRestoreParams, ...operations.ClientOption) error); ok { + r1 = rf(params, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDwClientService_DescribeRestore_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeRestore' +type MockDwClientService_DescribeRestore_Call struct { + *mock.Call +} + +// DescribeRestore is a helper method to define mock.On call +// - params *operations.DescribeRestoreParams +// - opts ...operations.ClientOption +func (_e *MockDwClientService_Expecter) DescribeRestore(params interface{}, opts ...interface{}) *MockDwClientService_DescribeRestore_Call { + return &MockDwClientService_DescribeRestore_Call{Call: _e.mock.On("DescribeRestore", + append([]interface{}{params}, opts...)...)} +} + +func (_c *MockDwClientService_DescribeRestore_Call) Run(run func(params *operations.DescribeRestoreParams, opts ...operations.ClientOption)) *MockDwClientService_DescribeRestore_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]operations.ClientOption, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(operations.ClientOption) + } + } + run(args[0].(*operations.DescribeRestoreParams), variadicArgs...) + }) + return _c +} + +func (_c *MockDwClientService_DescribeRestore_Call) Return(_a0 *operations.DescribeRestoreOK, _a1 error) *MockDwClientService_DescribeRestore_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDwClientService_DescribeRestore_Call) RunAndReturn(run func(*operations.DescribeRestoreParams, ...operations.ClientOption) (*operations.DescribeRestoreOK, error)) *MockDwClientService_DescribeRestore_Call { + _c.Call.Return(run) + return _c +} + +// DescribeServerSetting provides a mock function with given fields: params, opts +func (_m *MockDwClientService) DescribeServerSetting(params *operations.DescribeServerSettingParams, opts ...operations.ClientOption) (*operations.DescribeServerSettingOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for DescribeServerSetting") + } + + var r0 *operations.DescribeServerSettingOK + var r1 error + if rf, ok := ret.Get(0).(func(*operations.DescribeServerSettingParams, ...operations.ClientOption) (*operations.DescribeServerSettingOK, error)); ok { + return rf(params, opts...) + } + if rf, ok := ret.Get(0).(func(*operations.DescribeServerSettingParams, ...operations.ClientOption) *operations.DescribeServerSettingOK); ok { + r0 = rf(params, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*operations.DescribeServerSettingOK) + } + } + + if rf, ok := ret.Get(1).(func(*operations.DescribeServerSettingParams, ...operations.ClientOption) error); ok { + r1 = rf(params, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDwClientService_DescribeServerSetting_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeServerSetting' +type MockDwClientService_DescribeServerSetting_Call struct { + *mock.Call +} + +// DescribeServerSetting is a helper method to define mock.On call +// - params *operations.DescribeServerSettingParams +// - opts ...operations.ClientOption +func (_e *MockDwClientService_Expecter) DescribeServerSetting(params interface{}, opts ...interface{}) *MockDwClientService_DescribeServerSetting_Call { + return &MockDwClientService_DescribeServerSetting_Call{Call: _e.mock.On("DescribeServerSetting", + append([]interface{}{params}, opts...)...)} +} + +func (_c *MockDwClientService_DescribeServerSetting_Call) Run(run func(params *operations.DescribeServerSettingParams, opts ...operations.ClientOption)) *MockDwClientService_DescribeServerSetting_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]operations.ClientOption, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(operations.ClientOption) + } + } + run(args[0].(*operations.DescribeServerSettingParams), variadicArgs...) + }) + return _c +} + +func (_c *MockDwClientService_DescribeServerSetting_Call) Return(_a0 *operations.DescribeServerSettingOK, _a1 error) *MockDwClientService_DescribeServerSetting_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDwClientService_DescribeServerSetting_Call) RunAndReturn(run func(*operations.DescribeServerSettingParams, ...operations.ClientOption) (*operations.DescribeServerSettingOK, error)) *MockDwClientService_DescribeServerSetting_Call { + _c.Call.Return(run) + return _c +} + +// DescribeVw provides a mock function with given fields: params, opts +func (_m *MockDwClientService) DescribeVw(params *operations.DescribeVwParams, opts ...operations.ClientOption) (*operations.DescribeVwOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for DescribeVw") + } + + var r0 *operations.DescribeVwOK + var r1 error + if rf, ok := ret.Get(0).(func(*operations.DescribeVwParams, ...operations.ClientOption) (*operations.DescribeVwOK, error)); ok { + return rf(params, opts...) + } + if rf, ok := ret.Get(0).(func(*operations.DescribeVwParams, ...operations.ClientOption) *operations.DescribeVwOK); ok { + r0 = rf(params, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*operations.DescribeVwOK) + } + } + + if rf, ok := ret.Get(1).(func(*operations.DescribeVwParams, ...operations.ClientOption) error); ok { + r1 = rf(params, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDwClientService_DescribeVw_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeVw' +type MockDwClientService_DescribeVw_Call struct { + *mock.Call +} + +// DescribeVw is a helper method to define mock.On call +// - params *operations.DescribeVwParams +// - opts ...operations.ClientOption +func (_e *MockDwClientService_Expecter) DescribeVw(params interface{}, opts ...interface{}) *MockDwClientService_DescribeVw_Call { + return &MockDwClientService_DescribeVw_Call{Call: _e.mock.On("DescribeVw", + append([]interface{}{params}, opts...)...)} +} + +func (_c *MockDwClientService_DescribeVw_Call) Run(run func(params *operations.DescribeVwParams, opts ...operations.ClientOption)) *MockDwClientService_DescribeVw_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]operations.ClientOption, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(operations.ClientOption) + } + } + run(args[0].(*operations.DescribeVwParams), variadicArgs...) + }) + return _c +} + +func (_c *MockDwClientService_DescribeVw_Call) Return(_a0 *operations.DescribeVwOK, _a1 error) *MockDwClientService_DescribeVw_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDwClientService_DescribeVw_Call) RunAndReturn(run func(*operations.DescribeVwParams, ...operations.ClientOption) (*operations.DescribeVwOK, error)) *MockDwClientService_DescribeVw_Call { + _c.Call.Return(run) + return _c +} + +// DescribeVwConfig provides a mock function with given fields: params, opts +func (_m *MockDwClientService) DescribeVwConfig(params *operations.DescribeVwConfigParams, opts ...operations.ClientOption) (*operations.DescribeVwConfigOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for DescribeVwConfig") + } + + var r0 *operations.DescribeVwConfigOK + var r1 error + if rf, ok := ret.Get(0).(func(*operations.DescribeVwConfigParams, ...operations.ClientOption) (*operations.DescribeVwConfigOK, error)); ok { + return rf(params, opts...) + } + if rf, ok := ret.Get(0).(func(*operations.DescribeVwConfigParams, ...operations.ClientOption) *operations.DescribeVwConfigOK); ok { + r0 = rf(params, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*operations.DescribeVwConfigOK) + } + } + + if rf, ok := ret.Get(1).(func(*operations.DescribeVwConfigParams, ...operations.ClientOption) error); ok { + r1 = rf(params, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDwClientService_DescribeVwConfig_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeVwConfig' +type MockDwClientService_DescribeVwConfig_Call struct { + *mock.Call +} + +// DescribeVwConfig is a helper method to define mock.On call +// - params *operations.DescribeVwConfigParams +// - opts ...operations.ClientOption +func (_e *MockDwClientService_Expecter) DescribeVwConfig(params interface{}, opts ...interface{}) *MockDwClientService_DescribeVwConfig_Call { + return &MockDwClientService_DescribeVwConfig_Call{Call: _e.mock.On("DescribeVwConfig", + append([]interface{}{params}, opts...)...)} +} + +func (_c *MockDwClientService_DescribeVwConfig_Call) Run(run func(params *operations.DescribeVwConfigParams, opts ...operations.ClientOption)) *MockDwClientService_DescribeVwConfig_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]operations.ClientOption, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(operations.ClientOption) + } + } + run(args[0].(*operations.DescribeVwConfigParams), variadicArgs...) + }) + return _c +} + +func (_c *MockDwClientService_DescribeVwConfig_Call) Return(_a0 *operations.DescribeVwConfigOK, _a1 error) *MockDwClientService_DescribeVwConfig_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDwClientService_DescribeVwConfig_Call) RunAndReturn(run func(*operations.DescribeVwConfigParams, ...operations.ClientOption) (*operations.DescribeVwConfigOK, error)) *MockDwClientService_DescribeVwConfig_Call { + _c.Call.Return(run) + return _c +} + +// DescribeVwDiagnosticDataJob provides a mock function with given fields: params, opts +func (_m *MockDwClientService) DescribeVwDiagnosticDataJob(params *operations.DescribeVwDiagnosticDataJobParams, opts ...operations.ClientOption) (*operations.DescribeVwDiagnosticDataJobOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for DescribeVwDiagnosticDataJob") + } + + var r0 *operations.DescribeVwDiagnosticDataJobOK + var r1 error + if rf, ok := ret.Get(0).(func(*operations.DescribeVwDiagnosticDataJobParams, ...operations.ClientOption) (*operations.DescribeVwDiagnosticDataJobOK, error)); ok { + return rf(params, opts...) + } + if rf, ok := ret.Get(0).(func(*operations.DescribeVwDiagnosticDataJobParams, ...operations.ClientOption) *operations.DescribeVwDiagnosticDataJobOK); ok { + r0 = rf(params, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*operations.DescribeVwDiagnosticDataJobOK) + } + } + + if rf, ok := ret.Get(1).(func(*operations.DescribeVwDiagnosticDataJobParams, ...operations.ClientOption) error); ok { + r1 = rf(params, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDwClientService_DescribeVwDiagnosticDataJob_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeVwDiagnosticDataJob' +type MockDwClientService_DescribeVwDiagnosticDataJob_Call struct { + *mock.Call +} + +// DescribeVwDiagnosticDataJob is a helper method to define mock.On call +// - params *operations.DescribeVwDiagnosticDataJobParams +// - opts ...operations.ClientOption +func (_e *MockDwClientService_Expecter) DescribeVwDiagnosticDataJob(params interface{}, opts ...interface{}) *MockDwClientService_DescribeVwDiagnosticDataJob_Call { + return &MockDwClientService_DescribeVwDiagnosticDataJob_Call{Call: _e.mock.On("DescribeVwDiagnosticDataJob", + append([]interface{}{params}, opts...)...)} +} + +func (_c *MockDwClientService_DescribeVwDiagnosticDataJob_Call) Run(run func(params *operations.DescribeVwDiagnosticDataJobParams, opts ...operations.ClientOption)) *MockDwClientService_DescribeVwDiagnosticDataJob_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]operations.ClientOption, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(operations.ClientOption) + } + } + run(args[0].(*operations.DescribeVwDiagnosticDataJobParams), variadicArgs...) + }) + return _c +} + +func (_c *MockDwClientService_DescribeVwDiagnosticDataJob_Call) Return(_a0 *operations.DescribeVwDiagnosticDataJobOK, _a1 error) *MockDwClientService_DescribeVwDiagnosticDataJob_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDwClientService_DescribeVwDiagnosticDataJob_Call) RunAndReturn(run func(*operations.DescribeVwDiagnosticDataJobParams, ...operations.ClientOption) (*operations.DescribeVwDiagnosticDataJobOK, error)) *MockDwClientService_DescribeVwDiagnosticDataJob_Call { + _c.Call.Return(run) + return _c +} + +// GetDataVisualizationUpgradeVersion provides a mock function with given fields: params, opts +func (_m *MockDwClientService) GetDataVisualizationUpgradeVersion(params *operations.GetDataVisualizationUpgradeVersionParams, opts ...operations.ClientOption) (*operations.GetDataVisualizationUpgradeVersionOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for GetDataVisualizationUpgradeVersion") + } + + var r0 *operations.GetDataVisualizationUpgradeVersionOK + var r1 error + if rf, ok := ret.Get(0).(func(*operations.GetDataVisualizationUpgradeVersionParams, ...operations.ClientOption) (*operations.GetDataVisualizationUpgradeVersionOK, error)); ok { + return rf(params, opts...) + } + if rf, ok := ret.Get(0).(func(*operations.GetDataVisualizationUpgradeVersionParams, ...operations.ClientOption) *operations.GetDataVisualizationUpgradeVersionOK); ok { + r0 = rf(params, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*operations.GetDataVisualizationUpgradeVersionOK) + } + } + + if rf, ok := ret.Get(1).(func(*operations.GetDataVisualizationUpgradeVersionParams, ...operations.ClientOption) error); ok { + r1 = rf(params, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDwClientService_GetDataVisualizationUpgradeVersion_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetDataVisualizationUpgradeVersion' +type MockDwClientService_GetDataVisualizationUpgradeVersion_Call struct { + *mock.Call +} + +// GetDataVisualizationUpgradeVersion is a helper method to define mock.On call +// - params *operations.GetDataVisualizationUpgradeVersionParams +// - opts ...operations.ClientOption +func (_e *MockDwClientService_Expecter) GetDataVisualizationUpgradeVersion(params interface{}, opts ...interface{}) *MockDwClientService_GetDataVisualizationUpgradeVersion_Call { + return &MockDwClientService_GetDataVisualizationUpgradeVersion_Call{Call: _e.mock.On("GetDataVisualizationUpgradeVersion", + append([]interface{}{params}, opts...)...)} +} + +func (_c *MockDwClientService_GetDataVisualizationUpgradeVersion_Call) Run(run func(params *operations.GetDataVisualizationUpgradeVersionParams, opts ...operations.ClientOption)) *MockDwClientService_GetDataVisualizationUpgradeVersion_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]operations.ClientOption, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(operations.ClientOption) + } + } + run(args[0].(*operations.GetDataVisualizationUpgradeVersionParams), variadicArgs...) + }) + return _c +} + +func (_c *MockDwClientService_GetDataVisualizationUpgradeVersion_Call) Return(_a0 *operations.GetDataVisualizationUpgradeVersionOK, _a1 error) *MockDwClientService_GetDataVisualizationUpgradeVersion_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDwClientService_GetDataVisualizationUpgradeVersion_Call) RunAndReturn(run func(*operations.GetDataVisualizationUpgradeVersionParams, ...operations.ClientOption) (*operations.GetDataVisualizationUpgradeVersionOK, error)) *MockDwClientService_GetDataVisualizationUpgradeVersion_Call { + _c.Call.Return(run) + return _c +} + +// GetK8sCertJKS provides a mock function with given fields: params, opts +func (_m *MockDwClientService) GetK8sCertJKS(params *operations.GetK8sCertJKSParams, opts ...operations.ClientOption) (*operations.GetK8sCertJKSOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for GetK8sCertJKS") + } + + var r0 *operations.GetK8sCertJKSOK + var r1 error + if rf, ok := ret.Get(0).(func(*operations.GetK8sCertJKSParams, ...operations.ClientOption) (*operations.GetK8sCertJKSOK, error)); ok { + return rf(params, opts...) + } + if rf, ok := ret.Get(0).(func(*operations.GetK8sCertJKSParams, ...operations.ClientOption) *operations.GetK8sCertJKSOK); ok { + r0 = rf(params, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*operations.GetK8sCertJKSOK) + } + } + + if rf, ok := ret.Get(1).(func(*operations.GetK8sCertJKSParams, ...operations.ClientOption) error); ok { + r1 = rf(params, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDwClientService_GetK8sCertJKS_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetK8sCertJKS' +type MockDwClientService_GetK8sCertJKS_Call struct { + *mock.Call +} + +// GetK8sCertJKS is a helper method to define mock.On call +// - params *operations.GetK8sCertJKSParams +// - opts ...operations.ClientOption +func (_e *MockDwClientService_Expecter) GetK8sCertJKS(params interface{}, opts ...interface{}) *MockDwClientService_GetK8sCertJKS_Call { + return &MockDwClientService_GetK8sCertJKS_Call{Call: _e.mock.On("GetK8sCertJKS", + append([]interface{}{params}, opts...)...)} +} + +func (_c *MockDwClientService_GetK8sCertJKS_Call) Run(run func(params *operations.GetK8sCertJKSParams, opts ...operations.ClientOption)) *MockDwClientService_GetK8sCertJKS_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]operations.ClientOption, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(operations.ClientOption) + } + } + run(args[0].(*operations.GetK8sCertJKSParams), variadicArgs...) + }) + return _c +} + +func (_c *MockDwClientService_GetK8sCertJKS_Call) Return(_a0 *operations.GetK8sCertJKSOK, _a1 error) *MockDwClientService_GetK8sCertJKS_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDwClientService_GetK8sCertJKS_Call) RunAndReturn(run func(*operations.GetK8sCertJKSParams, ...operations.ClientOption) (*operations.GetK8sCertJKSOK, error)) *MockDwClientService_GetK8sCertJKS_Call { + _c.Call.Return(run) + return _c +} + +// GetK8sCertPEM provides a mock function with given fields: params, opts +func (_m *MockDwClientService) GetK8sCertPEM(params *operations.GetK8sCertPEMParams, opts ...operations.ClientOption) (*operations.GetK8sCertPEMOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for GetK8sCertPEM") + } + + var r0 *operations.GetK8sCertPEMOK + var r1 error + if rf, ok := ret.Get(0).(func(*operations.GetK8sCertPEMParams, ...operations.ClientOption) (*operations.GetK8sCertPEMOK, error)); ok { + return rf(params, opts...) + } + if rf, ok := ret.Get(0).(func(*operations.GetK8sCertPEMParams, ...operations.ClientOption) *operations.GetK8sCertPEMOK); ok { + r0 = rf(params, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*operations.GetK8sCertPEMOK) + } + } + + if rf, ok := ret.Get(1).(func(*operations.GetK8sCertPEMParams, ...operations.ClientOption) error); ok { + r1 = rf(params, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDwClientService_GetK8sCertPEM_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetK8sCertPEM' +type MockDwClientService_GetK8sCertPEM_Call struct { + *mock.Call +} + +// GetK8sCertPEM is a helper method to define mock.On call +// - params *operations.GetK8sCertPEMParams +// - opts ...operations.ClientOption +func (_e *MockDwClientService_Expecter) GetK8sCertPEM(params interface{}, opts ...interface{}) *MockDwClientService_GetK8sCertPEM_Call { + return &MockDwClientService_GetK8sCertPEM_Call{Call: _e.mock.On("GetK8sCertPEM", + append([]interface{}{params}, opts...)...)} +} + +func (_c *MockDwClientService_GetK8sCertPEM_Call) Run(run func(params *operations.GetK8sCertPEMParams, opts ...operations.ClientOption)) *MockDwClientService_GetK8sCertPEM_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]operations.ClientOption, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(operations.ClientOption) + } + } + run(args[0].(*operations.GetK8sCertPEMParams), variadicArgs...) + }) + return _c +} + +func (_c *MockDwClientService_GetK8sCertPEM_Call) Return(_a0 *operations.GetK8sCertPEMOK, _a1 error) *MockDwClientService_GetK8sCertPEM_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDwClientService_GetK8sCertPEM_Call) RunAndReturn(run func(*operations.GetK8sCertPEMParams, ...operations.ClientOption) (*operations.GetK8sCertPEMOK, error)) *MockDwClientService_GetK8sCertPEM_Call { + _c.Call.Return(run) + return _c +} + +// GetLogs provides a mock function with given fields: params, opts +func (_m *MockDwClientService) GetLogs(params *operations.GetLogsParams, opts ...operations.ClientOption) (*operations.GetLogsOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for GetLogs") + } + + var r0 *operations.GetLogsOK + var r1 error + if rf, ok := ret.Get(0).(func(*operations.GetLogsParams, ...operations.ClientOption) (*operations.GetLogsOK, error)); ok { + return rf(params, opts...) + } + if rf, ok := ret.Get(0).(func(*operations.GetLogsParams, ...operations.ClientOption) *operations.GetLogsOK); ok { + r0 = rf(params, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*operations.GetLogsOK) + } + } + + if rf, ok := ret.Get(1).(func(*operations.GetLogsParams, ...operations.ClientOption) error); ok { + r1 = rf(params, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDwClientService_GetLogs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetLogs' +type MockDwClientService_GetLogs_Call struct { + *mock.Call +} + +// GetLogs is a helper method to define mock.On call +// - params *operations.GetLogsParams +// - opts ...operations.ClientOption +func (_e *MockDwClientService_Expecter) GetLogs(params interface{}, opts ...interface{}) *MockDwClientService_GetLogs_Call { + return &MockDwClientService_GetLogs_Call{Call: _e.mock.On("GetLogs", + append([]interface{}{params}, opts...)...)} +} + +func (_c *MockDwClientService_GetLogs_Call) Run(run func(params *operations.GetLogsParams, opts ...operations.ClientOption)) *MockDwClientService_GetLogs_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]operations.ClientOption, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(operations.ClientOption) + } + } + run(args[0].(*operations.GetLogsParams), variadicArgs...) + }) + return _c +} + +func (_c *MockDwClientService_GetLogs_Call) Return(_a0 *operations.GetLogsOK, _a1 error) *MockDwClientService_GetLogs_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDwClientService_GetLogs_Call) RunAndReturn(run func(*operations.GetLogsParams, ...operations.ClientOption) (*operations.GetLogsOK, error)) *MockDwClientService_GetLogs_Call { + _c.Call.Return(run) + return _c +} + +// GetUpgradeDbcVersions provides a mock function with given fields: params, opts +func (_m *MockDwClientService) GetUpgradeDbcVersions(params *operations.GetUpgradeDbcVersionsParams, opts ...operations.ClientOption) (*operations.GetUpgradeDbcVersionsOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for GetUpgradeDbcVersions") + } + + var r0 *operations.GetUpgradeDbcVersionsOK + var r1 error + if rf, ok := ret.Get(0).(func(*operations.GetUpgradeDbcVersionsParams, ...operations.ClientOption) (*operations.GetUpgradeDbcVersionsOK, error)); ok { + return rf(params, opts...) + } + if rf, ok := ret.Get(0).(func(*operations.GetUpgradeDbcVersionsParams, ...operations.ClientOption) *operations.GetUpgradeDbcVersionsOK); ok { + r0 = rf(params, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*operations.GetUpgradeDbcVersionsOK) + } + } + + if rf, ok := ret.Get(1).(func(*operations.GetUpgradeDbcVersionsParams, ...operations.ClientOption) error); ok { + r1 = rf(params, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDwClientService_GetUpgradeDbcVersions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetUpgradeDbcVersions' +type MockDwClientService_GetUpgradeDbcVersions_Call struct { + *mock.Call +} + +// GetUpgradeDbcVersions is a helper method to define mock.On call +// - params *operations.GetUpgradeDbcVersionsParams +// - opts ...operations.ClientOption +func (_e *MockDwClientService_Expecter) GetUpgradeDbcVersions(params interface{}, opts ...interface{}) *MockDwClientService_GetUpgradeDbcVersions_Call { + return &MockDwClientService_GetUpgradeDbcVersions_Call{Call: _e.mock.On("GetUpgradeDbcVersions", + append([]interface{}{params}, opts...)...)} +} + +func (_c *MockDwClientService_GetUpgradeDbcVersions_Call) Run(run func(params *operations.GetUpgradeDbcVersionsParams, opts ...operations.ClientOption)) *MockDwClientService_GetUpgradeDbcVersions_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]operations.ClientOption, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(operations.ClientOption) + } + } + run(args[0].(*operations.GetUpgradeDbcVersionsParams), variadicArgs...) + }) + return _c +} + +func (_c *MockDwClientService_GetUpgradeDbcVersions_Call) Return(_a0 *operations.GetUpgradeDbcVersionsOK, _a1 error) *MockDwClientService_GetUpgradeDbcVersions_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDwClientService_GetUpgradeDbcVersions_Call) RunAndReturn(run func(*operations.GetUpgradeDbcVersionsParams, ...operations.ClientOption) (*operations.GetUpgradeDbcVersionsOK, error)) *MockDwClientService_GetUpgradeDbcVersions_Call { + _c.Call.Return(run) + return _c +} + +// GetUpgradeVwVersions provides a mock function with given fields: params, opts +func (_m *MockDwClientService) GetUpgradeVwVersions(params *operations.GetUpgradeVwVersionsParams, opts ...operations.ClientOption) (*operations.GetUpgradeVwVersionsOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for GetUpgradeVwVersions") + } + + var r0 *operations.GetUpgradeVwVersionsOK + var r1 error + if rf, ok := ret.Get(0).(func(*operations.GetUpgradeVwVersionsParams, ...operations.ClientOption) (*operations.GetUpgradeVwVersionsOK, error)); ok { + return rf(params, opts...) + } + if rf, ok := ret.Get(0).(func(*operations.GetUpgradeVwVersionsParams, ...operations.ClientOption) *operations.GetUpgradeVwVersionsOK); ok { + r0 = rf(params, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*operations.GetUpgradeVwVersionsOK) + } + } + + if rf, ok := ret.Get(1).(func(*operations.GetUpgradeVwVersionsParams, ...operations.ClientOption) error); ok { + r1 = rf(params, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDwClientService_GetUpgradeVwVersions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetUpgradeVwVersions' +type MockDwClientService_GetUpgradeVwVersions_Call struct { + *mock.Call +} + +// GetUpgradeVwVersions is a helper method to define mock.On call +// - params *operations.GetUpgradeVwVersionsParams +// - opts ...operations.ClientOption +func (_e *MockDwClientService_Expecter) GetUpgradeVwVersions(params interface{}, opts ...interface{}) *MockDwClientService_GetUpgradeVwVersions_Call { + return &MockDwClientService_GetUpgradeVwVersions_Call{Call: _e.mock.On("GetUpgradeVwVersions", + append([]interface{}{params}, opts...)...)} +} + +func (_c *MockDwClientService_GetUpgradeVwVersions_Call) Run(run func(params *operations.GetUpgradeVwVersionsParams, opts ...operations.ClientOption)) *MockDwClientService_GetUpgradeVwVersions_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]operations.ClientOption, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(operations.ClientOption) + } + } + run(args[0].(*operations.GetUpgradeVwVersionsParams), variadicArgs...) + }) + return _c +} + +func (_c *MockDwClientService_GetUpgradeVwVersions_Call) Return(_a0 *operations.GetUpgradeVwVersionsOK, _a1 error) *MockDwClientService_GetUpgradeVwVersions_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDwClientService_GetUpgradeVwVersions_Call) RunAndReturn(run func(*operations.GetUpgradeVwVersionsParams, ...operations.ClientOption) (*operations.GetUpgradeVwVersionsOK, error)) *MockDwClientService_GetUpgradeVwVersions_Call { + _c.Call.Return(run) + return _c +} + +// HealthCheck provides a mock function with given fields: params, opts +func (_m *MockDwClientService) HealthCheck(params *operations.HealthCheckParams, opts ...operations.ClientOption) (*operations.HealthCheckOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for HealthCheck") + } + + var r0 *operations.HealthCheckOK + var r1 error + if rf, ok := ret.Get(0).(func(*operations.HealthCheckParams, ...operations.ClientOption) (*operations.HealthCheckOK, error)); ok { + return rf(params, opts...) + } + if rf, ok := ret.Get(0).(func(*operations.HealthCheckParams, ...operations.ClientOption) *operations.HealthCheckOK); ok { + r0 = rf(params, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*operations.HealthCheckOK) + } + } + + if rf, ok := ret.Get(1).(func(*operations.HealthCheckParams, ...operations.ClientOption) error); ok { + r1 = rf(params, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDwClientService_HealthCheck_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HealthCheck' +type MockDwClientService_HealthCheck_Call struct { + *mock.Call +} + +// HealthCheck is a helper method to define mock.On call +// - params *operations.HealthCheckParams +// - opts ...operations.ClientOption +func (_e *MockDwClientService_Expecter) HealthCheck(params interface{}, opts ...interface{}) *MockDwClientService_HealthCheck_Call { + return &MockDwClientService_HealthCheck_Call{Call: _e.mock.On("HealthCheck", + append([]interface{}{params}, opts...)...)} +} + +func (_c *MockDwClientService_HealthCheck_Call) Run(run func(params *operations.HealthCheckParams, opts ...operations.ClientOption)) *MockDwClientService_HealthCheck_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]operations.ClientOption, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(operations.ClientOption) + } + } + run(args[0].(*operations.HealthCheckParams), variadicArgs...) + }) + return _c +} + +func (_c *MockDwClientService_HealthCheck_Call) Return(_a0 *operations.HealthCheckOK, _a1 error) *MockDwClientService_HealthCheck_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDwClientService_HealthCheck_Call) RunAndReturn(run func(*operations.HealthCheckParams, ...operations.ClientOption) (*operations.HealthCheckOK, error)) *MockDwClientService_HealthCheck_Call { + _c.Call.Return(run) + return _c +} + +// ListBackupEntities provides a mock function with given fields: params, opts +func (_m *MockDwClientService) ListBackupEntities(params *operations.ListBackupEntitiesParams, opts ...operations.ClientOption) (*operations.ListBackupEntitiesOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ListBackupEntities") + } + + var r0 *operations.ListBackupEntitiesOK + var r1 error + if rf, ok := ret.Get(0).(func(*operations.ListBackupEntitiesParams, ...operations.ClientOption) (*operations.ListBackupEntitiesOK, error)); ok { + return rf(params, opts...) + } + if rf, ok := ret.Get(0).(func(*operations.ListBackupEntitiesParams, ...operations.ClientOption) *operations.ListBackupEntitiesOK); ok { + r0 = rf(params, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*operations.ListBackupEntitiesOK) + } + } + + if rf, ok := ret.Get(1).(func(*operations.ListBackupEntitiesParams, ...operations.ClientOption) error); ok { + r1 = rf(params, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDwClientService_ListBackupEntities_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListBackupEntities' +type MockDwClientService_ListBackupEntities_Call struct { + *mock.Call +} + +// ListBackupEntities is a helper method to define mock.On call +// - params *operations.ListBackupEntitiesParams +// - opts ...operations.ClientOption +func (_e *MockDwClientService_Expecter) ListBackupEntities(params interface{}, opts ...interface{}) *MockDwClientService_ListBackupEntities_Call { + return &MockDwClientService_ListBackupEntities_Call{Call: _e.mock.On("ListBackupEntities", + append([]interface{}{params}, opts...)...)} +} + +func (_c *MockDwClientService_ListBackupEntities_Call) Run(run func(params *operations.ListBackupEntitiesParams, opts ...operations.ClientOption)) *MockDwClientService_ListBackupEntities_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]operations.ClientOption, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(operations.ClientOption) + } + } + run(args[0].(*operations.ListBackupEntitiesParams), variadicArgs...) + }) + return _c +} + +func (_c *MockDwClientService_ListBackupEntities_Call) Return(_a0 *operations.ListBackupEntitiesOK, _a1 error) *MockDwClientService_ListBackupEntities_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDwClientService_ListBackupEntities_Call) RunAndReturn(run func(*operations.ListBackupEntitiesParams, ...operations.ClientOption) (*operations.ListBackupEntitiesOK, error)) *MockDwClientService_ListBackupEntities_Call { + _c.Call.Return(run) + return _c +} + +// ListBackups provides a mock function with given fields: params, opts +func (_m *MockDwClientService) ListBackups(params *operations.ListBackupsParams, opts ...operations.ClientOption) (*operations.ListBackupsOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ListBackups") + } + + var r0 *operations.ListBackupsOK + var r1 error + if rf, ok := ret.Get(0).(func(*operations.ListBackupsParams, ...operations.ClientOption) (*operations.ListBackupsOK, error)); ok { + return rf(params, opts...) + } + if rf, ok := ret.Get(0).(func(*operations.ListBackupsParams, ...operations.ClientOption) *operations.ListBackupsOK); ok { + r0 = rf(params, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*operations.ListBackupsOK) + } + } + + if rf, ok := ret.Get(1).(func(*operations.ListBackupsParams, ...operations.ClientOption) error); ok { + r1 = rf(params, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDwClientService_ListBackups_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListBackups' +type MockDwClientService_ListBackups_Call struct { + *mock.Call +} + +// ListBackups is a helper method to define mock.On call +// - params *operations.ListBackupsParams +// - opts ...operations.ClientOption +func (_e *MockDwClientService_Expecter) ListBackups(params interface{}, opts ...interface{}) *MockDwClientService_ListBackups_Call { + return &MockDwClientService_ListBackups_Call{Call: _e.mock.On("ListBackups", + append([]interface{}{params}, opts...)...)} +} + +func (_c *MockDwClientService_ListBackups_Call) Run(run func(params *operations.ListBackupsParams, opts ...operations.ClientOption)) *MockDwClientService_ListBackups_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]operations.ClientOption, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(operations.ClientOption) + } + } + run(args[0].(*operations.ListBackupsParams), variadicArgs...) + }) + return _c +} + +func (_c *MockDwClientService_ListBackups_Call) Return(_a0 *operations.ListBackupsOK, _a1 error) *MockDwClientService_ListBackups_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDwClientService_ListBackups_Call) RunAndReturn(run func(*operations.ListBackupsParams, ...operations.ClientOption) (*operations.ListBackupsOK, error)) *MockDwClientService_ListBackups_Call { + _c.Call.Return(run) + return _c +} + +// ListClusterDiagnosticDataJobs provides a mock function with given fields: params, opts +func (_m *MockDwClientService) ListClusterDiagnosticDataJobs(params *operations.ListClusterDiagnosticDataJobsParams, opts ...operations.ClientOption) (*operations.ListClusterDiagnosticDataJobsOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ListClusterDiagnosticDataJobs") + } + + var r0 *operations.ListClusterDiagnosticDataJobsOK + var r1 error + if rf, ok := ret.Get(0).(func(*operations.ListClusterDiagnosticDataJobsParams, ...operations.ClientOption) (*operations.ListClusterDiagnosticDataJobsOK, error)); ok { + return rf(params, opts...) + } + if rf, ok := ret.Get(0).(func(*operations.ListClusterDiagnosticDataJobsParams, ...operations.ClientOption) *operations.ListClusterDiagnosticDataJobsOK); ok { + r0 = rf(params, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*operations.ListClusterDiagnosticDataJobsOK) + } + } + + if rf, ok := ret.Get(1).(func(*operations.ListClusterDiagnosticDataJobsParams, ...operations.ClientOption) error); ok { + r1 = rf(params, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDwClientService_ListClusterDiagnosticDataJobs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListClusterDiagnosticDataJobs' +type MockDwClientService_ListClusterDiagnosticDataJobs_Call struct { + *mock.Call +} + +// ListClusterDiagnosticDataJobs is a helper method to define mock.On call +// - params *operations.ListClusterDiagnosticDataJobsParams +// - opts ...operations.ClientOption +func (_e *MockDwClientService_Expecter) ListClusterDiagnosticDataJobs(params interface{}, opts ...interface{}) *MockDwClientService_ListClusterDiagnosticDataJobs_Call { + return &MockDwClientService_ListClusterDiagnosticDataJobs_Call{Call: _e.mock.On("ListClusterDiagnosticDataJobs", + append([]interface{}{params}, opts...)...)} +} + +func (_c *MockDwClientService_ListClusterDiagnosticDataJobs_Call) Run(run func(params *operations.ListClusterDiagnosticDataJobsParams, opts ...operations.ClientOption)) *MockDwClientService_ListClusterDiagnosticDataJobs_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]operations.ClientOption, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(operations.ClientOption) + } + } + run(args[0].(*operations.ListClusterDiagnosticDataJobsParams), variadicArgs...) + }) + return _c +} + +func (_c *MockDwClientService_ListClusterDiagnosticDataJobs_Call) Return(_a0 *operations.ListClusterDiagnosticDataJobsOK, _a1 error) *MockDwClientService_ListClusterDiagnosticDataJobs_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDwClientService_ListClusterDiagnosticDataJobs_Call) RunAndReturn(run func(*operations.ListClusterDiagnosticDataJobsParams, ...operations.ClientOption) (*operations.ListClusterDiagnosticDataJobsOK, error)) *MockDwClientService_ListClusterDiagnosticDataJobs_Call { + _c.Call.Return(run) + return _c +} + +// ListClusters provides a mock function with given fields: params, opts +func (_m *MockDwClientService) ListClusters(params *operations.ListClustersParams, opts ...operations.ClientOption) (*operations.ListClustersOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ListClusters") + } + + var r0 *operations.ListClustersOK + var r1 error + if rf, ok := ret.Get(0).(func(*operations.ListClustersParams, ...operations.ClientOption) (*operations.ListClustersOK, error)); ok { + return rf(params, opts...) + } + if rf, ok := ret.Get(0).(func(*operations.ListClustersParams, ...operations.ClientOption) *operations.ListClustersOK); ok { + r0 = rf(params, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*operations.ListClustersOK) + } + } + + if rf, ok := ret.Get(1).(func(*operations.ListClustersParams, ...operations.ClientOption) error); ok { + r1 = rf(params, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDwClientService_ListClusters_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListClusters' +type MockDwClientService_ListClusters_Call struct { + *mock.Call +} + +// ListClusters is a helper method to define mock.On call +// - params *operations.ListClustersParams +// - opts ...operations.ClientOption +func (_e *MockDwClientService_Expecter) ListClusters(params interface{}, opts ...interface{}) *MockDwClientService_ListClusters_Call { + return &MockDwClientService_ListClusters_Call{Call: _e.mock.On("ListClusters", + append([]interface{}{params}, opts...)...)} +} + +func (_c *MockDwClientService_ListClusters_Call) Run(run func(params *operations.ListClustersParams, opts ...operations.ClientOption)) *MockDwClientService_ListClusters_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]operations.ClientOption, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(operations.ClientOption) + } + } + run(args[0].(*operations.ListClustersParams), variadicArgs...) + }) + return _c +} + +func (_c *MockDwClientService_ListClusters_Call) Return(_a0 *operations.ListClustersOK, _a1 error) *MockDwClientService_ListClusters_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDwClientService_ListClusters_Call) RunAndReturn(run func(*operations.ListClustersParams, ...operations.ClientOption) (*operations.ListClustersOK, error)) *MockDwClientService_ListClusters_Call { + _c.Call.Return(run) + return _c +} + +// ListDataVisualizations provides a mock function with given fields: params, opts +func (_m *MockDwClientService) ListDataVisualizations(params *operations.ListDataVisualizationsParams, opts ...operations.ClientOption) (*operations.ListDataVisualizationsOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ListDataVisualizations") + } + + var r0 *operations.ListDataVisualizationsOK + var r1 error + if rf, ok := ret.Get(0).(func(*operations.ListDataVisualizationsParams, ...operations.ClientOption) (*operations.ListDataVisualizationsOK, error)); ok { + return rf(params, opts...) + } + if rf, ok := ret.Get(0).(func(*operations.ListDataVisualizationsParams, ...operations.ClientOption) *operations.ListDataVisualizationsOK); ok { + r0 = rf(params, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*operations.ListDataVisualizationsOK) + } + } + + if rf, ok := ret.Get(1).(func(*operations.ListDataVisualizationsParams, ...operations.ClientOption) error); ok { + r1 = rf(params, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDwClientService_ListDataVisualizations_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListDataVisualizations' +type MockDwClientService_ListDataVisualizations_Call struct { + *mock.Call +} + +// ListDataVisualizations is a helper method to define mock.On call +// - params *operations.ListDataVisualizationsParams +// - opts ...operations.ClientOption +func (_e *MockDwClientService_Expecter) ListDataVisualizations(params interface{}, opts ...interface{}) *MockDwClientService_ListDataVisualizations_Call { + return &MockDwClientService_ListDataVisualizations_Call{Call: _e.mock.On("ListDataVisualizations", + append([]interface{}{params}, opts...)...)} +} + +func (_c *MockDwClientService_ListDataVisualizations_Call) Run(run func(params *operations.ListDataVisualizationsParams, opts ...operations.ClientOption)) *MockDwClientService_ListDataVisualizations_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]operations.ClientOption, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(operations.ClientOption) + } + } + run(args[0].(*operations.ListDataVisualizationsParams), variadicArgs...) + }) + return _c +} + +func (_c *MockDwClientService_ListDataVisualizations_Call) Return(_a0 *operations.ListDataVisualizationsOK, _a1 error) *MockDwClientService_ListDataVisualizations_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDwClientService_ListDataVisualizations_Call) RunAndReturn(run func(*operations.ListDataVisualizationsParams, ...operations.ClientOption) (*operations.ListDataVisualizationsOK, error)) *MockDwClientService_ListDataVisualizations_Call { + _c.Call.Return(run) + return _c +} + +// ListDbcConfigs provides a mock function with given fields: params, opts +func (_m *MockDwClientService) ListDbcConfigs(params *operations.ListDbcConfigsParams, opts ...operations.ClientOption) (*operations.ListDbcConfigsOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ListDbcConfigs") + } + + var r0 *operations.ListDbcConfigsOK + var r1 error + if rf, ok := ret.Get(0).(func(*operations.ListDbcConfigsParams, ...operations.ClientOption) (*operations.ListDbcConfigsOK, error)); ok { + return rf(params, opts...) + } + if rf, ok := ret.Get(0).(func(*operations.ListDbcConfigsParams, ...operations.ClientOption) *operations.ListDbcConfigsOK); ok { + r0 = rf(params, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*operations.ListDbcConfigsOK) + } + } + + if rf, ok := ret.Get(1).(func(*operations.ListDbcConfigsParams, ...operations.ClientOption) error); ok { + r1 = rf(params, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDwClientService_ListDbcConfigs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListDbcConfigs' +type MockDwClientService_ListDbcConfigs_Call struct { + *mock.Call +} + +// ListDbcConfigs is a helper method to define mock.On call +// - params *operations.ListDbcConfigsParams +// - opts ...operations.ClientOption +func (_e *MockDwClientService_Expecter) ListDbcConfigs(params interface{}, opts ...interface{}) *MockDwClientService_ListDbcConfigs_Call { + return &MockDwClientService_ListDbcConfigs_Call{Call: _e.mock.On("ListDbcConfigs", + append([]interface{}{params}, opts...)...)} +} + +func (_c *MockDwClientService_ListDbcConfigs_Call) Run(run func(params *operations.ListDbcConfigsParams, opts ...operations.ClientOption)) *MockDwClientService_ListDbcConfigs_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]operations.ClientOption, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(operations.ClientOption) + } + } + run(args[0].(*operations.ListDbcConfigsParams), variadicArgs...) + }) + return _c +} + +func (_c *MockDwClientService_ListDbcConfigs_Call) Return(_a0 *operations.ListDbcConfigsOK, _a1 error) *MockDwClientService_ListDbcConfigs_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDwClientService_ListDbcConfigs_Call) RunAndReturn(run func(*operations.ListDbcConfigsParams, ...operations.ClientOption) (*operations.ListDbcConfigsOK, error)) *MockDwClientService_ListDbcConfigs_Call { + _c.Call.Return(run) + return _c +} + +// ListDbcDiagnosticDataJobs provides a mock function with given fields: params, opts +func (_m *MockDwClientService) ListDbcDiagnosticDataJobs(params *operations.ListDbcDiagnosticDataJobsParams, opts ...operations.ClientOption) (*operations.ListDbcDiagnosticDataJobsOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ListDbcDiagnosticDataJobs") + } + + var r0 *operations.ListDbcDiagnosticDataJobsOK + var r1 error + if rf, ok := ret.Get(0).(func(*operations.ListDbcDiagnosticDataJobsParams, ...operations.ClientOption) (*operations.ListDbcDiagnosticDataJobsOK, error)); ok { + return rf(params, opts...) + } + if rf, ok := ret.Get(0).(func(*operations.ListDbcDiagnosticDataJobsParams, ...operations.ClientOption) *operations.ListDbcDiagnosticDataJobsOK); ok { + r0 = rf(params, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*operations.ListDbcDiagnosticDataJobsOK) + } + } + + if rf, ok := ret.Get(1).(func(*operations.ListDbcDiagnosticDataJobsParams, ...operations.ClientOption) error); ok { + r1 = rf(params, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDwClientService_ListDbcDiagnosticDataJobs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListDbcDiagnosticDataJobs' +type MockDwClientService_ListDbcDiagnosticDataJobs_Call struct { + *mock.Call +} + +// ListDbcDiagnosticDataJobs is a helper method to define mock.On call +// - params *operations.ListDbcDiagnosticDataJobsParams +// - opts ...operations.ClientOption +func (_e *MockDwClientService_Expecter) ListDbcDiagnosticDataJobs(params interface{}, opts ...interface{}) *MockDwClientService_ListDbcDiagnosticDataJobs_Call { + return &MockDwClientService_ListDbcDiagnosticDataJobs_Call{Call: _e.mock.On("ListDbcDiagnosticDataJobs", + append([]interface{}{params}, opts...)...)} +} + +func (_c *MockDwClientService_ListDbcDiagnosticDataJobs_Call) Run(run func(params *operations.ListDbcDiagnosticDataJobsParams, opts ...operations.ClientOption)) *MockDwClientService_ListDbcDiagnosticDataJobs_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]operations.ClientOption, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(operations.ClientOption) + } + } + run(args[0].(*operations.ListDbcDiagnosticDataJobsParams), variadicArgs...) + }) + return _c +} + +func (_c *MockDwClientService_ListDbcDiagnosticDataJobs_Call) Return(_a0 *operations.ListDbcDiagnosticDataJobsOK, _a1 error) *MockDwClientService_ListDbcDiagnosticDataJobs_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDwClientService_ListDbcDiagnosticDataJobs_Call) RunAndReturn(run func(*operations.ListDbcDiagnosticDataJobsParams, ...operations.ClientOption) (*operations.ListDbcDiagnosticDataJobsOK, error)) *MockDwClientService_ListDbcDiagnosticDataJobs_Call { + _c.Call.Return(run) + return _c +} + +// ListDbcEvents provides a mock function with given fields: params, opts +func (_m *MockDwClientService) ListDbcEvents(params *operations.ListDbcEventsParams, opts ...operations.ClientOption) (*operations.ListDbcEventsOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ListDbcEvents") + } + + var r0 *operations.ListDbcEventsOK + var r1 error + if rf, ok := ret.Get(0).(func(*operations.ListDbcEventsParams, ...operations.ClientOption) (*operations.ListDbcEventsOK, error)); ok { + return rf(params, opts...) + } + if rf, ok := ret.Get(0).(func(*operations.ListDbcEventsParams, ...operations.ClientOption) *operations.ListDbcEventsOK); ok { + r0 = rf(params, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*operations.ListDbcEventsOK) + } + } + + if rf, ok := ret.Get(1).(func(*operations.ListDbcEventsParams, ...operations.ClientOption) error); ok { + r1 = rf(params, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDwClientService_ListDbcEvents_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListDbcEvents' +type MockDwClientService_ListDbcEvents_Call struct { + *mock.Call +} + +// ListDbcEvents is a helper method to define mock.On call +// - params *operations.ListDbcEventsParams +// - opts ...operations.ClientOption +func (_e *MockDwClientService_Expecter) ListDbcEvents(params interface{}, opts ...interface{}) *MockDwClientService_ListDbcEvents_Call { + return &MockDwClientService_ListDbcEvents_Call{Call: _e.mock.On("ListDbcEvents", + append([]interface{}{params}, opts...)...)} +} + +func (_c *MockDwClientService_ListDbcEvents_Call) Run(run func(params *operations.ListDbcEventsParams, opts ...operations.ClientOption)) *MockDwClientService_ListDbcEvents_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]operations.ClientOption, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(operations.ClientOption) + } + } + run(args[0].(*operations.ListDbcEventsParams), variadicArgs...) + }) + return _c +} + +func (_c *MockDwClientService_ListDbcEvents_Call) Return(_a0 *operations.ListDbcEventsOK, _a1 error) *MockDwClientService_ListDbcEvents_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDwClientService_ListDbcEvents_Call) RunAndReturn(run func(*operations.ListDbcEventsParams, ...operations.ClientOption) (*operations.ListDbcEventsOK, error)) *MockDwClientService_ListDbcEvents_Call { + _c.Call.Return(run) + return _c +} + +// ListDbcs provides a mock function with given fields: params, opts +func (_m *MockDwClientService) ListDbcs(params *operations.ListDbcsParams, opts ...operations.ClientOption) (*operations.ListDbcsOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ListDbcs") + } + + var r0 *operations.ListDbcsOK + var r1 error + if rf, ok := ret.Get(0).(func(*operations.ListDbcsParams, ...operations.ClientOption) (*operations.ListDbcsOK, error)); ok { + return rf(params, opts...) + } + if rf, ok := ret.Get(0).(func(*operations.ListDbcsParams, ...operations.ClientOption) *operations.ListDbcsOK); ok { + r0 = rf(params, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*operations.ListDbcsOK) + } + } + + if rf, ok := ret.Get(1).(func(*operations.ListDbcsParams, ...operations.ClientOption) error); ok { + r1 = rf(params, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDwClientService_ListDbcs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListDbcs' +type MockDwClientService_ListDbcs_Call struct { + *mock.Call +} + +// ListDbcs is a helper method to define mock.On call +// - params *operations.ListDbcsParams +// - opts ...operations.ClientOption +func (_e *MockDwClientService_Expecter) ListDbcs(params interface{}, opts ...interface{}) *MockDwClientService_ListDbcs_Call { + return &MockDwClientService_ListDbcs_Call{Call: _e.mock.On("ListDbcs", + append([]interface{}{params}, opts...)...)} +} + +func (_c *MockDwClientService_ListDbcs_Call) Run(run func(params *operations.ListDbcsParams, opts ...operations.ClientOption)) *MockDwClientService_ListDbcs_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]operations.ClientOption, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(operations.ClientOption) + } + } + run(args[0].(*operations.ListDbcsParams), variadicArgs...) + }) + return _c +} + +func (_c *MockDwClientService_ListDbcs_Call) Return(_a0 *operations.ListDbcsOK, _a1 error) *MockDwClientService_ListDbcs_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDwClientService_ListDbcs_Call) RunAndReturn(run func(*operations.ListDbcsParams, ...operations.ClientOption) (*operations.ListDbcsOK, error)) *MockDwClientService_ListDbcs_Call { + _c.Call.Return(run) + return _c +} + +// ListEvents provides a mock function with given fields: params, opts +func (_m *MockDwClientService) ListEvents(params *operations.ListEventsParams, opts ...operations.ClientOption) (*operations.ListEventsOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ListEvents") + } + + var r0 *operations.ListEventsOK + var r1 error + if rf, ok := ret.Get(0).(func(*operations.ListEventsParams, ...operations.ClientOption) (*operations.ListEventsOK, error)); ok { + return rf(params, opts...) + } + if rf, ok := ret.Get(0).(func(*operations.ListEventsParams, ...operations.ClientOption) *operations.ListEventsOK); ok { + r0 = rf(params, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*operations.ListEventsOK) + } + } + + if rf, ok := ret.Get(1).(func(*operations.ListEventsParams, ...operations.ClientOption) error); ok { + r1 = rf(params, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDwClientService_ListEvents_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListEvents' +type MockDwClientService_ListEvents_Call struct { + *mock.Call +} + +// ListEvents is a helper method to define mock.On call +// - params *operations.ListEventsParams +// - opts ...operations.ClientOption +func (_e *MockDwClientService_Expecter) ListEvents(params interface{}, opts ...interface{}) *MockDwClientService_ListEvents_Call { + return &MockDwClientService_ListEvents_Call{Call: _e.mock.On("ListEvents", + append([]interface{}{params}, opts...)...)} +} + +func (_c *MockDwClientService_ListEvents_Call) Run(run func(params *operations.ListEventsParams, opts ...operations.ClientOption)) *MockDwClientService_ListEvents_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]operations.ClientOption, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(operations.ClientOption) + } + } + run(args[0].(*operations.ListEventsParams), variadicArgs...) + }) + return _c +} + +func (_c *MockDwClientService_ListEvents_Call) Return(_a0 *operations.ListEventsOK, _a1 error) *MockDwClientService_ListEvents_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDwClientService_ListEvents_Call) RunAndReturn(run func(*operations.ListEventsParams, ...operations.ClientOption) (*operations.ListEventsOK, error)) *MockDwClientService_ListEvents_Call { + _c.Call.Return(run) + return _c +} + +// ListLatestVersions provides a mock function with given fields: params, opts +func (_m *MockDwClientService) ListLatestVersions(params *operations.ListLatestVersionsParams, opts ...operations.ClientOption) (*operations.ListLatestVersionsOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ListLatestVersions") + } + + var r0 *operations.ListLatestVersionsOK + var r1 error + if rf, ok := ret.Get(0).(func(*operations.ListLatestVersionsParams, ...operations.ClientOption) (*operations.ListLatestVersionsOK, error)); ok { + return rf(params, opts...) + } + if rf, ok := ret.Get(0).(func(*operations.ListLatestVersionsParams, ...operations.ClientOption) *operations.ListLatestVersionsOK); ok { + r0 = rf(params, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*operations.ListLatestVersionsOK) + } + } + + if rf, ok := ret.Get(1).(func(*operations.ListLatestVersionsParams, ...operations.ClientOption) error); ok { + r1 = rf(params, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDwClientService_ListLatestVersions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListLatestVersions' +type MockDwClientService_ListLatestVersions_Call struct { + *mock.Call +} + +// ListLatestVersions is a helper method to define mock.On call +// - params *operations.ListLatestVersionsParams +// - opts ...operations.ClientOption +func (_e *MockDwClientService_Expecter) ListLatestVersions(params interface{}, opts ...interface{}) *MockDwClientService_ListLatestVersions_Call { + return &MockDwClientService_ListLatestVersions_Call{Call: _e.mock.On("ListLatestVersions", + append([]interface{}{params}, opts...)...)} +} + +func (_c *MockDwClientService_ListLatestVersions_Call) Run(run func(params *operations.ListLatestVersionsParams, opts ...operations.ClientOption)) *MockDwClientService_ListLatestVersions_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]operations.ClientOption, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(operations.ClientOption) + } + } + run(args[0].(*operations.ListLatestVersionsParams), variadicArgs...) + }) + return _c +} + +func (_c *MockDwClientService_ListLatestVersions_Call) Return(_a0 *operations.ListLatestVersionsOK, _a1 error) *MockDwClientService_ListLatestVersions_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDwClientService_ListLatestVersions_Call) RunAndReturn(run func(*operations.ListLatestVersionsParams, ...operations.ClientOption) (*operations.ListLatestVersionsOK, error)) *MockDwClientService_ListLatestVersions_Call { + _c.Call.Return(run) + return _c +} + +// ListRestores provides a mock function with given fields: params, opts +func (_m *MockDwClientService) ListRestores(params *operations.ListRestoresParams, opts ...operations.ClientOption) (*operations.ListRestoresOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ListRestores") + } + + var r0 *operations.ListRestoresOK + var r1 error + if rf, ok := ret.Get(0).(func(*operations.ListRestoresParams, ...operations.ClientOption) (*operations.ListRestoresOK, error)); ok { + return rf(params, opts...) + } + if rf, ok := ret.Get(0).(func(*operations.ListRestoresParams, ...operations.ClientOption) *operations.ListRestoresOK); ok { + r0 = rf(params, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*operations.ListRestoresOK) + } + } + + if rf, ok := ret.Get(1).(func(*operations.ListRestoresParams, ...operations.ClientOption) error); ok { + r1 = rf(params, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDwClientService_ListRestores_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListRestores' +type MockDwClientService_ListRestores_Call struct { + *mock.Call +} + +// ListRestores is a helper method to define mock.On call +// - params *operations.ListRestoresParams +// - opts ...operations.ClientOption +func (_e *MockDwClientService_Expecter) ListRestores(params interface{}, opts ...interface{}) *MockDwClientService_ListRestores_Call { + return &MockDwClientService_ListRestores_Call{Call: _e.mock.On("ListRestores", + append([]interface{}{params}, opts...)...)} +} + +func (_c *MockDwClientService_ListRestores_Call) Run(run func(params *operations.ListRestoresParams, opts ...operations.ClientOption)) *MockDwClientService_ListRestores_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]operations.ClientOption, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(operations.ClientOption) + } + } + run(args[0].(*operations.ListRestoresParams), variadicArgs...) + }) + return _c +} + +func (_c *MockDwClientService_ListRestores_Call) Return(_a0 *operations.ListRestoresOK, _a1 error) *MockDwClientService_ListRestores_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDwClientService_ListRestores_Call) RunAndReturn(run func(*operations.ListRestoresParams, ...operations.ClientOption) (*operations.ListRestoresOK, error)) *MockDwClientService_ListRestores_Call { + _c.Call.Return(run) + return _c +} + +// ListUsers provides a mock function with given fields: params, opts +func (_m *MockDwClientService) ListUsers(params *operations.ListUsersParams, opts ...operations.ClientOption) (*operations.ListUsersOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ListUsers") + } + + var r0 *operations.ListUsersOK + var r1 error + if rf, ok := ret.Get(0).(func(*operations.ListUsersParams, ...operations.ClientOption) (*operations.ListUsersOK, error)); ok { + return rf(params, opts...) + } + if rf, ok := ret.Get(0).(func(*operations.ListUsersParams, ...operations.ClientOption) *operations.ListUsersOK); ok { + r0 = rf(params, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*operations.ListUsersOK) + } + } + + if rf, ok := ret.Get(1).(func(*operations.ListUsersParams, ...operations.ClientOption) error); ok { + r1 = rf(params, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDwClientService_ListUsers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListUsers' +type MockDwClientService_ListUsers_Call struct { + *mock.Call +} + +// ListUsers is a helper method to define mock.On call +// - params *operations.ListUsersParams +// - opts ...operations.ClientOption +func (_e *MockDwClientService_Expecter) ListUsers(params interface{}, opts ...interface{}) *MockDwClientService_ListUsers_Call { + return &MockDwClientService_ListUsers_Call{Call: _e.mock.On("ListUsers", + append([]interface{}{params}, opts...)...)} +} + +func (_c *MockDwClientService_ListUsers_Call) Run(run func(params *operations.ListUsersParams, opts ...operations.ClientOption)) *MockDwClientService_ListUsers_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]operations.ClientOption, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(operations.ClientOption) + } + } + run(args[0].(*operations.ListUsersParams), variadicArgs...) + }) + return _c +} + +func (_c *MockDwClientService_ListUsers_Call) Return(_a0 *operations.ListUsersOK, _a1 error) *MockDwClientService_ListUsers_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDwClientService_ListUsers_Call) RunAndReturn(run func(*operations.ListUsersParams, ...operations.ClientOption) (*operations.ListUsersOK, error)) *MockDwClientService_ListUsers_Call { + _c.Call.Return(run) + return _c +} + +// ListVwConfigs provides a mock function with given fields: params, opts +func (_m *MockDwClientService) ListVwConfigs(params *operations.ListVwConfigsParams, opts ...operations.ClientOption) (*operations.ListVwConfigsOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ListVwConfigs") + } + + var r0 *operations.ListVwConfigsOK + var r1 error + if rf, ok := ret.Get(0).(func(*operations.ListVwConfigsParams, ...operations.ClientOption) (*operations.ListVwConfigsOK, error)); ok { + return rf(params, opts...) + } + if rf, ok := ret.Get(0).(func(*operations.ListVwConfigsParams, ...operations.ClientOption) *operations.ListVwConfigsOK); ok { + r0 = rf(params, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*operations.ListVwConfigsOK) + } + } + + if rf, ok := ret.Get(1).(func(*operations.ListVwConfigsParams, ...operations.ClientOption) error); ok { + r1 = rf(params, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDwClientService_ListVwConfigs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListVwConfigs' +type MockDwClientService_ListVwConfigs_Call struct { + *mock.Call +} + +// ListVwConfigs is a helper method to define mock.On call +// - params *operations.ListVwConfigsParams +// - opts ...operations.ClientOption +func (_e *MockDwClientService_Expecter) ListVwConfigs(params interface{}, opts ...interface{}) *MockDwClientService_ListVwConfigs_Call { + return &MockDwClientService_ListVwConfigs_Call{Call: _e.mock.On("ListVwConfigs", + append([]interface{}{params}, opts...)...)} +} + +func (_c *MockDwClientService_ListVwConfigs_Call) Run(run func(params *operations.ListVwConfigsParams, opts ...operations.ClientOption)) *MockDwClientService_ListVwConfigs_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]operations.ClientOption, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(operations.ClientOption) + } + } + run(args[0].(*operations.ListVwConfigsParams), variadicArgs...) + }) + return _c +} + +func (_c *MockDwClientService_ListVwConfigs_Call) Return(_a0 *operations.ListVwConfigsOK, _a1 error) *MockDwClientService_ListVwConfigs_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDwClientService_ListVwConfigs_Call) RunAndReturn(run func(*operations.ListVwConfigsParams, ...operations.ClientOption) (*operations.ListVwConfigsOK, error)) *MockDwClientService_ListVwConfigs_Call { + _c.Call.Return(run) + return _c +} + +// ListVwDiagnosticDataJobs provides a mock function with given fields: params, opts +func (_m *MockDwClientService) ListVwDiagnosticDataJobs(params *operations.ListVwDiagnosticDataJobsParams, opts ...operations.ClientOption) (*operations.ListVwDiagnosticDataJobsOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ListVwDiagnosticDataJobs") + } + + var r0 *operations.ListVwDiagnosticDataJobsOK + var r1 error + if rf, ok := ret.Get(0).(func(*operations.ListVwDiagnosticDataJobsParams, ...operations.ClientOption) (*operations.ListVwDiagnosticDataJobsOK, error)); ok { + return rf(params, opts...) + } + if rf, ok := ret.Get(0).(func(*operations.ListVwDiagnosticDataJobsParams, ...operations.ClientOption) *operations.ListVwDiagnosticDataJobsOK); ok { + r0 = rf(params, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*operations.ListVwDiagnosticDataJobsOK) + } + } + + if rf, ok := ret.Get(1).(func(*operations.ListVwDiagnosticDataJobsParams, ...operations.ClientOption) error); ok { + r1 = rf(params, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDwClientService_ListVwDiagnosticDataJobs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListVwDiagnosticDataJobs' +type MockDwClientService_ListVwDiagnosticDataJobs_Call struct { + *mock.Call +} + +// ListVwDiagnosticDataJobs is a helper method to define mock.On call +// - params *operations.ListVwDiagnosticDataJobsParams +// - opts ...operations.ClientOption +func (_e *MockDwClientService_Expecter) ListVwDiagnosticDataJobs(params interface{}, opts ...interface{}) *MockDwClientService_ListVwDiagnosticDataJobs_Call { + return &MockDwClientService_ListVwDiagnosticDataJobs_Call{Call: _e.mock.On("ListVwDiagnosticDataJobs", + append([]interface{}{params}, opts...)...)} +} + +func (_c *MockDwClientService_ListVwDiagnosticDataJobs_Call) Run(run func(params *operations.ListVwDiagnosticDataJobsParams, opts ...operations.ClientOption)) *MockDwClientService_ListVwDiagnosticDataJobs_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]operations.ClientOption, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(operations.ClientOption) + } + } + run(args[0].(*operations.ListVwDiagnosticDataJobsParams), variadicArgs...) + }) + return _c +} + +func (_c *MockDwClientService_ListVwDiagnosticDataJobs_Call) Return(_a0 *operations.ListVwDiagnosticDataJobsOK, _a1 error) *MockDwClientService_ListVwDiagnosticDataJobs_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDwClientService_ListVwDiagnosticDataJobs_Call) RunAndReturn(run func(*operations.ListVwDiagnosticDataJobsParams, ...operations.ClientOption) (*operations.ListVwDiagnosticDataJobsOK, error)) *MockDwClientService_ListVwDiagnosticDataJobs_Call { + _c.Call.Return(run) + return _c +} + +// ListVwEvents provides a mock function with given fields: params, opts +func (_m *MockDwClientService) ListVwEvents(params *operations.ListVwEventsParams, opts ...operations.ClientOption) (*operations.ListVwEventsOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ListVwEvents") + } + + var r0 *operations.ListVwEventsOK + var r1 error + if rf, ok := ret.Get(0).(func(*operations.ListVwEventsParams, ...operations.ClientOption) (*operations.ListVwEventsOK, error)); ok { + return rf(params, opts...) + } + if rf, ok := ret.Get(0).(func(*operations.ListVwEventsParams, ...operations.ClientOption) *operations.ListVwEventsOK); ok { + r0 = rf(params, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*operations.ListVwEventsOK) + } + } + + if rf, ok := ret.Get(1).(func(*operations.ListVwEventsParams, ...operations.ClientOption) error); ok { + r1 = rf(params, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDwClientService_ListVwEvents_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListVwEvents' +type MockDwClientService_ListVwEvents_Call struct { + *mock.Call +} + +// ListVwEvents is a helper method to define mock.On call +// - params *operations.ListVwEventsParams +// - opts ...operations.ClientOption +func (_e *MockDwClientService_Expecter) ListVwEvents(params interface{}, opts ...interface{}) *MockDwClientService_ListVwEvents_Call { + return &MockDwClientService_ListVwEvents_Call{Call: _e.mock.On("ListVwEvents", + append([]interface{}{params}, opts...)...)} +} + +func (_c *MockDwClientService_ListVwEvents_Call) Run(run func(params *operations.ListVwEventsParams, opts ...operations.ClientOption)) *MockDwClientService_ListVwEvents_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]operations.ClientOption, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(operations.ClientOption) + } + } + run(args[0].(*operations.ListVwEventsParams), variadicArgs...) + }) + return _c +} + +func (_c *MockDwClientService_ListVwEvents_Call) Return(_a0 *operations.ListVwEventsOK, _a1 error) *MockDwClientService_ListVwEvents_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDwClientService_ListVwEvents_Call) RunAndReturn(run func(*operations.ListVwEventsParams, ...operations.ClientOption) (*operations.ListVwEventsOK, error)) *MockDwClientService_ListVwEvents_Call { + _c.Call.Return(run) + return _c +} + +// ListVws provides a mock function with given fields: params, opts +func (_m *MockDwClientService) ListVws(params *operations.ListVwsParams, opts ...operations.ClientOption) (*operations.ListVwsOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ListVws") + } + + var r0 *operations.ListVwsOK + var r1 error + if rf, ok := ret.Get(0).(func(*operations.ListVwsParams, ...operations.ClientOption) (*operations.ListVwsOK, error)); ok { + return rf(params, opts...) + } + if rf, ok := ret.Get(0).(func(*operations.ListVwsParams, ...operations.ClientOption) *operations.ListVwsOK); ok { + r0 = rf(params, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*operations.ListVwsOK) + } + } + + if rf, ok := ret.Get(1).(func(*operations.ListVwsParams, ...operations.ClientOption) error); ok { + r1 = rf(params, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDwClientService_ListVws_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListVws' +type MockDwClientService_ListVws_Call struct { + *mock.Call +} + +// ListVws is a helper method to define mock.On call +// - params *operations.ListVwsParams +// - opts ...operations.ClientOption +func (_e *MockDwClientService_Expecter) ListVws(params interface{}, opts ...interface{}) *MockDwClientService_ListVws_Call { + return &MockDwClientService_ListVws_Call{Call: _e.mock.On("ListVws", + append([]interface{}{params}, opts...)...)} +} + +func (_c *MockDwClientService_ListVws_Call) Run(run func(params *operations.ListVwsParams, opts ...operations.ClientOption)) *MockDwClientService_ListVws_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]operations.ClientOption, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(operations.ClientOption) + } + } + run(args[0].(*operations.ListVwsParams), variadicArgs...) + }) + return _c +} + +func (_c *MockDwClientService_ListVws_Call) Return(_a0 *operations.ListVwsOK, _a1 error) *MockDwClientService_ListVws_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDwClientService_ListVws_Call) RunAndReturn(run func(*operations.ListVwsParams, ...operations.ClientOption) (*operations.ListVwsOK, error)) *MockDwClientService_ListVws_Call { + _c.Call.Return(run) + return _c +} + +// RebuildDbc provides a mock function with given fields: params, opts +func (_m *MockDwClientService) RebuildDbc(params *operations.RebuildDbcParams, opts ...operations.ClientOption) (*operations.RebuildDbcOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for RebuildDbc") + } + + var r0 *operations.RebuildDbcOK + var r1 error + if rf, ok := ret.Get(0).(func(*operations.RebuildDbcParams, ...operations.ClientOption) (*operations.RebuildDbcOK, error)); ok { + return rf(params, opts...) + } + if rf, ok := ret.Get(0).(func(*operations.RebuildDbcParams, ...operations.ClientOption) *operations.RebuildDbcOK); ok { + r0 = rf(params, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*operations.RebuildDbcOK) + } + } + + if rf, ok := ret.Get(1).(func(*operations.RebuildDbcParams, ...operations.ClientOption) error); ok { + r1 = rf(params, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDwClientService_RebuildDbc_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RebuildDbc' +type MockDwClientService_RebuildDbc_Call struct { + *mock.Call +} + +// RebuildDbc is a helper method to define mock.On call +// - params *operations.RebuildDbcParams +// - opts ...operations.ClientOption +func (_e *MockDwClientService_Expecter) RebuildDbc(params interface{}, opts ...interface{}) *MockDwClientService_RebuildDbc_Call { + return &MockDwClientService_RebuildDbc_Call{Call: _e.mock.On("RebuildDbc", + append([]interface{}{params}, opts...)...)} +} + +func (_c *MockDwClientService_RebuildDbc_Call) Run(run func(params *operations.RebuildDbcParams, opts ...operations.ClientOption)) *MockDwClientService_RebuildDbc_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]operations.ClientOption, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(operations.ClientOption) + } + } + run(args[0].(*operations.RebuildDbcParams), variadicArgs...) + }) + return _c +} + +func (_c *MockDwClientService_RebuildDbc_Call) Return(_a0 *operations.RebuildDbcOK, _a1 error) *MockDwClientService_RebuildDbc_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDwClientService_RebuildDbc_Call) RunAndReturn(run func(*operations.RebuildDbcParams, ...operations.ClientOption) (*operations.RebuildDbcOK, error)) *MockDwClientService_RebuildDbc_Call { + _c.Call.Return(run) + return _c +} + +// RebuildVw provides a mock function with given fields: params, opts +func (_m *MockDwClientService) RebuildVw(params *operations.RebuildVwParams, opts ...operations.ClientOption) (*operations.RebuildVwOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for RebuildVw") + } + + var r0 *operations.RebuildVwOK + var r1 error + if rf, ok := ret.Get(0).(func(*operations.RebuildVwParams, ...operations.ClientOption) (*operations.RebuildVwOK, error)); ok { + return rf(params, opts...) + } + if rf, ok := ret.Get(0).(func(*operations.RebuildVwParams, ...operations.ClientOption) *operations.RebuildVwOK); ok { + r0 = rf(params, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*operations.RebuildVwOK) + } + } + + if rf, ok := ret.Get(1).(func(*operations.RebuildVwParams, ...operations.ClientOption) error); ok { + r1 = rf(params, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDwClientService_RebuildVw_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RebuildVw' +type MockDwClientService_RebuildVw_Call struct { + *mock.Call +} + +// RebuildVw is a helper method to define mock.On call +// - params *operations.RebuildVwParams +// - opts ...operations.ClientOption +func (_e *MockDwClientService_Expecter) RebuildVw(params interface{}, opts ...interface{}) *MockDwClientService_RebuildVw_Call { + return &MockDwClientService_RebuildVw_Call{Call: _e.mock.On("RebuildVw", + append([]interface{}{params}, opts...)...)} +} + +func (_c *MockDwClientService_RebuildVw_Call) Run(run func(params *operations.RebuildVwParams, opts ...operations.ClientOption)) *MockDwClientService_RebuildVw_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]operations.ClientOption, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(operations.ClientOption) + } + } + run(args[0].(*operations.RebuildVwParams), variadicArgs...) + }) + return _c +} + +func (_c *MockDwClientService_RebuildVw_Call) Return(_a0 *operations.RebuildVwOK, _a1 error) *MockDwClientService_RebuildVw_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDwClientService_RebuildVw_Call) RunAndReturn(run func(*operations.RebuildVwParams, ...operations.ClientOption) (*operations.RebuildVwOK, error)) *MockDwClientService_RebuildVw_Call { + _c.Call.Return(run) + return _c +} + +// RenewCertificates provides a mock function with given fields: params, opts +func (_m *MockDwClientService) RenewCertificates(params *operations.RenewCertificatesParams, opts ...operations.ClientOption) (*operations.RenewCertificatesOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for RenewCertificates") + } + + var r0 *operations.RenewCertificatesOK + var r1 error + if rf, ok := ret.Get(0).(func(*operations.RenewCertificatesParams, ...operations.ClientOption) (*operations.RenewCertificatesOK, error)); ok { + return rf(params, opts...) + } + if rf, ok := ret.Get(0).(func(*operations.RenewCertificatesParams, ...operations.ClientOption) *operations.RenewCertificatesOK); ok { + r0 = rf(params, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*operations.RenewCertificatesOK) + } + } + + if rf, ok := ret.Get(1).(func(*operations.RenewCertificatesParams, ...operations.ClientOption) error); ok { + r1 = rf(params, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDwClientService_RenewCertificates_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RenewCertificates' +type MockDwClientService_RenewCertificates_Call struct { + *mock.Call +} + +// RenewCertificates is a helper method to define mock.On call +// - params *operations.RenewCertificatesParams +// - opts ...operations.ClientOption +func (_e *MockDwClientService_Expecter) RenewCertificates(params interface{}, opts ...interface{}) *MockDwClientService_RenewCertificates_Call { + return &MockDwClientService_RenewCertificates_Call{Call: _e.mock.On("RenewCertificates", + append([]interface{}{params}, opts...)...)} +} + +func (_c *MockDwClientService_RenewCertificates_Call) Run(run func(params *operations.RenewCertificatesParams, opts ...operations.ClientOption)) *MockDwClientService_RenewCertificates_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]operations.ClientOption, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(operations.ClientOption) + } + } + run(args[0].(*operations.RenewCertificatesParams), variadicArgs...) + }) + return _c +} + +func (_c *MockDwClientService_RenewCertificates_Call) Return(_a0 *operations.RenewCertificatesOK, _a1 error) *MockDwClientService_RenewCertificates_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDwClientService_RenewCertificates_Call) RunAndReturn(run func(*operations.RenewCertificatesParams, ...operations.ClientOption) (*operations.RenewCertificatesOK, error)) *MockDwClientService_RenewCertificates_Call { + _c.Call.Return(run) + return _c +} + +// RestartDbc provides a mock function with given fields: params, opts +func (_m *MockDwClientService) RestartDbc(params *operations.RestartDbcParams, opts ...operations.ClientOption) (*operations.RestartDbcOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for RestartDbc") + } + + var r0 *operations.RestartDbcOK + var r1 error + if rf, ok := ret.Get(0).(func(*operations.RestartDbcParams, ...operations.ClientOption) (*operations.RestartDbcOK, error)); ok { + return rf(params, opts...) + } + if rf, ok := ret.Get(0).(func(*operations.RestartDbcParams, ...operations.ClientOption) *operations.RestartDbcOK); ok { + r0 = rf(params, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*operations.RestartDbcOK) + } + } + + if rf, ok := ret.Get(1).(func(*operations.RestartDbcParams, ...operations.ClientOption) error); ok { + r1 = rf(params, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDwClientService_RestartDbc_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RestartDbc' +type MockDwClientService_RestartDbc_Call struct { + *mock.Call +} + +// RestartDbc is a helper method to define mock.On call +// - params *operations.RestartDbcParams +// - opts ...operations.ClientOption +func (_e *MockDwClientService_Expecter) RestartDbc(params interface{}, opts ...interface{}) *MockDwClientService_RestartDbc_Call { + return &MockDwClientService_RestartDbc_Call{Call: _e.mock.On("RestartDbc", + append([]interface{}{params}, opts...)...)} +} + +func (_c *MockDwClientService_RestartDbc_Call) Run(run func(params *operations.RestartDbcParams, opts ...operations.ClientOption)) *MockDwClientService_RestartDbc_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]operations.ClientOption, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(operations.ClientOption) + } + } + run(args[0].(*operations.RestartDbcParams), variadicArgs...) + }) + return _c +} + +func (_c *MockDwClientService_RestartDbc_Call) Return(_a0 *operations.RestartDbcOK, _a1 error) *MockDwClientService_RestartDbc_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDwClientService_RestartDbc_Call) RunAndReturn(run func(*operations.RestartDbcParams, ...operations.ClientOption) (*operations.RestartDbcOK, error)) *MockDwClientService_RestartDbc_Call { + _c.Call.Return(run) + return _c +} + +// RestartVw provides a mock function with given fields: params, opts +func (_m *MockDwClientService) RestartVw(params *operations.RestartVwParams, opts ...operations.ClientOption) (*operations.RestartVwOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for RestartVw") + } + + var r0 *operations.RestartVwOK + var r1 error + if rf, ok := ret.Get(0).(func(*operations.RestartVwParams, ...operations.ClientOption) (*operations.RestartVwOK, error)); ok { + return rf(params, opts...) + } + if rf, ok := ret.Get(0).(func(*operations.RestartVwParams, ...operations.ClientOption) *operations.RestartVwOK); ok { + r0 = rf(params, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*operations.RestartVwOK) + } + } + + if rf, ok := ret.Get(1).(func(*operations.RestartVwParams, ...operations.ClientOption) error); ok { + r1 = rf(params, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDwClientService_RestartVw_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RestartVw' +type MockDwClientService_RestartVw_Call struct { + *mock.Call +} + +// RestartVw is a helper method to define mock.On call +// - params *operations.RestartVwParams +// - opts ...operations.ClientOption +func (_e *MockDwClientService_Expecter) RestartVw(params interface{}, opts ...interface{}) *MockDwClientService_RestartVw_Call { + return &MockDwClientService_RestartVw_Call{Call: _e.mock.On("RestartVw", + append([]interface{}{params}, opts...)...)} +} + +func (_c *MockDwClientService_RestartVw_Call) Run(run func(params *operations.RestartVwParams, opts ...operations.ClientOption)) *MockDwClientService_RestartVw_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]operations.ClientOption, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(operations.ClientOption) + } + } + run(args[0].(*operations.RestartVwParams), variadicArgs...) + }) + return _c +} + +func (_c *MockDwClientService_RestartVw_Call) Return(_a0 *operations.RestartVwOK, _a1 error) *MockDwClientService_RestartVw_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDwClientService_RestartVw_Call) RunAndReturn(run func(*operations.RestartVwParams, ...operations.ClientOption) (*operations.RestartVwOK, error)) *MockDwClientService_RestartVw_Call { + _c.Call.Return(run) + return _c +} + +// RestoreBackup provides a mock function with given fields: params, opts +func (_m *MockDwClientService) RestoreBackup(params *operations.RestoreBackupParams, opts ...operations.ClientOption) (*operations.RestoreBackupOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for RestoreBackup") + } + + var r0 *operations.RestoreBackupOK + var r1 error + if rf, ok := ret.Get(0).(func(*operations.RestoreBackupParams, ...operations.ClientOption) (*operations.RestoreBackupOK, error)); ok { + return rf(params, opts...) + } + if rf, ok := ret.Get(0).(func(*operations.RestoreBackupParams, ...operations.ClientOption) *operations.RestoreBackupOK); ok { + r0 = rf(params, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*operations.RestoreBackupOK) + } + } + + if rf, ok := ret.Get(1).(func(*operations.RestoreBackupParams, ...operations.ClientOption) error); ok { + r1 = rf(params, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDwClientService_RestoreBackup_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RestoreBackup' +type MockDwClientService_RestoreBackup_Call struct { + *mock.Call +} + +// RestoreBackup is a helper method to define mock.On call +// - params *operations.RestoreBackupParams +// - opts ...operations.ClientOption +func (_e *MockDwClientService_Expecter) RestoreBackup(params interface{}, opts ...interface{}) *MockDwClientService_RestoreBackup_Call { + return &MockDwClientService_RestoreBackup_Call{Call: _e.mock.On("RestoreBackup", + append([]interface{}{params}, opts...)...)} +} + +func (_c *MockDwClientService_RestoreBackup_Call) Run(run func(params *operations.RestoreBackupParams, opts ...operations.ClientOption)) *MockDwClientService_RestoreBackup_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]operations.ClientOption, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(operations.ClientOption) + } + } + run(args[0].(*operations.RestoreBackupParams), variadicArgs...) + }) + return _c +} + +func (_c *MockDwClientService_RestoreBackup_Call) Return(_a0 *operations.RestoreBackupOK, _a1 error) *MockDwClientService_RestoreBackup_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDwClientService_RestoreBackup_Call) RunAndReturn(run func(*operations.RestoreBackupParams, ...operations.ClientOption) (*operations.RestoreBackupOK, error)) *MockDwClientService_RestoreBackup_Call { + _c.Call.Return(run) + return _c +} + +// RestoreCluster provides a mock function with given fields: params, opts +func (_m *MockDwClientService) RestoreCluster(params *operations.RestoreClusterParams, opts ...operations.ClientOption) (*operations.RestoreClusterOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for RestoreCluster") + } + + var r0 *operations.RestoreClusterOK + var r1 error + if rf, ok := ret.Get(0).(func(*operations.RestoreClusterParams, ...operations.ClientOption) (*operations.RestoreClusterOK, error)); ok { + return rf(params, opts...) + } + if rf, ok := ret.Get(0).(func(*operations.RestoreClusterParams, ...operations.ClientOption) *operations.RestoreClusterOK); ok { + r0 = rf(params, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*operations.RestoreClusterOK) + } + } + + if rf, ok := ret.Get(1).(func(*operations.RestoreClusterParams, ...operations.ClientOption) error); ok { + r1 = rf(params, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDwClientService_RestoreCluster_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RestoreCluster' +type MockDwClientService_RestoreCluster_Call struct { + *mock.Call +} + +// RestoreCluster is a helper method to define mock.On call +// - params *operations.RestoreClusterParams +// - opts ...operations.ClientOption +func (_e *MockDwClientService_Expecter) RestoreCluster(params interface{}, opts ...interface{}) *MockDwClientService_RestoreCluster_Call { + return &MockDwClientService_RestoreCluster_Call{Call: _e.mock.On("RestoreCluster", + append([]interface{}{params}, opts...)...)} +} + +func (_c *MockDwClientService_RestoreCluster_Call) Run(run func(params *operations.RestoreClusterParams, opts ...operations.ClientOption)) *MockDwClientService_RestoreCluster_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]operations.ClientOption, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(operations.ClientOption) + } + } + run(args[0].(*operations.RestoreClusterParams), variadicArgs...) + }) + return _c +} + +func (_c *MockDwClientService_RestoreCluster_Call) Return(_a0 *operations.RestoreClusterOK, _a1 error) *MockDwClientService_RestoreCluster_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDwClientService_RestoreCluster_Call) RunAndReturn(run func(*operations.RestoreClusterParams, ...operations.ClientOption) (*operations.RestoreClusterOK, error)) *MockDwClientService_RestoreCluster_Call { + _c.Call.Return(run) + return _c +} + +// ResumeCluster provides a mock function with given fields: params, opts +func (_m *MockDwClientService) ResumeCluster(params *operations.ResumeClusterParams, opts ...operations.ClientOption) (*operations.ResumeClusterOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ResumeCluster") + } + + var r0 *operations.ResumeClusterOK + var r1 error + if rf, ok := ret.Get(0).(func(*operations.ResumeClusterParams, ...operations.ClientOption) (*operations.ResumeClusterOK, error)); ok { + return rf(params, opts...) + } + if rf, ok := ret.Get(0).(func(*operations.ResumeClusterParams, ...operations.ClientOption) *operations.ResumeClusterOK); ok { + r0 = rf(params, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*operations.ResumeClusterOK) + } + } + + if rf, ok := ret.Get(1).(func(*operations.ResumeClusterParams, ...operations.ClientOption) error); ok { + r1 = rf(params, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDwClientService_ResumeCluster_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ResumeCluster' +type MockDwClientService_ResumeCluster_Call struct { + *mock.Call +} + +// ResumeCluster is a helper method to define mock.On call +// - params *operations.ResumeClusterParams +// - opts ...operations.ClientOption +func (_e *MockDwClientService_Expecter) ResumeCluster(params interface{}, opts ...interface{}) *MockDwClientService_ResumeCluster_Call { + return &MockDwClientService_ResumeCluster_Call{Call: _e.mock.On("ResumeCluster", + append([]interface{}{params}, opts...)...)} +} + +func (_c *MockDwClientService_ResumeCluster_Call) Run(run func(params *operations.ResumeClusterParams, opts ...operations.ClientOption)) *MockDwClientService_ResumeCluster_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]operations.ClientOption, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(operations.ClientOption) + } + } + run(args[0].(*operations.ResumeClusterParams), variadicArgs...) + }) + return _c +} + +func (_c *MockDwClientService_ResumeCluster_Call) Return(_a0 *operations.ResumeClusterOK, _a1 error) *MockDwClientService_ResumeCluster_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDwClientService_ResumeCluster_Call) RunAndReturn(run func(*operations.ResumeClusterParams, ...operations.ClientOption) (*operations.ResumeClusterOK, error)) *MockDwClientService_ResumeCluster_Call { + _c.Call.Return(run) + return _c +} + +// SetTransport provides a mock function with given fields: transport +func (_m *MockDwClientService) SetTransport(transport runtime.ClientTransport) { + _m.Called(transport) +} + +// MockDwClientService_SetTransport_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetTransport' +type MockDwClientService_SetTransport_Call struct { + *mock.Call +} + +// SetTransport is a helper method to define mock.On call +// - transport runtime.ClientTransport +func (_e *MockDwClientService_Expecter) SetTransport(transport interface{}) *MockDwClientService_SetTransport_Call { + return &MockDwClientService_SetTransport_Call{Call: _e.mock.On("SetTransport", transport)} +} + +func (_c *MockDwClientService_SetTransport_Call) Run(run func(transport runtime.ClientTransport)) *MockDwClientService_SetTransport_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(runtime.ClientTransport)) + }) + return _c +} + +func (_c *MockDwClientService_SetTransport_Call) Return() *MockDwClientService_SetTransport_Call { + _c.Call.Return() + return _c +} + +func (_c *MockDwClientService_SetTransport_Call) RunAndReturn(run func(runtime.ClientTransport)) *MockDwClientService_SetTransport_Call { + _c.Call.Return(run) + return _c +} + +// StartVw provides a mock function with given fields: params, opts +func (_m *MockDwClientService) StartVw(params *operations.StartVwParams, opts ...operations.ClientOption) (*operations.StartVwOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for StartVw") + } + + var r0 *operations.StartVwOK + var r1 error + if rf, ok := ret.Get(0).(func(*operations.StartVwParams, ...operations.ClientOption) (*operations.StartVwOK, error)); ok { + return rf(params, opts...) + } + if rf, ok := ret.Get(0).(func(*operations.StartVwParams, ...operations.ClientOption) *operations.StartVwOK); ok { + r0 = rf(params, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*operations.StartVwOK) + } + } + + if rf, ok := ret.Get(1).(func(*operations.StartVwParams, ...operations.ClientOption) error); ok { + r1 = rf(params, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDwClientService_StartVw_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StartVw' +type MockDwClientService_StartVw_Call struct { + *mock.Call +} + +// StartVw is a helper method to define mock.On call +// - params *operations.StartVwParams +// - opts ...operations.ClientOption +func (_e *MockDwClientService_Expecter) StartVw(params interface{}, opts ...interface{}) *MockDwClientService_StartVw_Call { + return &MockDwClientService_StartVw_Call{Call: _e.mock.On("StartVw", + append([]interface{}{params}, opts...)...)} +} + +func (_c *MockDwClientService_StartVw_Call) Run(run func(params *operations.StartVwParams, opts ...operations.ClientOption)) *MockDwClientService_StartVw_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]operations.ClientOption, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(operations.ClientOption) + } + } + run(args[0].(*operations.StartVwParams), variadicArgs...) + }) + return _c +} + +func (_c *MockDwClientService_StartVw_Call) Return(_a0 *operations.StartVwOK, _a1 error) *MockDwClientService_StartVw_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDwClientService_StartVw_Call) RunAndReturn(run func(*operations.StartVwParams, ...operations.ClientOption) (*operations.StartVwOK, error)) *MockDwClientService_StartVw_Call { + _c.Call.Return(run) + return _c +} + +// SuspendCluster provides a mock function with given fields: params, opts +func (_m *MockDwClientService) SuspendCluster(params *operations.SuspendClusterParams, opts ...operations.ClientOption) (*operations.SuspendClusterOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for SuspendCluster") + } + + var r0 *operations.SuspendClusterOK + var r1 error + if rf, ok := ret.Get(0).(func(*operations.SuspendClusterParams, ...operations.ClientOption) (*operations.SuspendClusterOK, error)); ok { + return rf(params, opts...) + } + if rf, ok := ret.Get(0).(func(*operations.SuspendClusterParams, ...operations.ClientOption) *operations.SuspendClusterOK); ok { + r0 = rf(params, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*operations.SuspendClusterOK) + } + } + + if rf, ok := ret.Get(1).(func(*operations.SuspendClusterParams, ...operations.ClientOption) error); ok { + r1 = rf(params, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDwClientService_SuspendCluster_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SuspendCluster' +type MockDwClientService_SuspendCluster_Call struct { + *mock.Call +} + +// SuspendCluster is a helper method to define mock.On call +// - params *operations.SuspendClusterParams +// - opts ...operations.ClientOption +func (_e *MockDwClientService_Expecter) SuspendCluster(params interface{}, opts ...interface{}) *MockDwClientService_SuspendCluster_Call { + return &MockDwClientService_SuspendCluster_Call{Call: _e.mock.On("SuspendCluster", + append([]interface{}{params}, opts...)...)} +} + +func (_c *MockDwClientService_SuspendCluster_Call) Run(run func(params *operations.SuspendClusterParams, opts ...operations.ClientOption)) *MockDwClientService_SuspendCluster_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]operations.ClientOption, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(operations.ClientOption) + } + } + run(args[0].(*operations.SuspendClusterParams), variadicArgs...) + }) + return _c +} + +func (_c *MockDwClientService_SuspendCluster_Call) Return(_a0 *operations.SuspendClusterOK, _a1 error) *MockDwClientService_SuspendCluster_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDwClientService_SuspendCluster_Call) RunAndReturn(run func(*operations.SuspendClusterParams, ...operations.ClientOption) (*operations.SuspendClusterOK, error)) *MockDwClientService_SuspendCluster_Call { + _c.Call.Return(run) + return _c +} + +// SuspendDbc provides a mock function with given fields: params, opts +func (_m *MockDwClientService) SuspendDbc(params *operations.SuspendDbcParams, opts ...operations.ClientOption) (*operations.SuspendDbcOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for SuspendDbc") + } + + var r0 *operations.SuspendDbcOK + var r1 error + if rf, ok := ret.Get(0).(func(*operations.SuspendDbcParams, ...operations.ClientOption) (*operations.SuspendDbcOK, error)); ok { + return rf(params, opts...) + } + if rf, ok := ret.Get(0).(func(*operations.SuspendDbcParams, ...operations.ClientOption) *operations.SuspendDbcOK); ok { + r0 = rf(params, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*operations.SuspendDbcOK) + } + } + + if rf, ok := ret.Get(1).(func(*operations.SuspendDbcParams, ...operations.ClientOption) error); ok { + r1 = rf(params, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDwClientService_SuspendDbc_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SuspendDbc' +type MockDwClientService_SuspendDbc_Call struct { + *mock.Call +} + +// SuspendDbc is a helper method to define mock.On call +// - params *operations.SuspendDbcParams +// - opts ...operations.ClientOption +func (_e *MockDwClientService_Expecter) SuspendDbc(params interface{}, opts ...interface{}) *MockDwClientService_SuspendDbc_Call { + return &MockDwClientService_SuspendDbc_Call{Call: _e.mock.On("SuspendDbc", + append([]interface{}{params}, opts...)...)} +} + +func (_c *MockDwClientService_SuspendDbc_Call) Run(run func(params *operations.SuspendDbcParams, opts ...operations.ClientOption)) *MockDwClientService_SuspendDbc_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]operations.ClientOption, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(operations.ClientOption) + } + } + run(args[0].(*operations.SuspendDbcParams), variadicArgs...) + }) + return _c +} + +func (_c *MockDwClientService_SuspendDbc_Call) Return(_a0 *operations.SuspendDbcOK, _a1 error) *MockDwClientService_SuspendDbc_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDwClientService_SuspendDbc_Call) RunAndReturn(run func(*operations.SuspendDbcParams, ...operations.ClientOption) (*operations.SuspendDbcOK, error)) *MockDwClientService_SuspendDbc_Call { + _c.Call.Return(run) + return _c +} + +// SuspendVw provides a mock function with given fields: params, opts +func (_m *MockDwClientService) SuspendVw(params *operations.SuspendVwParams, opts ...operations.ClientOption) (*operations.SuspendVwOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for SuspendVw") + } + + var r0 *operations.SuspendVwOK + var r1 error + if rf, ok := ret.Get(0).(func(*operations.SuspendVwParams, ...operations.ClientOption) (*operations.SuspendVwOK, error)); ok { + return rf(params, opts...) + } + if rf, ok := ret.Get(0).(func(*operations.SuspendVwParams, ...operations.ClientOption) *operations.SuspendVwOK); ok { + r0 = rf(params, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*operations.SuspendVwOK) + } + } + + if rf, ok := ret.Get(1).(func(*operations.SuspendVwParams, ...operations.ClientOption) error); ok { + r1 = rf(params, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDwClientService_SuspendVw_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SuspendVw' +type MockDwClientService_SuspendVw_Call struct { + *mock.Call +} + +// SuspendVw is a helper method to define mock.On call +// - params *operations.SuspendVwParams +// - opts ...operations.ClientOption +func (_e *MockDwClientService_Expecter) SuspendVw(params interface{}, opts ...interface{}) *MockDwClientService_SuspendVw_Call { + return &MockDwClientService_SuspendVw_Call{Call: _e.mock.On("SuspendVw", + append([]interface{}{params}, opts...)...)} +} + +func (_c *MockDwClientService_SuspendVw_Call) Run(run func(params *operations.SuspendVwParams, opts ...operations.ClientOption)) *MockDwClientService_SuspendVw_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]operations.ClientOption, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(operations.ClientOption) + } + } + run(args[0].(*operations.SuspendVwParams), variadicArgs...) + }) + return _c +} + +func (_c *MockDwClientService_SuspendVw_Call) Return(_a0 *operations.SuspendVwOK, _a1 error) *MockDwClientService_SuspendVw_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDwClientService_SuspendVw_Call) RunAndReturn(run func(*operations.SuspendVwParams, ...operations.ClientOption) (*operations.SuspendVwOK, error)) *MockDwClientService_SuspendVw_Call { + _c.Call.Return(run) + return _c +} + +// UpdateAwsCluster provides a mock function with given fields: params, opts +func (_m *MockDwClientService) UpdateAwsCluster(params *operations.UpdateAwsClusterParams, opts ...operations.ClientOption) (*operations.UpdateAwsClusterOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for UpdateAwsCluster") + } + + var r0 *operations.UpdateAwsClusterOK + var r1 error + if rf, ok := ret.Get(0).(func(*operations.UpdateAwsClusterParams, ...operations.ClientOption) (*operations.UpdateAwsClusterOK, error)); ok { + return rf(params, opts...) + } + if rf, ok := ret.Get(0).(func(*operations.UpdateAwsClusterParams, ...operations.ClientOption) *operations.UpdateAwsClusterOK); ok { + r0 = rf(params, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*operations.UpdateAwsClusterOK) + } + } + + if rf, ok := ret.Get(1).(func(*operations.UpdateAwsClusterParams, ...operations.ClientOption) error); ok { + r1 = rf(params, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDwClientService_UpdateAwsCluster_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateAwsCluster' +type MockDwClientService_UpdateAwsCluster_Call struct { + *mock.Call +} + +// UpdateAwsCluster is a helper method to define mock.On call +// - params *operations.UpdateAwsClusterParams +// - opts ...operations.ClientOption +func (_e *MockDwClientService_Expecter) UpdateAwsCluster(params interface{}, opts ...interface{}) *MockDwClientService_UpdateAwsCluster_Call { + return &MockDwClientService_UpdateAwsCluster_Call{Call: _e.mock.On("UpdateAwsCluster", + append([]interface{}{params}, opts...)...)} +} + +func (_c *MockDwClientService_UpdateAwsCluster_Call) Run(run func(params *operations.UpdateAwsClusterParams, opts ...operations.ClientOption)) *MockDwClientService_UpdateAwsCluster_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]operations.ClientOption, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(operations.ClientOption) + } + } + run(args[0].(*operations.UpdateAwsClusterParams), variadicArgs...) + }) + return _c +} + +func (_c *MockDwClientService_UpdateAwsCluster_Call) Return(_a0 *operations.UpdateAwsClusterOK, _a1 error) *MockDwClientService_UpdateAwsCluster_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDwClientService_UpdateAwsCluster_Call) RunAndReturn(run func(*operations.UpdateAwsClusterParams, ...operations.ClientOption) (*operations.UpdateAwsClusterOK, error)) *MockDwClientService_UpdateAwsCluster_Call { + _c.Call.Return(run) + return _c +} + +// UpdateAzureCluster provides a mock function with given fields: params, opts +func (_m *MockDwClientService) UpdateAzureCluster(params *operations.UpdateAzureClusterParams, opts ...operations.ClientOption) (*operations.UpdateAzureClusterOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for UpdateAzureCluster") + } + + var r0 *operations.UpdateAzureClusterOK + var r1 error + if rf, ok := ret.Get(0).(func(*operations.UpdateAzureClusterParams, ...operations.ClientOption) (*operations.UpdateAzureClusterOK, error)); ok { + return rf(params, opts...) + } + if rf, ok := ret.Get(0).(func(*operations.UpdateAzureClusterParams, ...operations.ClientOption) *operations.UpdateAzureClusterOK); ok { + r0 = rf(params, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*operations.UpdateAzureClusterOK) + } + } + + if rf, ok := ret.Get(1).(func(*operations.UpdateAzureClusterParams, ...operations.ClientOption) error); ok { + r1 = rf(params, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDwClientService_UpdateAzureCluster_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateAzureCluster' +type MockDwClientService_UpdateAzureCluster_Call struct { + *mock.Call +} + +// UpdateAzureCluster is a helper method to define mock.On call +// - params *operations.UpdateAzureClusterParams +// - opts ...operations.ClientOption +func (_e *MockDwClientService_Expecter) UpdateAzureCluster(params interface{}, opts ...interface{}) *MockDwClientService_UpdateAzureCluster_Call { + return &MockDwClientService_UpdateAzureCluster_Call{Call: _e.mock.On("UpdateAzureCluster", + append([]interface{}{params}, opts...)...)} +} + +func (_c *MockDwClientService_UpdateAzureCluster_Call) Run(run func(params *operations.UpdateAzureClusterParams, opts ...operations.ClientOption)) *MockDwClientService_UpdateAzureCluster_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]operations.ClientOption, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(operations.ClientOption) + } + } + run(args[0].(*operations.UpdateAzureClusterParams), variadicArgs...) + }) + return _c +} + +func (_c *MockDwClientService_UpdateAzureCluster_Call) Return(_a0 *operations.UpdateAzureClusterOK, _a1 error) *MockDwClientService_UpdateAzureCluster_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDwClientService_UpdateAzureCluster_Call) RunAndReturn(run func(*operations.UpdateAzureClusterParams, ...operations.ClientOption) (*operations.UpdateAzureClusterOK, error)) *MockDwClientService_UpdateAzureCluster_Call { + _c.Call.Return(run) + return _c +} + +// UpdateCluster provides a mock function with given fields: params, opts +func (_m *MockDwClientService) UpdateCluster(params *operations.UpdateClusterParams, opts ...operations.ClientOption) (*operations.UpdateClusterOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for UpdateCluster") + } + + var r0 *operations.UpdateClusterOK + var r1 error + if rf, ok := ret.Get(0).(func(*operations.UpdateClusterParams, ...operations.ClientOption) (*operations.UpdateClusterOK, error)); ok { + return rf(params, opts...) + } + if rf, ok := ret.Get(0).(func(*operations.UpdateClusterParams, ...operations.ClientOption) *operations.UpdateClusterOK); ok { + r0 = rf(params, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*operations.UpdateClusterOK) + } + } + + if rf, ok := ret.Get(1).(func(*operations.UpdateClusterParams, ...operations.ClientOption) error); ok { + r1 = rf(params, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDwClientService_UpdateCluster_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateCluster' +type MockDwClientService_UpdateCluster_Call struct { + *mock.Call +} + +// UpdateCluster is a helper method to define mock.On call +// - params *operations.UpdateClusterParams +// - opts ...operations.ClientOption +func (_e *MockDwClientService_Expecter) UpdateCluster(params interface{}, opts ...interface{}) *MockDwClientService_UpdateCluster_Call { + return &MockDwClientService_UpdateCluster_Call{Call: _e.mock.On("UpdateCluster", + append([]interface{}{params}, opts...)...)} +} + +func (_c *MockDwClientService_UpdateCluster_Call) Run(run func(params *operations.UpdateClusterParams, opts ...operations.ClientOption)) *MockDwClientService_UpdateCluster_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]operations.ClientOption, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(operations.ClientOption) + } + } + run(args[0].(*operations.UpdateClusterParams), variadicArgs...) + }) + return _c +} + +func (_c *MockDwClientService_UpdateCluster_Call) Return(_a0 *operations.UpdateClusterOK, _a1 error) *MockDwClientService_UpdateCluster_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDwClientService_UpdateCluster_Call) RunAndReturn(run func(*operations.UpdateClusterParams, ...operations.ClientOption) (*operations.UpdateClusterOK, error)) *MockDwClientService_UpdateCluster_Call { + _c.Call.Return(run) + return _c +} + +// UpdateDataVisualization provides a mock function with given fields: params, opts +func (_m *MockDwClientService) UpdateDataVisualization(params *operations.UpdateDataVisualizationParams, opts ...operations.ClientOption) (*operations.UpdateDataVisualizationOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for UpdateDataVisualization") + } + + var r0 *operations.UpdateDataVisualizationOK + var r1 error + if rf, ok := ret.Get(0).(func(*operations.UpdateDataVisualizationParams, ...operations.ClientOption) (*operations.UpdateDataVisualizationOK, error)); ok { + return rf(params, opts...) + } + if rf, ok := ret.Get(0).(func(*operations.UpdateDataVisualizationParams, ...operations.ClientOption) *operations.UpdateDataVisualizationOK); ok { + r0 = rf(params, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*operations.UpdateDataVisualizationOK) + } + } + + if rf, ok := ret.Get(1).(func(*operations.UpdateDataVisualizationParams, ...operations.ClientOption) error); ok { + r1 = rf(params, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDwClientService_UpdateDataVisualization_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateDataVisualization' +type MockDwClientService_UpdateDataVisualization_Call struct { + *mock.Call +} + +// UpdateDataVisualization is a helper method to define mock.On call +// - params *operations.UpdateDataVisualizationParams +// - opts ...operations.ClientOption +func (_e *MockDwClientService_Expecter) UpdateDataVisualization(params interface{}, opts ...interface{}) *MockDwClientService_UpdateDataVisualization_Call { + return &MockDwClientService_UpdateDataVisualization_Call{Call: _e.mock.On("UpdateDataVisualization", + append([]interface{}{params}, opts...)...)} +} + +func (_c *MockDwClientService_UpdateDataVisualization_Call) Run(run func(params *operations.UpdateDataVisualizationParams, opts ...operations.ClientOption)) *MockDwClientService_UpdateDataVisualization_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]operations.ClientOption, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(operations.ClientOption) + } + } + run(args[0].(*operations.UpdateDataVisualizationParams), variadicArgs...) + }) + return _c +} + +func (_c *MockDwClientService_UpdateDataVisualization_Call) Return(_a0 *operations.UpdateDataVisualizationOK, _a1 error) *MockDwClientService_UpdateDataVisualization_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDwClientService_UpdateDataVisualization_Call) RunAndReturn(run func(*operations.UpdateDataVisualizationParams, ...operations.ClientOption) (*operations.UpdateDataVisualizationOK, error)) *MockDwClientService_UpdateDataVisualization_Call { + _c.Call.Return(run) + return _c +} + +// UpdateDbc provides a mock function with given fields: params, opts +func (_m *MockDwClientService) UpdateDbc(params *operations.UpdateDbcParams, opts ...operations.ClientOption) (*operations.UpdateDbcOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for UpdateDbc") + } + + var r0 *operations.UpdateDbcOK + var r1 error + if rf, ok := ret.Get(0).(func(*operations.UpdateDbcParams, ...operations.ClientOption) (*operations.UpdateDbcOK, error)); ok { + return rf(params, opts...) + } + if rf, ok := ret.Get(0).(func(*operations.UpdateDbcParams, ...operations.ClientOption) *operations.UpdateDbcOK); ok { + r0 = rf(params, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*operations.UpdateDbcOK) + } + } + + if rf, ok := ret.Get(1).(func(*operations.UpdateDbcParams, ...operations.ClientOption) error); ok { + r1 = rf(params, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDwClientService_UpdateDbc_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateDbc' +type MockDwClientService_UpdateDbc_Call struct { + *mock.Call +} + +// UpdateDbc is a helper method to define mock.On call +// - params *operations.UpdateDbcParams +// - opts ...operations.ClientOption +func (_e *MockDwClientService_Expecter) UpdateDbc(params interface{}, opts ...interface{}) *MockDwClientService_UpdateDbc_Call { + return &MockDwClientService_UpdateDbc_Call{Call: _e.mock.On("UpdateDbc", + append([]interface{}{params}, opts...)...)} +} + +func (_c *MockDwClientService_UpdateDbc_Call) Run(run func(params *operations.UpdateDbcParams, opts ...operations.ClientOption)) *MockDwClientService_UpdateDbc_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]operations.ClientOption, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(operations.ClientOption) + } + } + run(args[0].(*operations.UpdateDbcParams), variadicArgs...) + }) + return _c +} + +func (_c *MockDwClientService_UpdateDbc_Call) Return(_a0 *operations.UpdateDbcOK, _a1 error) *MockDwClientService_UpdateDbc_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDwClientService_UpdateDbc_Call) RunAndReturn(run func(*operations.UpdateDbcParams, ...operations.ClientOption) (*operations.UpdateDbcOK, error)) *MockDwClientService_UpdateDbc_Call { + _c.Call.Return(run) + return _c +} + +// UpdateDbcConfig provides a mock function with given fields: params, opts +func (_m *MockDwClientService) UpdateDbcConfig(params *operations.UpdateDbcConfigParams, opts ...operations.ClientOption) (*operations.UpdateDbcConfigOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for UpdateDbcConfig") + } + + var r0 *operations.UpdateDbcConfigOK + var r1 error + if rf, ok := ret.Get(0).(func(*operations.UpdateDbcConfigParams, ...operations.ClientOption) (*operations.UpdateDbcConfigOK, error)); ok { + return rf(params, opts...) + } + if rf, ok := ret.Get(0).(func(*operations.UpdateDbcConfigParams, ...operations.ClientOption) *operations.UpdateDbcConfigOK); ok { + r0 = rf(params, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*operations.UpdateDbcConfigOK) + } + } + + if rf, ok := ret.Get(1).(func(*operations.UpdateDbcConfigParams, ...operations.ClientOption) error); ok { + r1 = rf(params, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDwClientService_UpdateDbcConfig_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateDbcConfig' +type MockDwClientService_UpdateDbcConfig_Call struct { + *mock.Call +} + +// UpdateDbcConfig is a helper method to define mock.On call +// - params *operations.UpdateDbcConfigParams +// - opts ...operations.ClientOption +func (_e *MockDwClientService_Expecter) UpdateDbcConfig(params interface{}, opts ...interface{}) *MockDwClientService_UpdateDbcConfig_Call { + return &MockDwClientService_UpdateDbcConfig_Call{Call: _e.mock.On("UpdateDbcConfig", + append([]interface{}{params}, opts...)...)} +} + +func (_c *MockDwClientService_UpdateDbcConfig_Call) Run(run func(params *operations.UpdateDbcConfigParams, opts ...operations.ClientOption)) *MockDwClientService_UpdateDbcConfig_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]operations.ClientOption, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(operations.ClientOption) + } + } + run(args[0].(*operations.UpdateDbcConfigParams), variadicArgs...) + }) + return _c +} + +func (_c *MockDwClientService_UpdateDbcConfig_Call) Return(_a0 *operations.UpdateDbcConfigOK, _a1 error) *MockDwClientService_UpdateDbcConfig_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDwClientService_UpdateDbcConfig_Call) RunAndReturn(run func(*operations.UpdateDbcConfigParams, ...operations.ClientOption) (*operations.UpdateDbcConfigOK, error)) *MockDwClientService_UpdateDbcConfig_Call { + _c.Call.Return(run) + return _c +} + +// UpdatePrivateCluster provides a mock function with given fields: params, opts +func (_m *MockDwClientService) UpdatePrivateCluster(params *operations.UpdatePrivateClusterParams, opts ...operations.ClientOption) (*operations.UpdatePrivateClusterOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for UpdatePrivateCluster") + } + + var r0 *operations.UpdatePrivateClusterOK + var r1 error + if rf, ok := ret.Get(0).(func(*operations.UpdatePrivateClusterParams, ...operations.ClientOption) (*operations.UpdatePrivateClusterOK, error)); ok { + return rf(params, opts...) + } + if rf, ok := ret.Get(0).(func(*operations.UpdatePrivateClusterParams, ...operations.ClientOption) *operations.UpdatePrivateClusterOK); ok { + r0 = rf(params, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*operations.UpdatePrivateClusterOK) + } + } + + if rf, ok := ret.Get(1).(func(*operations.UpdatePrivateClusterParams, ...operations.ClientOption) error); ok { + r1 = rf(params, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDwClientService_UpdatePrivateCluster_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdatePrivateCluster' +type MockDwClientService_UpdatePrivateCluster_Call struct { + *mock.Call +} + +// UpdatePrivateCluster is a helper method to define mock.On call +// - params *operations.UpdatePrivateClusterParams +// - opts ...operations.ClientOption +func (_e *MockDwClientService_Expecter) UpdatePrivateCluster(params interface{}, opts ...interface{}) *MockDwClientService_UpdatePrivateCluster_Call { + return &MockDwClientService_UpdatePrivateCluster_Call{Call: _e.mock.On("UpdatePrivateCluster", + append([]interface{}{params}, opts...)...)} +} + +func (_c *MockDwClientService_UpdatePrivateCluster_Call) Run(run func(params *operations.UpdatePrivateClusterParams, opts ...operations.ClientOption)) *MockDwClientService_UpdatePrivateCluster_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]operations.ClientOption, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(operations.ClientOption) + } + } + run(args[0].(*operations.UpdatePrivateClusterParams), variadicArgs...) + }) + return _c +} + +func (_c *MockDwClientService_UpdatePrivateCluster_Call) Return(_a0 *operations.UpdatePrivateClusterOK, _a1 error) *MockDwClientService_UpdatePrivateCluster_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDwClientService_UpdatePrivateCluster_Call) RunAndReturn(run func(*operations.UpdatePrivateClusterParams, ...operations.ClientOption) (*operations.UpdatePrivateClusterOK, error)) *MockDwClientService_UpdatePrivateCluster_Call { + _c.Call.Return(run) + return _c +} + +// UpdateSSHKey provides a mock function with given fields: params, opts +func (_m *MockDwClientService) UpdateSSHKey(params *operations.UpdateSSHKeyParams, opts ...operations.ClientOption) (*operations.UpdateSSHKeyOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for UpdateSSHKey") + } + + var r0 *operations.UpdateSSHKeyOK + var r1 error + if rf, ok := ret.Get(0).(func(*operations.UpdateSSHKeyParams, ...operations.ClientOption) (*operations.UpdateSSHKeyOK, error)); ok { + return rf(params, opts...) + } + if rf, ok := ret.Get(0).(func(*operations.UpdateSSHKeyParams, ...operations.ClientOption) *operations.UpdateSSHKeyOK); ok { + r0 = rf(params, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*operations.UpdateSSHKeyOK) + } + } + + if rf, ok := ret.Get(1).(func(*operations.UpdateSSHKeyParams, ...operations.ClientOption) error); ok { + r1 = rf(params, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDwClientService_UpdateSSHKey_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateSSHKey' +type MockDwClientService_UpdateSSHKey_Call struct { + *mock.Call +} + +// UpdateSSHKey is a helper method to define mock.On call +// - params *operations.UpdateSSHKeyParams +// - opts ...operations.ClientOption +func (_e *MockDwClientService_Expecter) UpdateSSHKey(params interface{}, opts ...interface{}) *MockDwClientService_UpdateSSHKey_Call { + return &MockDwClientService_UpdateSSHKey_Call{Call: _e.mock.On("UpdateSSHKey", + append([]interface{}{params}, opts...)...)} +} + +func (_c *MockDwClientService_UpdateSSHKey_Call) Run(run func(params *operations.UpdateSSHKeyParams, opts ...operations.ClientOption)) *MockDwClientService_UpdateSSHKey_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]operations.ClientOption, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(operations.ClientOption) + } + } + run(args[0].(*operations.UpdateSSHKeyParams), variadicArgs...) + }) + return _c +} + +func (_c *MockDwClientService_UpdateSSHKey_Call) Return(_a0 *operations.UpdateSSHKeyOK, _a1 error) *MockDwClientService_UpdateSSHKey_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDwClientService_UpdateSSHKey_Call) RunAndReturn(run func(*operations.UpdateSSHKeyParams, ...operations.ClientOption) (*operations.UpdateSSHKeyOK, error)) *MockDwClientService_UpdateSSHKey_Call { + _c.Call.Return(run) + return _c +} + +// UpdateServerSetting provides a mock function with given fields: params, opts +func (_m *MockDwClientService) UpdateServerSetting(params *operations.UpdateServerSettingParams, opts ...operations.ClientOption) (*operations.UpdateServerSettingOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for UpdateServerSetting") + } + + var r0 *operations.UpdateServerSettingOK + var r1 error + if rf, ok := ret.Get(0).(func(*operations.UpdateServerSettingParams, ...operations.ClientOption) (*operations.UpdateServerSettingOK, error)); ok { + return rf(params, opts...) + } + if rf, ok := ret.Get(0).(func(*operations.UpdateServerSettingParams, ...operations.ClientOption) *operations.UpdateServerSettingOK); ok { + r0 = rf(params, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*operations.UpdateServerSettingOK) + } + } + + if rf, ok := ret.Get(1).(func(*operations.UpdateServerSettingParams, ...operations.ClientOption) error); ok { + r1 = rf(params, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDwClientService_UpdateServerSetting_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateServerSetting' +type MockDwClientService_UpdateServerSetting_Call struct { + *mock.Call +} + +// UpdateServerSetting is a helper method to define mock.On call +// - params *operations.UpdateServerSettingParams +// - opts ...operations.ClientOption +func (_e *MockDwClientService_Expecter) UpdateServerSetting(params interface{}, opts ...interface{}) *MockDwClientService_UpdateServerSetting_Call { + return &MockDwClientService_UpdateServerSetting_Call{Call: _e.mock.On("UpdateServerSetting", + append([]interface{}{params}, opts...)...)} +} + +func (_c *MockDwClientService_UpdateServerSetting_Call) Run(run func(params *operations.UpdateServerSettingParams, opts ...operations.ClientOption)) *MockDwClientService_UpdateServerSetting_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]operations.ClientOption, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(operations.ClientOption) + } + } + run(args[0].(*operations.UpdateServerSettingParams), variadicArgs...) + }) + return _c +} + +func (_c *MockDwClientService_UpdateServerSetting_Call) Return(_a0 *operations.UpdateServerSettingOK, _a1 error) *MockDwClientService_UpdateServerSetting_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDwClientService_UpdateServerSetting_Call) RunAndReturn(run func(*operations.UpdateServerSettingParams, ...operations.ClientOption) (*operations.UpdateServerSettingOK, error)) *MockDwClientService_UpdateServerSetting_Call { + _c.Call.Return(run) + return _c +} + +// UpdateVw provides a mock function with given fields: params, opts +func (_m *MockDwClientService) UpdateVw(params *operations.UpdateVwParams, opts ...operations.ClientOption) (*operations.UpdateVwOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for UpdateVw") + } + + var r0 *operations.UpdateVwOK + var r1 error + if rf, ok := ret.Get(0).(func(*operations.UpdateVwParams, ...operations.ClientOption) (*operations.UpdateVwOK, error)); ok { + return rf(params, opts...) + } + if rf, ok := ret.Get(0).(func(*operations.UpdateVwParams, ...operations.ClientOption) *operations.UpdateVwOK); ok { + r0 = rf(params, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*operations.UpdateVwOK) + } + } + + if rf, ok := ret.Get(1).(func(*operations.UpdateVwParams, ...operations.ClientOption) error); ok { + r1 = rf(params, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDwClientService_UpdateVw_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateVw' +type MockDwClientService_UpdateVw_Call struct { + *mock.Call +} + +// UpdateVw is a helper method to define mock.On call +// - params *operations.UpdateVwParams +// - opts ...operations.ClientOption +func (_e *MockDwClientService_Expecter) UpdateVw(params interface{}, opts ...interface{}) *MockDwClientService_UpdateVw_Call { + return &MockDwClientService_UpdateVw_Call{Call: _e.mock.On("UpdateVw", + append([]interface{}{params}, opts...)...)} +} + +func (_c *MockDwClientService_UpdateVw_Call) Run(run func(params *operations.UpdateVwParams, opts ...operations.ClientOption)) *MockDwClientService_UpdateVw_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]operations.ClientOption, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(operations.ClientOption) + } + } + run(args[0].(*operations.UpdateVwParams), variadicArgs...) + }) + return _c +} + +func (_c *MockDwClientService_UpdateVw_Call) Return(_a0 *operations.UpdateVwOK, _a1 error) *MockDwClientService_UpdateVw_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDwClientService_UpdateVw_Call) RunAndReturn(run func(*operations.UpdateVwParams, ...operations.ClientOption) (*operations.UpdateVwOK, error)) *MockDwClientService_UpdateVw_Call { + _c.Call.Return(run) + return _c +} + +// UpdateVwConfig provides a mock function with given fields: params, opts +func (_m *MockDwClientService) UpdateVwConfig(params *operations.UpdateVwConfigParams, opts ...operations.ClientOption) (*operations.UpdateVwConfigOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for UpdateVwConfig") + } + + var r0 *operations.UpdateVwConfigOK + var r1 error + if rf, ok := ret.Get(0).(func(*operations.UpdateVwConfigParams, ...operations.ClientOption) (*operations.UpdateVwConfigOK, error)); ok { + return rf(params, opts...) + } + if rf, ok := ret.Get(0).(func(*operations.UpdateVwConfigParams, ...operations.ClientOption) *operations.UpdateVwConfigOK); ok { + r0 = rf(params, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*operations.UpdateVwConfigOK) + } + } + + if rf, ok := ret.Get(1).(func(*operations.UpdateVwConfigParams, ...operations.ClientOption) error); ok { + r1 = rf(params, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDwClientService_UpdateVwConfig_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateVwConfig' +type MockDwClientService_UpdateVwConfig_Call struct { + *mock.Call +} + +// UpdateVwConfig is a helper method to define mock.On call +// - params *operations.UpdateVwConfigParams +// - opts ...operations.ClientOption +func (_e *MockDwClientService_Expecter) UpdateVwConfig(params interface{}, opts ...interface{}) *MockDwClientService_UpdateVwConfig_Call { + return &MockDwClientService_UpdateVwConfig_Call{Call: _e.mock.On("UpdateVwConfig", + append([]interface{}{params}, opts...)...)} +} + +func (_c *MockDwClientService_UpdateVwConfig_Call) Run(run func(params *operations.UpdateVwConfigParams, opts ...operations.ClientOption)) *MockDwClientService_UpdateVwConfig_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]operations.ClientOption, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(operations.ClientOption) + } + } + run(args[0].(*operations.UpdateVwConfigParams), variadicArgs...) + }) + return _c +} + +func (_c *MockDwClientService_UpdateVwConfig_Call) Return(_a0 *operations.UpdateVwConfigOK, _a1 error) *MockDwClientService_UpdateVwConfig_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDwClientService_UpdateVwConfig_Call) RunAndReturn(run func(*operations.UpdateVwConfigParams, ...operations.ClientOption) (*operations.UpdateVwConfigOK, error)) *MockDwClientService_UpdateVwConfig_Call { + _c.Call.Return(run) + return _c +} + +// UpgradeCluster provides a mock function with given fields: params, opts +func (_m *MockDwClientService) UpgradeCluster(params *operations.UpgradeClusterParams, opts ...operations.ClientOption) (*operations.UpgradeClusterOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for UpgradeCluster") + } + + var r0 *operations.UpgradeClusterOK + var r1 error + if rf, ok := ret.Get(0).(func(*operations.UpgradeClusterParams, ...operations.ClientOption) (*operations.UpgradeClusterOK, error)); ok { + return rf(params, opts...) + } + if rf, ok := ret.Get(0).(func(*operations.UpgradeClusterParams, ...operations.ClientOption) *operations.UpgradeClusterOK); ok { + r0 = rf(params, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*operations.UpgradeClusterOK) + } + } + + if rf, ok := ret.Get(1).(func(*operations.UpgradeClusterParams, ...operations.ClientOption) error); ok { + r1 = rf(params, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDwClientService_UpgradeCluster_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpgradeCluster' +type MockDwClientService_UpgradeCluster_Call struct { + *mock.Call +} + +// UpgradeCluster is a helper method to define mock.On call +// - params *operations.UpgradeClusterParams +// - opts ...operations.ClientOption +func (_e *MockDwClientService_Expecter) UpgradeCluster(params interface{}, opts ...interface{}) *MockDwClientService_UpgradeCluster_Call { + return &MockDwClientService_UpgradeCluster_Call{Call: _e.mock.On("UpgradeCluster", + append([]interface{}{params}, opts...)...)} +} + +func (_c *MockDwClientService_UpgradeCluster_Call) Run(run func(params *operations.UpgradeClusterParams, opts ...operations.ClientOption)) *MockDwClientService_UpgradeCluster_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]operations.ClientOption, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(operations.ClientOption) + } + } + run(args[0].(*operations.UpgradeClusterParams), variadicArgs...) + }) + return _c +} + +func (_c *MockDwClientService_UpgradeCluster_Call) Return(_a0 *operations.UpgradeClusterOK, _a1 error) *MockDwClientService_UpgradeCluster_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDwClientService_UpgradeCluster_Call) RunAndReturn(run func(*operations.UpgradeClusterParams, ...operations.ClientOption) (*operations.UpgradeClusterOK, error)) *MockDwClientService_UpgradeCluster_Call { + _c.Call.Return(run) + return _c +} + +// UpgradeDataVisualization provides a mock function with given fields: params, opts +func (_m *MockDwClientService) UpgradeDataVisualization(params *operations.UpgradeDataVisualizationParams, opts ...operations.ClientOption) (*operations.UpgradeDataVisualizationOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for UpgradeDataVisualization") + } + + var r0 *operations.UpgradeDataVisualizationOK + var r1 error + if rf, ok := ret.Get(0).(func(*operations.UpgradeDataVisualizationParams, ...operations.ClientOption) (*operations.UpgradeDataVisualizationOK, error)); ok { + return rf(params, opts...) + } + if rf, ok := ret.Get(0).(func(*operations.UpgradeDataVisualizationParams, ...operations.ClientOption) *operations.UpgradeDataVisualizationOK); ok { + r0 = rf(params, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*operations.UpgradeDataVisualizationOK) + } + } + + if rf, ok := ret.Get(1).(func(*operations.UpgradeDataVisualizationParams, ...operations.ClientOption) error); ok { + r1 = rf(params, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDwClientService_UpgradeDataVisualization_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpgradeDataVisualization' +type MockDwClientService_UpgradeDataVisualization_Call struct { + *mock.Call +} + +// UpgradeDataVisualization is a helper method to define mock.On call +// - params *operations.UpgradeDataVisualizationParams +// - opts ...operations.ClientOption +func (_e *MockDwClientService_Expecter) UpgradeDataVisualization(params interface{}, opts ...interface{}) *MockDwClientService_UpgradeDataVisualization_Call { + return &MockDwClientService_UpgradeDataVisualization_Call{Call: _e.mock.On("UpgradeDataVisualization", + append([]interface{}{params}, opts...)...)} +} + +func (_c *MockDwClientService_UpgradeDataVisualization_Call) Run(run func(params *operations.UpgradeDataVisualizationParams, opts ...operations.ClientOption)) *MockDwClientService_UpgradeDataVisualization_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]operations.ClientOption, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(operations.ClientOption) + } + } + run(args[0].(*operations.UpgradeDataVisualizationParams), variadicArgs...) + }) + return _c +} + +func (_c *MockDwClientService_UpgradeDataVisualization_Call) Return(_a0 *operations.UpgradeDataVisualizationOK, _a1 error) *MockDwClientService_UpgradeDataVisualization_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDwClientService_UpgradeDataVisualization_Call) RunAndReturn(run func(*operations.UpgradeDataVisualizationParams, ...operations.ClientOption) (*operations.UpgradeDataVisualizationOK, error)) *MockDwClientService_UpgradeDataVisualization_Call { + _c.Call.Return(run) + return _c +} + +// UpgradeDbc provides a mock function with given fields: params, opts +func (_m *MockDwClientService) UpgradeDbc(params *operations.UpgradeDbcParams, opts ...operations.ClientOption) (*operations.UpgradeDbcOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for UpgradeDbc") + } + + var r0 *operations.UpgradeDbcOK + var r1 error + if rf, ok := ret.Get(0).(func(*operations.UpgradeDbcParams, ...operations.ClientOption) (*operations.UpgradeDbcOK, error)); ok { + return rf(params, opts...) + } + if rf, ok := ret.Get(0).(func(*operations.UpgradeDbcParams, ...operations.ClientOption) *operations.UpgradeDbcOK); ok { + r0 = rf(params, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*operations.UpgradeDbcOK) + } + } + + if rf, ok := ret.Get(1).(func(*operations.UpgradeDbcParams, ...operations.ClientOption) error); ok { + r1 = rf(params, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDwClientService_UpgradeDbc_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpgradeDbc' +type MockDwClientService_UpgradeDbc_Call struct { + *mock.Call +} + +// UpgradeDbc is a helper method to define mock.On call +// - params *operations.UpgradeDbcParams +// - opts ...operations.ClientOption +func (_e *MockDwClientService_Expecter) UpgradeDbc(params interface{}, opts ...interface{}) *MockDwClientService_UpgradeDbc_Call { + return &MockDwClientService_UpgradeDbc_Call{Call: _e.mock.On("UpgradeDbc", + append([]interface{}{params}, opts...)...)} +} + +func (_c *MockDwClientService_UpgradeDbc_Call) Run(run func(params *operations.UpgradeDbcParams, opts ...operations.ClientOption)) *MockDwClientService_UpgradeDbc_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]operations.ClientOption, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(operations.ClientOption) + } + } + run(args[0].(*operations.UpgradeDbcParams), variadicArgs...) + }) + return _c +} + +func (_c *MockDwClientService_UpgradeDbc_Call) Return(_a0 *operations.UpgradeDbcOK, _a1 error) *MockDwClientService_UpgradeDbc_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDwClientService_UpgradeDbc_Call) RunAndReturn(run func(*operations.UpgradeDbcParams, ...operations.ClientOption) (*operations.UpgradeDbcOK, error)) *MockDwClientService_UpgradeDbc_Call { + _c.Call.Return(run) + return _c +} + +// UpgradeVw provides a mock function with given fields: params, opts +func (_m *MockDwClientService) UpgradeVw(params *operations.UpgradeVwParams, opts ...operations.ClientOption) (*operations.UpgradeVwOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for UpgradeVw") + } + + var r0 *operations.UpgradeVwOK + var r1 error + if rf, ok := ret.Get(0).(func(*operations.UpgradeVwParams, ...operations.ClientOption) (*operations.UpgradeVwOK, error)); ok { + return rf(params, opts...) + } + if rf, ok := ret.Get(0).(func(*operations.UpgradeVwParams, ...operations.ClientOption) *operations.UpgradeVwOK); ok { + r0 = rf(params, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*operations.UpgradeVwOK) + } + } + + if rf, ok := ret.Get(1).(func(*operations.UpgradeVwParams, ...operations.ClientOption) error); ok { + r1 = rf(params, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDwClientService_UpgradeVw_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpgradeVw' +type MockDwClientService_UpgradeVw_Call struct { + *mock.Call +} + +// UpgradeVw is a helper method to define mock.On call +// - params *operations.UpgradeVwParams +// - opts ...operations.ClientOption +func (_e *MockDwClientService_Expecter) UpgradeVw(params interface{}, opts ...interface{}) *MockDwClientService_UpgradeVw_Call { + return &MockDwClientService_UpgradeVw_Call{Call: _e.mock.On("UpgradeVw", + append([]interface{}{params}, opts...)...)} +} + +func (_c *MockDwClientService_UpgradeVw_Call) Run(run func(params *operations.UpgradeVwParams, opts ...operations.ClientOption)) *MockDwClientService_UpgradeVw_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]operations.ClientOption, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(operations.ClientOption) + } + } + run(args[0].(*operations.UpgradeVwParams), variadicArgs...) + }) + return _c +} + +func (_c *MockDwClientService_UpgradeVw_Call) Return(_a0 *operations.UpgradeVwOK, _a1 error) *MockDwClientService_UpgradeVw_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDwClientService_UpgradeVw_Call) RunAndReturn(run func(*operations.UpgradeVwParams, ...operations.ClientOption) (*operations.UpgradeVwOK, error)) *MockDwClientService_UpgradeVw_Call { + _c.Call.Return(run) + return _c +} + +// NewMockDwClientService creates a new instance of MockDwClientService. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockDwClientService(t interface { + mock.TestingT + Cleanup(func()) +}) *MockDwClientService { + mock := &MockDwClientService{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +}