github.com/jpreese/tflint@v0.19.2-0.20200908152133-b01686250fb6/client/aws_rds_mock.go (about) 1 // Code generated by MockGen. DO NOT EDIT. 2 // Source: github.com/aws/aws-sdk-go/service/rds/rdsiface (interfaces: RDSAPI) 3 4 // Package client is a generated GoMock package. 5 package client 6 7 import ( 8 context "context" 9 request "github.com/aws/aws-sdk-go/aws/request" 10 rds "github.com/aws/aws-sdk-go/service/rds" 11 gomock "github.com/golang/mock/gomock" 12 reflect "reflect" 13 ) 14 15 // MockRDSAPI is a mock of RDSAPI interface 16 type MockRDSAPI struct { 17 ctrl *gomock.Controller 18 recorder *MockRDSAPIMockRecorder 19 } 20 21 // MockRDSAPIMockRecorder is the mock recorder for MockRDSAPI 22 type MockRDSAPIMockRecorder struct { 23 mock *MockRDSAPI 24 } 25 26 // NewMockRDSAPI creates a new mock instance 27 func NewMockRDSAPI(ctrl *gomock.Controller) *MockRDSAPI { 28 mock := &MockRDSAPI{ctrl: ctrl} 29 mock.recorder = &MockRDSAPIMockRecorder{mock} 30 return mock 31 } 32 33 // EXPECT returns an object that allows the caller to indicate expected use 34 func (m *MockRDSAPI) EXPECT() *MockRDSAPIMockRecorder { 35 return m.recorder 36 } 37 38 // AddRoleToDBCluster mocks base method 39 func (m *MockRDSAPI) AddRoleToDBCluster(arg0 *rds.AddRoleToDBClusterInput) (*rds.AddRoleToDBClusterOutput, error) { 40 m.ctrl.T.Helper() 41 ret := m.ctrl.Call(m, "AddRoleToDBCluster", arg0) 42 ret0, _ := ret[0].(*rds.AddRoleToDBClusterOutput) 43 ret1, _ := ret[1].(error) 44 return ret0, ret1 45 } 46 47 // AddRoleToDBCluster indicates an expected call of AddRoleToDBCluster 48 func (mr *MockRDSAPIMockRecorder) AddRoleToDBCluster(arg0 interface{}) *gomock.Call { 49 mr.mock.ctrl.T.Helper() 50 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddRoleToDBCluster", reflect.TypeOf((*MockRDSAPI)(nil).AddRoleToDBCluster), arg0) 51 } 52 53 // AddRoleToDBClusterRequest mocks base method 54 func (m *MockRDSAPI) AddRoleToDBClusterRequest(arg0 *rds.AddRoleToDBClusterInput) (*request.Request, *rds.AddRoleToDBClusterOutput) { 55 m.ctrl.T.Helper() 56 ret := m.ctrl.Call(m, "AddRoleToDBClusterRequest", arg0) 57 ret0, _ := ret[0].(*request.Request) 58 ret1, _ := ret[1].(*rds.AddRoleToDBClusterOutput) 59 return ret0, ret1 60 } 61 62 // AddRoleToDBClusterRequest indicates an expected call of AddRoleToDBClusterRequest 63 func (mr *MockRDSAPIMockRecorder) AddRoleToDBClusterRequest(arg0 interface{}) *gomock.Call { 64 mr.mock.ctrl.T.Helper() 65 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddRoleToDBClusterRequest", reflect.TypeOf((*MockRDSAPI)(nil).AddRoleToDBClusterRequest), arg0) 66 } 67 68 // AddRoleToDBClusterWithContext mocks base method 69 func (m *MockRDSAPI) AddRoleToDBClusterWithContext(arg0 context.Context, arg1 *rds.AddRoleToDBClusterInput, arg2 ...request.Option) (*rds.AddRoleToDBClusterOutput, error) { 70 m.ctrl.T.Helper() 71 varargs := []interface{}{arg0, arg1} 72 for _, a := range arg2 { 73 varargs = append(varargs, a) 74 } 75 ret := m.ctrl.Call(m, "AddRoleToDBClusterWithContext", varargs...) 76 ret0, _ := ret[0].(*rds.AddRoleToDBClusterOutput) 77 ret1, _ := ret[1].(error) 78 return ret0, ret1 79 } 80 81 // AddRoleToDBClusterWithContext indicates an expected call of AddRoleToDBClusterWithContext 82 func (mr *MockRDSAPIMockRecorder) AddRoleToDBClusterWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 83 mr.mock.ctrl.T.Helper() 84 varargs := append([]interface{}{arg0, arg1}, arg2...) 85 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddRoleToDBClusterWithContext", reflect.TypeOf((*MockRDSAPI)(nil).AddRoleToDBClusterWithContext), varargs...) 86 } 87 88 // AddRoleToDBInstance mocks base method 89 func (m *MockRDSAPI) AddRoleToDBInstance(arg0 *rds.AddRoleToDBInstanceInput) (*rds.AddRoleToDBInstanceOutput, error) { 90 m.ctrl.T.Helper() 91 ret := m.ctrl.Call(m, "AddRoleToDBInstance", arg0) 92 ret0, _ := ret[0].(*rds.AddRoleToDBInstanceOutput) 93 ret1, _ := ret[1].(error) 94 return ret0, ret1 95 } 96 97 // AddRoleToDBInstance indicates an expected call of AddRoleToDBInstance 98 func (mr *MockRDSAPIMockRecorder) AddRoleToDBInstance(arg0 interface{}) *gomock.Call { 99 mr.mock.ctrl.T.Helper() 100 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddRoleToDBInstance", reflect.TypeOf((*MockRDSAPI)(nil).AddRoleToDBInstance), arg0) 101 } 102 103 // AddRoleToDBInstanceRequest mocks base method 104 func (m *MockRDSAPI) AddRoleToDBInstanceRequest(arg0 *rds.AddRoleToDBInstanceInput) (*request.Request, *rds.AddRoleToDBInstanceOutput) { 105 m.ctrl.T.Helper() 106 ret := m.ctrl.Call(m, "AddRoleToDBInstanceRequest", arg0) 107 ret0, _ := ret[0].(*request.Request) 108 ret1, _ := ret[1].(*rds.AddRoleToDBInstanceOutput) 109 return ret0, ret1 110 } 111 112 // AddRoleToDBInstanceRequest indicates an expected call of AddRoleToDBInstanceRequest 113 func (mr *MockRDSAPIMockRecorder) AddRoleToDBInstanceRequest(arg0 interface{}) *gomock.Call { 114 mr.mock.ctrl.T.Helper() 115 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddRoleToDBInstanceRequest", reflect.TypeOf((*MockRDSAPI)(nil).AddRoleToDBInstanceRequest), arg0) 116 } 117 118 // AddRoleToDBInstanceWithContext mocks base method 119 func (m *MockRDSAPI) AddRoleToDBInstanceWithContext(arg0 context.Context, arg1 *rds.AddRoleToDBInstanceInput, arg2 ...request.Option) (*rds.AddRoleToDBInstanceOutput, error) { 120 m.ctrl.T.Helper() 121 varargs := []interface{}{arg0, arg1} 122 for _, a := range arg2 { 123 varargs = append(varargs, a) 124 } 125 ret := m.ctrl.Call(m, "AddRoleToDBInstanceWithContext", varargs...) 126 ret0, _ := ret[0].(*rds.AddRoleToDBInstanceOutput) 127 ret1, _ := ret[1].(error) 128 return ret0, ret1 129 } 130 131 // AddRoleToDBInstanceWithContext indicates an expected call of AddRoleToDBInstanceWithContext 132 func (mr *MockRDSAPIMockRecorder) AddRoleToDBInstanceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 133 mr.mock.ctrl.T.Helper() 134 varargs := append([]interface{}{arg0, arg1}, arg2...) 135 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddRoleToDBInstanceWithContext", reflect.TypeOf((*MockRDSAPI)(nil).AddRoleToDBInstanceWithContext), varargs...) 136 } 137 138 // AddSourceIdentifierToSubscription mocks base method 139 func (m *MockRDSAPI) AddSourceIdentifierToSubscription(arg0 *rds.AddSourceIdentifierToSubscriptionInput) (*rds.AddSourceIdentifierToSubscriptionOutput, error) { 140 m.ctrl.T.Helper() 141 ret := m.ctrl.Call(m, "AddSourceIdentifierToSubscription", arg0) 142 ret0, _ := ret[0].(*rds.AddSourceIdentifierToSubscriptionOutput) 143 ret1, _ := ret[1].(error) 144 return ret0, ret1 145 } 146 147 // AddSourceIdentifierToSubscription indicates an expected call of AddSourceIdentifierToSubscription 148 func (mr *MockRDSAPIMockRecorder) AddSourceIdentifierToSubscription(arg0 interface{}) *gomock.Call { 149 mr.mock.ctrl.T.Helper() 150 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddSourceIdentifierToSubscription", reflect.TypeOf((*MockRDSAPI)(nil).AddSourceIdentifierToSubscription), arg0) 151 } 152 153 // AddSourceIdentifierToSubscriptionRequest mocks base method 154 func (m *MockRDSAPI) AddSourceIdentifierToSubscriptionRequest(arg0 *rds.AddSourceIdentifierToSubscriptionInput) (*request.Request, *rds.AddSourceIdentifierToSubscriptionOutput) { 155 m.ctrl.T.Helper() 156 ret := m.ctrl.Call(m, "AddSourceIdentifierToSubscriptionRequest", arg0) 157 ret0, _ := ret[0].(*request.Request) 158 ret1, _ := ret[1].(*rds.AddSourceIdentifierToSubscriptionOutput) 159 return ret0, ret1 160 } 161 162 // AddSourceIdentifierToSubscriptionRequest indicates an expected call of AddSourceIdentifierToSubscriptionRequest 163 func (mr *MockRDSAPIMockRecorder) AddSourceIdentifierToSubscriptionRequest(arg0 interface{}) *gomock.Call { 164 mr.mock.ctrl.T.Helper() 165 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddSourceIdentifierToSubscriptionRequest", reflect.TypeOf((*MockRDSAPI)(nil).AddSourceIdentifierToSubscriptionRequest), arg0) 166 } 167 168 // AddSourceIdentifierToSubscriptionWithContext mocks base method 169 func (m *MockRDSAPI) AddSourceIdentifierToSubscriptionWithContext(arg0 context.Context, arg1 *rds.AddSourceIdentifierToSubscriptionInput, arg2 ...request.Option) (*rds.AddSourceIdentifierToSubscriptionOutput, error) { 170 m.ctrl.T.Helper() 171 varargs := []interface{}{arg0, arg1} 172 for _, a := range arg2 { 173 varargs = append(varargs, a) 174 } 175 ret := m.ctrl.Call(m, "AddSourceIdentifierToSubscriptionWithContext", varargs...) 176 ret0, _ := ret[0].(*rds.AddSourceIdentifierToSubscriptionOutput) 177 ret1, _ := ret[1].(error) 178 return ret0, ret1 179 } 180 181 // AddSourceIdentifierToSubscriptionWithContext indicates an expected call of AddSourceIdentifierToSubscriptionWithContext 182 func (mr *MockRDSAPIMockRecorder) AddSourceIdentifierToSubscriptionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 183 mr.mock.ctrl.T.Helper() 184 varargs := append([]interface{}{arg0, arg1}, arg2...) 185 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddSourceIdentifierToSubscriptionWithContext", reflect.TypeOf((*MockRDSAPI)(nil).AddSourceIdentifierToSubscriptionWithContext), varargs...) 186 } 187 188 // AddTagsToResource mocks base method 189 func (m *MockRDSAPI) AddTagsToResource(arg0 *rds.AddTagsToResourceInput) (*rds.AddTagsToResourceOutput, error) { 190 m.ctrl.T.Helper() 191 ret := m.ctrl.Call(m, "AddTagsToResource", arg0) 192 ret0, _ := ret[0].(*rds.AddTagsToResourceOutput) 193 ret1, _ := ret[1].(error) 194 return ret0, ret1 195 } 196 197 // AddTagsToResource indicates an expected call of AddTagsToResource 198 func (mr *MockRDSAPIMockRecorder) AddTagsToResource(arg0 interface{}) *gomock.Call { 199 mr.mock.ctrl.T.Helper() 200 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddTagsToResource", reflect.TypeOf((*MockRDSAPI)(nil).AddTagsToResource), arg0) 201 } 202 203 // AddTagsToResourceRequest mocks base method 204 func (m *MockRDSAPI) AddTagsToResourceRequest(arg0 *rds.AddTagsToResourceInput) (*request.Request, *rds.AddTagsToResourceOutput) { 205 m.ctrl.T.Helper() 206 ret := m.ctrl.Call(m, "AddTagsToResourceRequest", arg0) 207 ret0, _ := ret[0].(*request.Request) 208 ret1, _ := ret[1].(*rds.AddTagsToResourceOutput) 209 return ret0, ret1 210 } 211 212 // AddTagsToResourceRequest indicates an expected call of AddTagsToResourceRequest 213 func (mr *MockRDSAPIMockRecorder) AddTagsToResourceRequest(arg0 interface{}) *gomock.Call { 214 mr.mock.ctrl.T.Helper() 215 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddTagsToResourceRequest", reflect.TypeOf((*MockRDSAPI)(nil).AddTagsToResourceRequest), arg0) 216 } 217 218 // AddTagsToResourceWithContext mocks base method 219 func (m *MockRDSAPI) AddTagsToResourceWithContext(arg0 context.Context, arg1 *rds.AddTagsToResourceInput, arg2 ...request.Option) (*rds.AddTagsToResourceOutput, error) { 220 m.ctrl.T.Helper() 221 varargs := []interface{}{arg0, arg1} 222 for _, a := range arg2 { 223 varargs = append(varargs, a) 224 } 225 ret := m.ctrl.Call(m, "AddTagsToResourceWithContext", varargs...) 226 ret0, _ := ret[0].(*rds.AddTagsToResourceOutput) 227 ret1, _ := ret[1].(error) 228 return ret0, ret1 229 } 230 231 // AddTagsToResourceWithContext indicates an expected call of AddTagsToResourceWithContext 232 func (mr *MockRDSAPIMockRecorder) AddTagsToResourceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 233 mr.mock.ctrl.T.Helper() 234 varargs := append([]interface{}{arg0, arg1}, arg2...) 235 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddTagsToResourceWithContext", reflect.TypeOf((*MockRDSAPI)(nil).AddTagsToResourceWithContext), varargs...) 236 } 237 238 // ApplyPendingMaintenanceAction mocks base method 239 func (m *MockRDSAPI) ApplyPendingMaintenanceAction(arg0 *rds.ApplyPendingMaintenanceActionInput) (*rds.ApplyPendingMaintenanceActionOutput, error) { 240 m.ctrl.T.Helper() 241 ret := m.ctrl.Call(m, "ApplyPendingMaintenanceAction", arg0) 242 ret0, _ := ret[0].(*rds.ApplyPendingMaintenanceActionOutput) 243 ret1, _ := ret[1].(error) 244 return ret0, ret1 245 } 246 247 // ApplyPendingMaintenanceAction indicates an expected call of ApplyPendingMaintenanceAction 248 func (mr *MockRDSAPIMockRecorder) ApplyPendingMaintenanceAction(arg0 interface{}) *gomock.Call { 249 mr.mock.ctrl.T.Helper() 250 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApplyPendingMaintenanceAction", reflect.TypeOf((*MockRDSAPI)(nil).ApplyPendingMaintenanceAction), arg0) 251 } 252 253 // ApplyPendingMaintenanceActionRequest mocks base method 254 func (m *MockRDSAPI) ApplyPendingMaintenanceActionRequest(arg0 *rds.ApplyPendingMaintenanceActionInput) (*request.Request, *rds.ApplyPendingMaintenanceActionOutput) { 255 m.ctrl.T.Helper() 256 ret := m.ctrl.Call(m, "ApplyPendingMaintenanceActionRequest", arg0) 257 ret0, _ := ret[0].(*request.Request) 258 ret1, _ := ret[1].(*rds.ApplyPendingMaintenanceActionOutput) 259 return ret0, ret1 260 } 261 262 // ApplyPendingMaintenanceActionRequest indicates an expected call of ApplyPendingMaintenanceActionRequest 263 func (mr *MockRDSAPIMockRecorder) ApplyPendingMaintenanceActionRequest(arg0 interface{}) *gomock.Call { 264 mr.mock.ctrl.T.Helper() 265 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApplyPendingMaintenanceActionRequest", reflect.TypeOf((*MockRDSAPI)(nil).ApplyPendingMaintenanceActionRequest), arg0) 266 } 267 268 // ApplyPendingMaintenanceActionWithContext mocks base method 269 func (m *MockRDSAPI) ApplyPendingMaintenanceActionWithContext(arg0 context.Context, arg1 *rds.ApplyPendingMaintenanceActionInput, arg2 ...request.Option) (*rds.ApplyPendingMaintenanceActionOutput, error) { 270 m.ctrl.T.Helper() 271 varargs := []interface{}{arg0, arg1} 272 for _, a := range arg2 { 273 varargs = append(varargs, a) 274 } 275 ret := m.ctrl.Call(m, "ApplyPendingMaintenanceActionWithContext", varargs...) 276 ret0, _ := ret[0].(*rds.ApplyPendingMaintenanceActionOutput) 277 ret1, _ := ret[1].(error) 278 return ret0, ret1 279 } 280 281 // ApplyPendingMaintenanceActionWithContext indicates an expected call of ApplyPendingMaintenanceActionWithContext 282 func (mr *MockRDSAPIMockRecorder) ApplyPendingMaintenanceActionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 283 mr.mock.ctrl.T.Helper() 284 varargs := append([]interface{}{arg0, arg1}, arg2...) 285 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApplyPendingMaintenanceActionWithContext", reflect.TypeOf((*MockRDSAPI)(nil).ApplyPendingMaintenanceActionWithContext), varargs...) 286 } 287 288 // AuthorizeDBSecurityGroupIngress mocks base method 289 func (m *MockRDSAPI) AuthorizeDBSecurityGroupIngress(arg0 *rds.AuthorizeDBSecurityGroupIngressInput) (*rds.AuthorizeDBSecurityGroupIngressOutput, error) { 290 m.ctrl.T.Helper() 291 ret := m.ctrl.Call(m, "AuthorizeDBSecurityGroupIngress", arg0) 292 ret0, _ := ret[0].(*rds.AuthorizeDBSecurityGroupIngressOutput) 293 ret1, _ := ret[1].(error) 294 return ret0, ret1 295 } 296 297 // AuthorizeDBSecurityGroupIngress indicates an expected call of AuthorizeDBSecurityGroupIngress 298 func (mr *MockRDSAPIMockRecorder) AuthorizeDBSecurityGroupIngress(arg0 interface{}) *gomock.Call { 299 mr.mock.ctrl.T.Helper() 300 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AuthorizeDBSecurityGroupIngress", reflect.TypeOf((*MockRDSAPI)(nil).AuthorizeDBSecurityGroupIngress), arg0) 301 } 302 303 // AuthorizeDBSecurityGroupIngressRequest mocks base method 304 func (m *MockRDSAPI) AuthorizeDBSecurityGroupIngressRequest(arg0 *rds.AuthorizeDBSecurityGroupIngressInput) (*request.Request, *rds.AuthorizeDBSecurityGroupIngressOutput) { 305 m.ctrl.T.Helper() 306 ret := m.ctrl.Call(m, "AuthorizeDBSecurityGroupIngressRequest", arg0) 307 ret0, _ := ret[0].(*request.Request) 308 ret1, _ := ret[1].(*rds.AuthorizeDBSecurityGroupIngressOutput) 309 return ret0, ret1 310 } 311 312 // AuthorizeDBSecurityGroupIngressRequest indicates an expected call of AuthorizeDBSecurityGroupIngressRequest 313 func (mr *MockRDSAPIMockRecorder) AuthorizeDBSecurityGroupIngressRequest(arg0 interface{}) *gomock.Call { 314 mr.mock.ctrl.T.Helper() 315 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AuthorizeDBSecurityGroupIngressRequest", reflect.TypeOf((*MockRDSAPI)(nil).AuthorizeDBSecurityGroupIngressRequest), arg0) 316 } 317 318 // AuthorizeDBSecurityGroupIngressWithContext mocks base method 319 func (m *MockRDSAPI) AuthorizeDBSecurityGroupIngressWithContext(arg0 context.Context, arg1 *rds.AuthorizeDBSecurityGroupIngressInput, arg2 ...request.Option) (*rds.AuthorizeDBSecurityGroupIngressOutput, error) { 320 m.ctrl.T.Helper() 321 varargs := []interface{}{arg0, arg1} 322 for _, a := range arg2 { 323 varargs = append(varargs, a) 324 } 325 ret := m.ctrl.Call(m, "AuthorizeDBSecurityGroupIngressWithContext", varargs...) 326 ret0, _ := ret[0].(*rds.AuthorizeDBSecurityGroupIngressOutput) 327 ret1, _ := ret[1].(error) 328 return ret0, ret1 329 } 330 331 // AuthorizeDBSecurityGroupIngressWithContext indicates an expected call of AuthorizeDBSecurityGroupIngressWithContext 332 func (mr *MockRDSAPIMockRecorder) AuthorizeDBSecurityGroupIngressWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 333 mr.mock.ctrl.T.Helper() 334 varargs := append([]interface{}{arg0, arg1}, arg2...) 335 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AuthorizeDBSecurityGroupIngressWithContext", reflect.TypeOf((*MockRDSAPI)(nil).AuthorizeDBSecurityGroupIngressWithContext), varargs...) 336 } 337 338 // BacktrackDBCluster mocks base method 339 func (m *MockRDSAPI) BacktrackDBCluster(arg0 *rds.BacktrackDBClusterInput) (*rds.BacktrackDBClusterOutput, error) { 340 m.ctrl.T.Helper() 341 ret := m.ctrl.Call(m, "BacktrackDBCluster", arg0) 342 ret0, _ := ret[0].(*rds.BacktrackDBClusterOutput) 343 ret1, _ := ret[1].(error) 344 return ret0, ret1 345 } 346 347 // BacktrackDBCluster indicates an expected call of BacktrackDBCluster 348 func (mr *MockRDSAPIMockRecorder) BacktrackDBCluster(arg0 interface{}) *gomock.Call { 349 mr.mock.ctrl.T.Helper() 350 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BacktrackDBCluster", reflect.TypeOf((*MockRDSAPI)(nil).BacktrackDBCluster), arg0) 351 } 352 353 // BacktrackDBClusterRequest mocks base method 354 func (m *MockRDSAPI) BacktrackDBClusterRequest(arg0 *rds.BacktrackDBClusterInput) (*request.Request, *rds.BacktrackDBClusterOutput) { 355 m.ctrl.T.Helper() 356 ret := m.ctrl.Call(m, "BacktrackDBClusterRequest", arg0) 357 ret0, _ := ret[0].(*request.Request) 358 ret1, _ := ret[1].(*rds.BacktrackDBClusterOutput) 359 return ret0, ret1 360 } 361 362 // BacktrackDBClusterRequest indicates an expected call of BacktrackDBClusterRequest 363 func (mr *MockRDSAPIMockRecorder) BacktrackDBClusterRequest(arg0 interface{}) *gomock.Call { 364 mr.mock.ctrl.T.Helper() 365 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BacktrackDBClusterRequest", reflect.TypeOf((*MockRDSAPI)(nil).BacktrackDBClusterRequest), arg0) 366 } 367 368 // BacktrackDBClusterWithContext mocks base method 369 func (m *MockRDSAPI) BacktrackDBClusterWithContext(arg0 context.Context, arg1 *rds.BacktrackDBClusterInput, arg2 ...request.Option) (*rds.BacktrackDBClusterOutput, error) { 370 m.ctrl.T.Helper() 371 varargs := []interface{}{arg0, arg1} 372 for _, a := range arg2 { 373 varargs = append(varargs, a) 374 } 375 ret := m.ctrl.Call(m, "BacktrackDBClusterWithContext", varargs...) 376 ret0, _ := ret[0].(*rds.BacktrackDBClusterOutput) 377 ret1, _ := ret[1].(error) 378 return ret0, ret1 379 } 380 381 // BacktrackDBClusterWithContext indicates an expected call of BacktrackDBClusterWithContext 382 func (mr *MockRDSAPIMockRecorder) BacktrackDBClusterWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 383 mr.mock.ctrl.T.Helper() 384 varargs := append([]interface{}{arg0, arg1}, arg2...) 385 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BacktrackDBClusterWithContext", reflect.TypeOf((*MockRDSAPI)(nil).BacktrackDBClusterWithContext), varargs...) 386 } 387 388 // CancelExportTask mocks base method 389 func (m *MockRDSAPI) CancelExportTask(arg0 *rds.CancelExportTaskInput) (*rds.CancelExportTaskOutput, error) { 390 m.ctrl.T.Helper() 391 ret := m.ctrl.Call(m, "CancelExportTask", arg0) 392 ret0, _ := ret[0].(*rds.CancelExportTaskOutput) 393 ret1, _ := ret[1].(error) 394 return ret0, ret1 395 } 396 397 // CancelExportTask indicates an expected call of CancelExportTask 398 func (mr *MockRDSAPIMockRecorder) CancelExportTask(arg0 interface{}) *gomock.Call { 399 mr.mock.ctrl.T.Helper() 400 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelExportTask", reflect.TypeOf((*MockRDSAPI)(nil).CancelExportTask), arg0) 401 } 402 403 // CancelExportTaskRequest mocks base method 404 func (m *MockRDSAPI) CancelExportTaskRequest(arg0 *rds.CancelExportTaskInput) (*request.Request, *rds.CancelExportTaskOutput) { 405 m.ctrl.T.Helper() 406 ret := m.ctrl.Call(m, "CancelExportTaskRequest", arg0) 407 ret0, _ := ret[0].(*request.Request) 408 ret1, _ := ret[1].(*rds.CancelExportTaskOutput) 409 return ret0, ret1 410 } 411 412 // CancelExportTaskRequest indicates an expected call of CancelExportTaskRequest 413 func (mr *MockRDSAPIMockRecorder) CancelExportTaskRequest(arg0 interface{}) *gomock.Call { 414 mr.mock.ctrl.T.Helper() 415 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelExportTaskRequest", reflect.TypeOf((*MockRDSAPI)(nil).CancelExportTaskRequest), arg0) 416 } 417 418 // CancelExportTaskWithContext mocks base method 419 func (m *MockRDSAPI) CancelExportTaskWithContext(arg0 context.Context, arg1 *rds.CancelExportTaskInput, arg2 ...request.Option) (*rds.CancelExportTaskOutput, error) { 420 m.ctrl.T.Helper() 421 varargs := []interface{}{arg0, arg1} 422 for _, a := range arg2 { 423 varargs = append(varargs, a) 424 } 425 ret := m.ctrl.Call(m, "CancelExportTaskWithContext", varargs...) 426 ret0, _ := ret[0].(*rds.CancelExportTaskOutput) 427 ret1, _ := ret[1].(error) 428 return ret0, ret1 429 } 430 431 // CancelExportTaskWithContext indicates an expected call of CancelExportTaskWithContext 432 func (mr *MockRDSAPIMockRecorder) CancelExportTaskWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 433 mr.mock.ctrl.T.Helper() 434 varargs := append([]interface{}{arg0, arg1}, arg2...) 435 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelExportTaskWithContext", reflect.TypeOf((*MockRDSAPI)(nil).CancelExportTaskWithContext), varargs...) 436 } 437 438 // CopyDBClusterParameterGroup mocks base method 439 func (m *MockRDSAPI) CopyDBClusterParameterGroup(arg0 *rds.CopyDBClusterParameterGroupInput) (*rds.CopyDBClusterParameterGroupOutput, error) { 440 m.ctrl.T.Helper() 441 ret := m.ctrl.Call(m, "CopyDBClusterParameterGroup", arg0) 442 ret0, _ := ret[0].(*rds.CopyDBClusterParameterGroupOutput) 443 ret1, _ := ret[1].(error) 444 return ret0, ret1 445 } 446 447 // CopyDBClusterParameterGroup indicates an expected call of CopyDBClusterParameterGroup 448 func (mr *MockRDSAPIMockRecorder) CopyDBClusterParameterGroup(arg0 interface{}) *gomock.Call { 449 mr.mock.ctrl.T.Helper() 450 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CopyDBClusterParameterGroup", reflect.TypeOf((*MockRDSAPI)(nil).CopyDBClusterParameterGroup), arg0) 451 } 452 453 // CopyDBClusterParameterGroupRequest mocks base method 454 func (m *MockRDSAPI) CopyDBClusterParameterGroupRequest(arg0 *rds.CopyDBClusterParameterGroupInput) (*request.Request, *rds.CopyDBClusterParameterGroupOutput) { 455 m.ctrl.T.Helper() 456 ret := m.ctrl.Call(m, "CopyDBClusterParameterGroupRequest", arg0) 457 ret0, _ := ret[0].(*request.Request) 458 ret1, _ := ret[1].(*rds.CopyDBClusterParameterGroupOutput) 459 return ret0, ret1 460 } 461 462 // CopyDBClusterParameterGroupRequest indicates an expected call of CopyDBClusterParameterGroupRequest 463 func (mr *MockRDSAPIMockRecorder) CopyDBClusterParameterGroupRequest(arg0 interface{}) *gomock.Call { 464 mr.mock.ctrl.T.Helper() 465 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CopyDBClusterParameterGroupRequest", reflect.TypeOf((*MockRDSAPI)(nil).CopyDBClusterParameterGroupRequest), arg0) 466 } 467 468 // CopyDBClusterParameterGroupWithContext mocks base method 469 func (m *MockRDSAPI) CopyDBClusterParameterGroupWithContext(arg0 context.Context, arg1 *rds.CopyDBClusterParameterGroupInput, arg2 ...request.Option) (*rds.CopyDBClusterParameterGroupOutput, error) { 470 m.ctrl.T.Helper() 471 varargs := []interface{}{arg0, arg1} 472 for _, a := range arg2 { 473 varargs = append(varargs, a) 474 } 475 ret := m.ctrl.Call(m, "CopyDBClusterParameterGroupWithContext", varargs...) 476 ret0, _ := ret[0].(*rds.CopyDBClusterParameterGroupOutput) 477 ret1, _ := ret[1].(error) 478 return ret0, ret1 479 } 480 481 // CopyDBClusterParameterGroupWithContext indicates an expected call of CopyDBClusterParameterGroupWithContext 482 func (mr *MockRDSAPIMockRecorder) CopyDBClusterParameterGroupWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 483 mr.mock.ctrl.T.Helper() 484 varargs := append([]interface{}{arg0, arg1}, arg2...) 485 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CopyDBClusterParameterGroupWithContext", reflect.TypeOf((*MockRDSAPI)(nil).CopyDBClusterParameterGroupWithContext), varargs...) 486 } 487 488 // CopyDBClusterSnapshot mocks base method 489 func (m *MockRDSAPI) CopyDBClusterSnapshot(arg0 *rds.CopyDBClusterSnapshotInput) (*rds.CopyDBClusterSnapshotOutput, error) { 490 m.ctrl.T.Helper() 491 ret := m.ctrl.Call(m, "CopyDBClusterSnapshot", arg0) 492 ret0, _ := ret[0].(*rds.CopyDBClusterSnapshotOutput) 493 ret1, _ := ret[1].(error) 494 return ret0, ret1 495 } 496 497 // CopyDBClusterSnapshot indicates an expected call of CopyDBClusterSnapshot 498 func (mr *MockRDSAPIMockRecorder) CopyDBClusterSnapshot(arg0 interface{}) *gomock.Call { 499 mr.mock.ctrl.T.Helper() 500 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CopyDBClusterSnapshot", reflect.TypeOf((*MockRDSAPI)(nil).CopyDBClusterSnapshot), arg0) 501 } 502 503 // CopyDBClusterSnapshotRequest mocks base method 504 func (m *MockRDSAPI) CopyDBClusterSnapshotRequest(arg0 *rds.CopyDBClusterSnapshotInput) (*request.Request, *rds.CopyDBClusterSnapshotOutput) { 505 m.ctrl.T.Helper() 506 ret := m.ctrl.Call(m, "CopyDBClusterSnapshotRequest", arg0) 507 ret0, _ := ret[0].(*request.Request) 508 ret1, _ := ret[1].(*rds.CopyDBClusterSnapshotOutput) 509 return ret0, ret1 510 } 511 512 // CopyDBClusterSnapshotRequest indicates an expected call of CopyDBClusterSnapshotRequest 513 func (mr *MockRDSAPIMockRecorder) CopyDBClusterSnapshotRequest(arg0 interface{}) *gomock.Call { 514 mr.mock.ctrl.T.Helper() 515 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CopyDBClusterSnapshotRequest", reflect.TypeOf((*MockRDSAPI)(nil).CopyDBClusterSnapshotRequest), arg0) 516 } 517 518 // CopyDBClusterSnapshotWithContext mocks base method 519 func (m *MockRDSAPI) CopyDBClusterSnapshotWithContext(arg0 context.Context, arg1 *rds.CopyDBClusterSnapshotInput, arg2 ...request.Option) (*rds.CopyDBClusterSnapshotOutput, error) { 520 m.ctrl.T.Helper() 521 varargs := []interface{}{arg0, arg1} 522 for _, a := range arg2 { 523 varargs = append(varargs, a) 524 } 525 ret := m.ctrl.Call(m, "CopyDBClusterSnapshotWithContext", varargs...) 526 ret0, _ := ret[0].(*rds.CopyDBClusterSnapshotOutput) 527 ret1, _ := ret[1].(error) 528 return ret0, ret1 529 } 530 531 // CopyDBClusterSnapshotWithContext indicates an expected call of CopyDBClusterSnapshotWithContext 532 func (mr *MockRDSAPIMockRecorder) CopyDBClusterSnapshotWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 533 mr.mock.ctrl.T.Helper() 534 varargs := append([]interface{}{arg0, arg1}, arg2...) 535 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CopyDBClusterSnapshotWithContext", reflect.TypeOf((*MockRDSAPI)(nil).CopyDBClusterSnapshotWithContext), varargs...) 536 } 537 538 // CopyDBParameterGroup mocks base method 539 func (m *MockRDSAPI) CopyDBParameterGroup(arg0 *rds.CopyDBParameterGroupInput) (*rds.CopyDBParameterGroupOutput, error) { 540 m.ctrl.T.Helper() 541 ret := m.ctrl.Call(m, "CopyDBParameterGroup", arg0) 542 ret0, _ := ret[0].(*rds.CopyDBParameterGroupOutput) 543 ret1, _ := ret[1].(error) 544 return ret0, ret1 545 } 546 547 // CopyDBParameterGroup indicates an expected call of CopyDBParameterGroup 548 func (mr *MockRDSAPIMockRecorder) CopyDBParameterGroup(arg0 interface{}) *gomock.Call { 549 mr.mock.ctrl.T.Helper() 550 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CopyDBParameterGroup", reflect.TypeOf((*MockRDSAPI)(nil).CopyDBParameterGroup), arg0) 551 } 552 553 // CopyDBParameterGroupRequest mocks base method 554 func (m *MockRDSAPI) CopyDBParameterGroupRequest(arg0 *rds.CopyDBParameterGroupInput) (*request.Request, *rds.CopyDBParameterGroupOutput) { 555 m.ctrl.T.Helper() 556 ret := m.ctrl.Call(m, "CopyDBParameterGroupRequest", arg0) 557 ret0, _ := ret[0].(*request.Request) 558 ret1, _ := ret[1].(*rds.CopyDBParameterGroupOutput) 559 return ret0, ret1 560 } 561 562 // CopyDBParameterGroupRequest indicates an expected call of CopyDBParameterGroupRequest 563 func (mr *MockRDSAPIMockRecorder) CopyDBParameterGroupRequest(arg0 interface{}) *gomock.Call { 564 mr.mock.ctrl.T.Helper() 565 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CopyDBParameterGroupRequest", reflect.TypeOf((*MockRDSAPI)(nil).CopyDBParameterGroupRequest), arg0) 566 } 567 568 // CopyDBParameterGroupWithContext mocks base method 569 func (m *MockRDSAPI) CopyDBParameterGroupWithContext(arg0 context.Context, arg1 *rds.CopyDBParameterGroupInput, arg2 ...request.Option) (*rds.CopyDBParameterGroupOutput, error) { 570 m.ctrl.T.Helper() 571 varargs := []interface{}{arg0, arg1} 572 for _, a := range arg2 { 573 varargs = append(varargs, a) 574 } 575 ret := m.ctrl.Call(m, "CopyDBParameterGroupWithContext", varargs...) 576 ret0, _ := ret[0].(*rds.CopyDBParameterGroupOutput) 577 ret1, _ := ret[1].(error) 578 return ret0, ret1 579 } 580 581 // CopyDBParameterGroupWithContext indicates an expected call of CopyDBParameterGroupWithContext 582 func (mr *MockRDSAPIMockRecorder) CopyDBParameterGroupWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 583 mr.mock.ctrl.T.Helper() 584 varargs := append([]interface{}{arg0, arg1}, arg2...) 585 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CopyDBParameterGroupWithContext", reflect.TypeOf((*MockRDSAPI)(nil).CopyDBParameterGroupWithContext), varargs...) 586 } 587 588 // CopyDBSnapshot mocks base method 589 func (m *MockRDSAPI) CopyDBSnapshot(arg0 *rds.CopyDBSnapshotInput) (*rds.CopyDBSnapshotOutput, error) { 590 m.ctrl.T.Helper() 591 ret := m.ctrl.Call(m, "CopyDBSnapshot", arg0) 592 ret0, _ := ret[0].(*rds.CopyDBSnapshotOutput) 593 ret1, _ := ret[1].(error) 594 return ret0, ret1 595 } 596 597 // CopyDBSnapshot indicates an expected call of CopyDBSnapshot 598 func (mr *MockRDSAPIMockRecorder) CopyDBSnapshot(arg0 interface{}) *gomock.Call { 599 mr.mock.ctrl.T.Helper() 600 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CopyDBSnapshot", reflect.TypeOf((*MockRDSAPI)(nil).CopyDBSnapshot), arg0) 601 } 602 603 // CopyDBSnapshotRequest mocks base method 604 func (m *MockRDSAPI) CopyDBSnapshotRequest(arg0 *rds.CopyDBSnapshotInput) (*request.Request, *rds.CopyDBSnapshotOutput) { 605 m.ctrl.T.Helper() 606 ret := m.ctrl.Call(m, "CopyDBSnapshotRequest", arg0) 607 ret0, _ := ret[0].(*request.Request) 608 ret1, _ := ret[1].(*rds.CopyDBSnapshotOutput) 609 return ret0, ret1 610 } 611 612 // CopyDBSnapshotRequest indicates an expected call of CopyDBSnapshotRequest 613 func (mr *MockRDSAPIMockRecorder) CopyDBSnapshotRequest(arg0 interface{}) *gomock.Call { 614 mr.mock.ctrl.T.Helper() 615 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CopyDBSnapshotRequest", reflect.TypeOf((*MockRDSAPI)(nil).CopyDBSnapshotRequest), arg0) 616 } 617 618 // CopyDBSnapshotWithContext mocks base method 619 func (m *MockRDSAPI) CopyDBSnapshotWithContext(arg0 context.Context, arg1 *rds.CopyDBSnapshotInput, arg2 ...request.Option) (*rds.CopyDBSnapshotOutput, error) { 620 m.ctrl.T.Helper() 621 varargs := []interface{}{arg0, arg1} 622 for _, a := range arg2 { 623 varargs = append(varargs, a) 624 } 625 ret := m.ctrl.Call(m, "CopyDBSnapshotWithContext", varargs...) 626 ret0, _ := ret[0].(*rds.CopyDBSnapshotOutput) 627 ret1, _ := ret[1].(error) 628 return ret0, ret1 629 } 630 631 // CopyDBSnapshotWithContext indicates an expected call of CopyDBSnapshotWithContext 632 func (mr *MockRDSAPIMockRecorder) CopyDBSnapshotWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 633 mr.mock.ctrl.T.Helper() 634 varargs := append([]interface{}{arg0, arg1}, arg2...) 635 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CopyDBSnapshotWithContext", reflect.TypeOf((*MockRDSAPI)(nil).CopyDBSnapshotWithContext), varargs...) 636 } 637 638 // CopyOptionGroup mocks base method 639 func (m *MockRDSAPI) CopyOptionGroup(arg0 *rds.CopyOptionGroupInput) (*rds.CopyOptionGroupOutput, error) { 640 m.ctrl.T.Helper() 641 ret := m.ctrl.Call(m, "CopyOptionGroup", arg0) 642 ret0, _ := ret[0].(*rds.CopyOptionGroupOutput) 643 ret1, _ := ret[1].(error) 644 return ret0, ret1 645 } 646 647 // CopyOptionGroup indicates an expected call of CopyOptionGroup 648 func (mr *MockRDSAPIMockRecorder) CopyOptionGroup(arg0 interface{}) *gomock.Call { 649 mr.mock.ctrl.T.Helper() 650 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CopyOptionGroup", reflect.TypeOf((*MockRDSAPI)(nil).CopyOptionGroup), arg0) 651 } 652 653 // CopyOptionGroupRequest mocks base method 654 func (m *MockRDSAPI) CopyOptionGroupRequest(arg0 *rds.CopyOptionGroupInput) (*request.Request, *rds.CopyOptionGroupOutput) { 655 m.ctrl.T.Helper() 656 ret := m.ctrl.Call(m, "CopyOptionGroupRequest", arg0) 657 ret0, _ := ret[0].(*request.Request) 658 ret1, _ := ret[1].(*rds.CopyOptionGroupOutput) 659 return ret0, ret1 660 } 661 662 // CopyOptionGroupRequest indicates an expected call of CopyOptionGroupRequest 663 func (mr *MockRDSAPIMockRecorder) CopyOptionGroupRequest(arg0 interface{}) *gomock.Call { 664 mr.mock.ctrl.T.Helper() 665 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CopyOptionGroupRequest", reflect.TypeOf((*MockRDSAPI)(nil).CopyOptionGroupRequest), arg0) 666 } 667 668 // CopyOptionGroupWithContext mocks base method 669 func (m *MockRDSAPI) CopyOptionGroupWithContext(arg0 context.Context, arg1 *rds.CopyOptionGroupInput, arg2 ...request.Option) (*rds.CopyOptionGroupOutput, error) { 670 m.ctrl.T.Helper() 671 varargs := []interface{}{arg0, arg1} 672 for _, a := range arg2 { 673 varargs = append(varargs, a) 674 } 675 ret := m.ctrl.Call(m, "CopyOptionGroupWithContext", varargs...) 676 ret0, _ := ret[0].(*rds.CopyOptionGroupOutput) 677 ret1, _ := ret[1].(error) 678 return ret0, ret1 679 } 680 681 // CopyOptionGroupWithContext indicates an expected call of CopyOptionGroupWithContext 682 func (mr *MockRDSAPIMockRecorder) CopyOptionGroupWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 683 mr.mock.ctrl.T.Helper() 684 varargs := append([]interface{}{arg0, arg1}, arg2...) 685 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CopyOptionGroupWithContext", reflect.TypeOf((*MockRDSAPI)(nil).CopyOptionGroupWithContext), varargs...) 686 } 687 688 // CreateCustomAvailabilityZone mocks base method 689 func (m *MockRDSAPI) CreateCustomAvailabilityZone(arg0 *rds.CreateCustomAvailabilityZoneInput) (*rds.CreateCustomAvailabilityZoneOutput, error) { 690 m.ctrl.T.Helper() 691 ret := m.ctrl.Call(m, "CreateCustomAvailabilityZone", arg0) 692 ret0, _ := ret[0].(*rds.CreateCustomAvailabilityZoneOutput) 693 ret1, _ := ret[1].(error) 694 return ret0, ret1 695 } 696 697 // CreateCustomAvailabilityZone indicates an expected call of CreateCustomAvailabilityZone 698 func (mr *MockRDSAPIMockRecorder) CreateCustomAvailabilityZone(arg0 interface{}) *gomock.Call { 699 mr.mock.ctrl.T.Helper() 700 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCustomAvailabilityZone", reflect.TypeOf((*MockRDSAPI)(nil).CreateCustomAvailabilityZone), arg0) 701 } 702 703 // CreateCustomAvailabilityZoneRequest mocks base method 704 func (m *MockRDSAPI) CreateCustomAvailabilityZoneRequest(arg0 *rds.CreateCustomAvailabilityZoneInput) (*request.Request, *rds.CreateCustomAvailabilityZoneOutput) { 705 m.ctrl.T.Helper() 706 ret := m.ctrl.Call(m, "CreateCustomAvailabilityZoneRequest", arg0) 707 ret0, _ := ret[0].(*request.Request) 708 ret1, _ := ret[1].(*rds.CreateCustomAvailabilityZoneOutput) 709 return ret0, ret1 710 } 711 712 // CreateCustomAvailabilityZoneRequest indicates an expected call of CreateCustomAvailabilityZoneRequest 713 func (mr *MockRDSAPIMockRecorder) CreateCustomAvailabilityZoneRequest(arg0 interface{}) *gomock.Call { 714 mr.mock.ctrl.T.Helper() 715 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCustomAvailabilityZoneRequest", reflect.TypeOf((*MockRDSAPI)(nil).CreateCustomAvailabilityZoneRequest), arg0) 716 } 717 718 // CreateCustomAvailabilityZoneWithContext mocks base method 719 func (m *MockRDSAPI) CreateCustomAvailabilityZoneWithContext(arg0 context.Context, arg1 *rds.CreateCustomAvailabilityZoneInput, arg2 ...request.Option) (*rds.CreateCustomAvailabilityZoneOutput, error) { 720 m.ctrl.T.Helper() 721 varargs := []interface{}{arg0, arg1} 722 for _, a := range arg2 { 723 varargs = append(varargs, a) 724 } 725 ret := m.ctrl.Call(m, "CreateCustomAvailabilityZoneWithContext", varargs...) 726 ret0, _ := ret[0].(*rds.CreateCustomAvailabilityZoneOutput) 727 ret1, _ := ret[1].(error) 728 return ret0, ret1 729 } 730 731 // CreateCustomAvailabilityZoneWithContext indicates an expected call of CreateCustomAvailabilityZoneWithContext 732 func (mr *MockRDSAPIMockRecorder) CreateCustomAvailabilityZoneWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 733 mr.mock.ctrl.T.Helper() 734 varargs := append([]interface{}{arg0, arg1}, arg2...) 735 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCustomAvailabilityZoneWithContext", reflect.TypeOf((*MockRDSAPI)(nil).CreateCustomAvailabilityZoneWithContext), varargs...) 736 } 737 738 // CreateDBCluster mocks base method 739 func (m *MockRDSAPI) CreateDBCluster(arg0 *rds.CreateDBClusterInput) (*rds.CreateDBClusterOutput, error) { 740 m.ctrl.T.Helper() 741 ret := m.ctrl.Call(m, "CreateDBCluster", arg0) 742 ret0, _ := ret[0].(*rds.CreateDBClusterOutput) 743 ret1, _ := ret[1].(error) 744 return ret0, ret1 745 } 746 747 // CreateDBCluster indicates an expected call of CreateDBCluster 748 func (mr *MockRDSAPIMockRecorder) CreateDBCluster(arg0 interface{}) *gomock.Call { 749 mr.mock.ctrl.T.Helper() 750 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDBCluster", reflect.TypeOf((*MockRDSAPI)(nil).CreateDBCluster), arg0) 751 } 752 753 // CreateDBClusterEndpoint mocks base method 754 func (m *MockRDSAPI) CreateDBClusterEndpoint(arg0 *rds.CreateDBClusterEndpointInput) (*rds.CreateDBClusterEndpointOutput, error) { 755 m.ctrl.T.Helper() 756 ret := m.ctrl.Call(m, "CreateDBClusterEndpoint", arg0) 757 ret0, _ := ret[0].(*rds.CreateDBClusterEndpointOutput) 758 ret1, _ := ret[1].(error) 759 return ret0, ret1 760 } 761 762 // CreateDBClusterEndpoint indicates an expected call of CreateDBClusterEndpoint 763 func (mr *MockRDSAPIMockRecorder) CreateDBClusterEndpoint(arg0 interface{}) *gomock.Call { 764 mr.mock.ctrl.T.Helper() 765 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDBClusterEndpoint", reflect.TypeOf((*MockRDSAPI)(nil).CreateDBClusterEndpoint), arg0) 766 } 767 768 // CreateDBClusterEndpointRequest mocks base method 769 func (m *MockRDSAPI) CreateDBClusterEndpointRequest(arg0 *rds.CreateDBClusterEndpointInput) (*request.Request, *rds.CreateDBClusterEndpointOutput) { 770 m.ctrl.T.Helper() 771 ret := m.ctrl.Call(m, "CreateDBClusterEndpointRequest", arg0) 772 ret0, _ := ret[0].(*request.Request) 773 ret1, _ := ret[1].(*rds.CreateDBClusterEndpointOutput) 774 return ret0, ret1 775 } 776 777 // CreateDBClusterEndpointRequest indicates an expected call of CreateDBClusterEndpointRequest 778 func (mr *MockRDSAPIMockRecorder) CreateDBClusterEndpointRequest(arg0 interface{}) *gomock.Call { 779 mr.mock.ctrl.T.Helper() 780 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDBClusterEndpointRequest", reflect.TypeOf((*MockRDSAPI)(nil).CreateDBClusterEndpointRequest), arg0) 781 } 782 783 // CreateDBClusterEndpointWithContext mocks base method 784 func (m *MockRDSAPI) CreateDBClusterEndpointWithContext(arg0 context.Context, arg1 *rds.CreateDBClusterEndpointInput, arg2 ...request.Option) (*rds.CreateDBClusterEndpointOutput, error) { 785 m.ctrl.T.Helper() 786 varargs := []interface{}{arg0, arg1} 787 for _, a := range arg2 { 788 varargs = append(varargs, a) 789 } 790 ret := m.ctrl.Call(m, "CreateDBClusterEndpointWithContext", varargs...) 791 ret0, _ := ret[0].(*rds.CreateDBClusterEndpointOutput) 792 ret1, _ := ret[1].(error) 793 return ret0, ret1 794 } 795 796 // CreateDBClusterEndpointWithContext indicates an expected call of CreateDBClusterEndpointWithContext 797 func (mr *MockRDSAPIMockRecorder) CreateDBClusterEndpointWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 798 mr.mock.ctrl.T.Helper() 799 varargs := append([]interface{}{arg0, arg1}, arg2...) 800 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDBClusterEndpointWithContext", reflect.TypeOf((*MockRDSAPI)(nil).CreateDBClusterEndpointWithContext), varargs...) 801 } 802 803 // CreateDBClusterParameterGroup mocks base method 804 func (m *MockRDSAPI) CreateDBClusterParameterGroup(arg0 *rds.CreateDBClusterParameterGroupInput) (*rds.CreateDBClusterParameterGroupOutput, error) { 805 m.ctrl.T.Helper() 806 ret := m.ctrl.Call(m, "CreateDBClusterParameterGroup", arg0) 807 ret0, _ := ret[0].(*rds.CreateDBClusterParameterGroupOutput) 808 ret1, _ := ret[1].(error) 809 return ret0, ret1 810 } 811 812 // CreateDBClusterParameterGroup indicates an expected call of CreateDBClusterParameterGroup 813 func (mr *MockRDSAPIMockRecorder) CreateDBClusterParameterGroup(arg0 interface{}) *gomock.Call { 814 mr.mock.ctrl.T.Helper() 815 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDBClusterParameterGroup", reflect.TypeOf((*MockRDSAPI)(nil).CreateDBClusterParameterGroup), arg0) 816 } 817 818 // CreateDBClusterParameterGroupRequest mocks base method 819 func (m *MockRDSAPI) CreateDBClusterParameterGroupRequest(arg0 *rds.CreateDBClusterParameterGroupInput) (*request.Request, *rds.CreateDBClusterParameterGroupOutput) { 820 m.ctrl.T.Helper() 821 ret := m.ctrl.Call(m, "CreateDBClusterParameterGroupRequest", arg0) 822 ret0, _ := ret[0].(*request.Request) 823 ret1, _ := ret[1].(*rds.CreateDBClusterParameterGroupOutput) 824 return ret0, ret1 825 } 826 827 // CreateDBClusterParameterGroupRequest indicates an expected call of CreateDBClusterParameterGroupRequest 828 func (mr *MockRDSAPIMockRecorder) CreateDBClusterParameterGroupRequest(arg0 interface{}) *gomock.Call { 829 mr.mock.ctrl.T.Helper() 830 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDBClusterParameterGroupRequest", reflect.TypeOf((*MockRDSAPI)(nil).CreateDBClusterParameterGroupRequest), arg0) 831 } 832 833 // CreateDBClusterParameterGroupWithContext mocks base method 834 func (m *MockRDSAPI) CreateDBClusterParameterGroupWithContext(arg0 context.Context, arg1 *rds.CreateDBClusterParameterGroupInput, arg2 ...request.Option) (*rds.CreateDBClusterParameterGroupOutput, error) { 835 m.ctrl.T.Helper() 836 varargs := []interface{}{arg0, arg1} 837 for _, a := range arg2 { 838 varargs = append(varargs, a) 839 } 840 ret := m.ctrl.Call(m, "CreateDBClusterParameterGroupWithContext", varargs...) 841 ret0, _ := ret[0].(*rds.CreateDBClusterParameterGroupOutput) 842 ret1, _ := ret[1].(error) 843 return ret0, ret1 844 } 845 846 // CreateDBClusterParameterGroupWithContext indicates an expected call of CreateDBClusterParameterGroupWithContext 847 func (mr *MockRDSAPIMockRecorder) CreateDBClusterParameterGroupWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 848 mr.mock.ctrl.T.Helper() 849 varargs := append([]interface{}{arg0, arg1}, arg2...) 850 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDBClusterParameterGroupWithContext", reflect.TypeOf((*MockRDSAPI)(nil).CreateDBClusterParameterGroupWithContext), varargs...) 851 } 852 853 // CreateDBClusterRequest mocks base method 854 func (m *MockRDSAPI) CreateDBClusterRequest(arg0 *rds.CreateDBClusterInput) (*request.Request, *rds.CreateDBClusterOutput) { 855 m.ctrl.T.Helper() 856 ret := m.ctrl.Call(m, "CreateDBClusterRequest", arg0) 857 ret0, _ := ret[0].(*request.Request) 858 ret1, _ := ret[1].(*rds.CreateDBClusterOutput) 859 return ret0, ret1 860 } 861 862 // CreateDBClusterRequest indicates an expected call of CreateDBClusterRequest 863 func (mr *MockRDSAPIMockRecorder) CreateDBClusterRequest(arg0 interface{}) *gomock.Call { 864 mr.mock.ctrl.T.Helper() 865 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDBClusterRequest", reflect.TypeOf((*MockRDSAPI)(nil).CreateDBClusterRequest), arg0) 866 } 867 868 // CreateDBClusterSnapshot mocks base method 869 func (m *MockRDSAPI) CreateDBClusterSnapshot(arg0 *rds.CreateDBClusterSnapshotInput) (*rds.CreateDBClusterSnapshotOutput, error) { 870 m.ctrl.T.Helper() 871 ret := m.ctrl.Call(m, "CreateDBClusterSnapshot", arg0) 872 ret0, _ := ret[0].(*rds.CreateDBClusterSnapshotOutput) 873 ret1, _ := ret[1].(error) 874 return ret0, ret1 875 } 876 877 // CreateDBClusterSnapshot indicates an expected call of CreateDBClusterSnapshot 878 func (mr *MockRDSAPIMockRecorder) CreateDBClusterSnapshot(arg0 interface{}) *gomock.Call { 879 mr.mock.ctrl.T.Helper() 880 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDBClusterSnapshot", reflect.TypeOf((*MockRDSAPI)(nil).CreateDBClusterSnapshot), arg0) 881 } 882 883 // CreateDBClusterSnapshotRequest mocks base method 884 func (m *MockRDSAPI) CreateDBClusterSnapshotRequest(arg0 *rds.CreateDBClusterSnapshotInput) (*request.Request, *rds.CreateDBClusterSnapshotOutput) { 885 m.ctrl.T.Helper() 886 ret := m.ctrl.Call(m, "CreateDBClusterSnapshotRequest", arg0) 887 ret0, _ := ret[0].(*request.Request) 888 ret1, _ := ret[1].(*rds.CreateDBClusterSnapshotOutput) 889 return ret0, ret1 890 } 891 892 // CreateDBClusterSnapshotRequest indicates an expected call of CreateDBClusterSnapshotRequest 893 func (mr *MockRDSAPIMockRecorder) CreateDBClusterSnapshotRequest(arg0 interface{}) *gomock.Call { 894 mr.mock.ctrl.T.Helper() 895 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDBClusterSnapshotRequest", reflect.TypeOf((*MockRDSAPI)(nil).CreateDBClusterSnapshotRequest), arg0) 896 } 897 898 // CreateDBClusterSnapshotWithContext mocks base method 899 func (m *MockRDSAPI) CreateDBClusterSnapshotWithContext(arg0 context.Context, arg1 *rds.CreateDBClusterSnapshotInput, arg2 ...request.Option) (*rds.CreateDBClusterSnapshotOutput, error) { 900 m.ctrl.T.Helper() 901 varargs := []interface{}{arg0, arg1} 902 for _, a := range arg2 { 903 varargs = append(varargs, a) 904 } 905 ret := m.ctrl.Call(m, "CreateDBClusterSnapshotWithContext", varargs...) 906 ret0, _ := ret[0].(*rds.CreateDBClusterSnapshotOutput) 907 ret1, _ := ret[1].(error) 908 return ret0, ret1 909 } 910 911 // CreateDBClusterSnapshotWithContext indicates an expected call of CreateDBClusterSnapshotWithContext 912 func (mr *MockRDSAPIMockRecorder) CreateDBClusterSnapshotWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 913 mr.mock.ctrl.T.Helper() 914 varargs := append([]interface{}{arg0, arg1}, arg2...) 915 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDBClusterSnapshotWithContext", reflect.TypeOf((*MockRDSAPI)(nil).CreateDBClusterSnapshotWithContext), varargs...) 916 } 917 918 // CreateDBClusterWithContext mocks base method 919 func (m *MockRDSAPI) CreateDBClusterWithContext(arg0 context.Context, arg1 *rds.CreateDBClusterInput, arg2 ...request.Option) (*rds.CreateDBClusterOutput, error) { 920 m.ctrl.T.Helper() 921 varargs := []interface{}{arg0, arg1} 922 for _, a := range arg2 { 923 varargs = append(varargs, a) 924 } 925 ret := m.ctrl.Call(m, "CreateDBClusterWithContext", varargs...) 926 ret0, _ := ret[0].(*rds.CreateDBClusterOutput) 927 ret1, _ := ret[1].(error) 928 return ret0, ret1 929 } 930 931 // CreateDBClusterWithContext indicates an expected call of CreateDBClusterWithContext 932 func (mr *MockRDSAPIMockRecorder) CreateDBClusterWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 933 mr.mock.ctrl.T.Helper() 934 varargs := append([]interface{}{arg0, arg1}, arg2...) 935 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDBClusterWithContext", reflect.TypeOf((*MockRDSAPI)(nil).CreateDBClusterWithContext), varargs...) 936 } 937 938 // CreateDBInstance mocks base method 939 func (m *MockRDSAPI) CreateDBInstance(arg0 *rds.CreateDBInstanceInput) (*rds.CreateDBInstanceOutput, error) { 940 m.ctrl.T.Helper() 941 ret := m.ctrl.Call(m, "CreateDBInstance", arg0) 942 ret0, _ := ret[0].(*rds.CreateDBInstanceOutput) 943 ret1, _ := ret[1].(error) 944 return ret0, ret1 945 } 946 947 // CreateDBInstance indicates an expected call of CreateDBInstance 948 func (mr *MockRDSAPIMockRecorder) CreateDBInstance(arg0 interface{}) *gomock.Call { 949 mr.mock.ctrl.T.Helper() 950 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDBInstance", reflect.TypeOf((*MockRDSAPI)(nil).CreateDBInstance), arg0) 951 } 952 953 // CreateDBInstanceReadReplica mocks base method 954 func (m *MockRDSAPI) CreateDBInstanceReadReplica(arg0 *rds.CreateDBInstanceReadReplicaInput) (*rds.CreateDBInstanceReadReplicaOutput, error) { 955 m.ctrl.T.Helper() 956 ret := m.ctrl.Call(m, "CreateDBInstanceReadReplica", arg0) 957 ret0, _ := ret[0].(*rds.CreateDBInstanceReadReplicaOutput) 958 ret1, _ := ret[1].(error) 959 return ret0, ret1 960 } 961 962 // CreateDBInstanceReadReplica indicates an expected call of CreateDBInstanceReadReplica 963 func (mr *MockRDSAPIMockRecorder) CreateDBInstanceReadReplica(arg0 interface{}) *gomock.Call { 964 mr.mock.ctrl.T.Helper() 965 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDBInstanceReadReplica", reflect.TypeOf((*MockRDSAPI)(nil).CreateDBInstanceReadReplica), arg0) 966 } 967 968 // CreateDBInstanceReadReplicaRequest mocks base method 969 func (m *MockRDSAPI) CreateDBInstanceReadReplicaRequest(arg0 *rds.CreateDBInstanceReadReplicaInput) (*request.Request, *rds.CreateDBInstanceReadReplicaOutput) { 970 m.ctrl.T.Helper() 971 ret := m.ctrl.Call(m, "CreateDBInstanceReadReplicaRequest", arg0) 972 ret0, _ := ret[0].(*request.Request) 973 ret1, _ := ret[1].(*rds.CreateDBInstanceReadReplicaOutput) 974 return ret0, ret1 975 } 976 977 // CreateDBInstanceReadReplicaRequest indicates an expected call of CreateDBInstanceReadReplicaRequest 978 func (mr *MockRDSAPIMockRecorder) CreateDBInstanceReadReplicaRequest(arg0 interface{}) *gomock.Call { 979 mr.mock.ctrl.T.Helper() 980 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDBInstanceReadReplicaRequest", reflect.TypeOf((*MockRDSAPI)(nil).CreateDBInstanceReadReplicaRequest), arg0) 981 } 982 983 // CreateDBInstanceReadReplicaWithContext mocks base method 984 func (m *MockRDSAPI) CreateDBInstanceReadReplicaWithContext(arg0 context.Context, arg1 *rds.CreateDBInstanceReadReplicaInput, arg2 ...request.Option) (*rds.CreateDBInstanceReadReplicaOutput, error) { 985 m.ctrl.T.Helper() 986 varargs := []interface{}{arg0, arg1} 987 for _, a := range arg2 { 988 varargs = append(varargs, a) 989 } 990 ret := m.ctrl.Call(m, "CreateDBInstanceReadReplicaWithContext", varargs...) 991 ret0, _ := ret[0].(*rds.CreateDBInstanceReadReplicaOutput) 992 ret1, _ := ret[1].(error) 993 return ret0, ret1 994 } 995 996 // CreateDBInstanceReadReplicaWithContext indicates an expected call of CreateDBInstanceReadReplicaWithContext 997 func (mr *MockRDSAPIMockRecorder) CreateDBInstanceReadReplicaWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 998 mr.mock.ctrl.T.Helper() 999 varargs := append([]interface{}{arg0, arg1}, arg2...) 1000 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDBInstanceReadReplicaWithContext", reflect.TypeOf((*MockRDSAPI)(nil).CreateDBInstanceReadReplicaWithContext), varargs...) 1001 } 1002 1003 // CreateDBInstanceRequest mocks base method 1004 func (m *MockRDSAPI) CreateDBInstanceRequest(arg0 *rds.CreateDBInstanceInput) (*request.Request, *rds.CreateDBInstanceOutput) { 1005 m.ctrl.T.Helper() 1006 ret := m.ctrl.Call(m, "CreateDBInstanceRequest", arg0) 1007 ret0, _ := ret[0].(*request.Request) 1008 ret1, _ := ret[1].(*rds.CreateDBInstanceOutput) 1009 return ret0, ret1 1010 } 1011 1012 // CreateDBInstanceRequest indicates an expected call of CreateDBInstanceRequest 1013 func (mr *MockRDSAPIMockRecorder) CreateDBInstanceRequest(arg0 interface{}) *gomock.Call { 1014 mr.mock.ctrl.T.Helper() 1015 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDBInstanceRequest", reflect.TypeOf((*MockRDSAPI)(nil).CreateDBInstanceRequest), arg0) 1016 } 1017 1018 // CreateDBInstanceWithContext mocks base method 1019 func (m *MockRDSAPI) CreateDBInstanceWithContext(arg0 context.Context, arg1 *rds.CreateDBInstanceInput, arg2 ...request.Option) (*rds.CreateDBInstanceOutput, error) { 1020 m.ctrl.T.Helper() 1021 varargs := []interface{}{arg0, arg1} 1022 for _, a := range arg2 { 1023 varargs = append(varargs, a) 1024 } 1025 ret := m.ctrl.Call(m, "CreateDBInstanceWithContext", varargs...) 1026 ret0, _ := ret[0].(*rds.CreateDBInstanceOutput) 1027 ret1, _ := ret[1].(error) 1028 return ret0, ret1 1029 } 1030 1031 // CreateDBInstanceWithContext indicates an expected call of CreateDBInstanceWithContext 1032 func (mr *MockRDSAPIMockRecorder) CreateDBInstanceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 1033 mr.mock.ctrl.T.Helper() 1034 varargs := append([]interface{}{arg0, arg1}, arg2...) 1035 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDBInstanceWithContext", reflect.TypeOf((*MockRDSAPI)(nil).CreateDBInstanceWithContext), varargs...) 1036 } 1037 1038 // CreateDBParameterGroup mocks base method 1039 func (m *MockRDSAPI) CreateDBParameterGroup(arg0 *rds.CreateDBParameterGroupInput) (*rds.CreateDBParameterGroupOutput, error) { 1040 m.ctrl.T.Helper() 1041 ret := m.ctrl.Call(m, "CreateDBParameterGroup", arg0) 1042 ret0, _ := ret[0].(*rds.CreateDBParameterGroupOutput) 1043 ret1, _ := ret[1].(error) 1044 return ret0, ret1 1045 } 1046 1047 // CreateDBParameterGroup indicates an expected call of CreateDBParameterGroup 1048 func (mr *MockRDSAPIMockRecorder) CreateDBParameterGroup(arg0 interface{}) *gomock.Call { 1049 mr.mock.ctrl.T.Helper() 1050 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDBParameterGroup", reflect.TypeOf((*MockRDSAPI)(nil).CreateDBParameterGroup), arg0) 1051 } 1052 1053 // CreateDBParameterGroupRequest mocks base method 1054 func (m *MockRDSAPI) CreateDBParameterGroupRequest(arg0 *rds.CreateDBParameterGroupInput) (*request.Request, *rds.CreateDBParameterGroupOutput) { 1055 m.ctrl.T.Helper() 1056 ret := m.ctrl.Call(m, "CreateDBParameterGroupRequest", arg0) 1057 ret0, _ := ret[0].(*request.Request) 1058 ret1, _ := ret[1].(*rds.CreateDBParameterGroupOutput) 1059 return ret0, ret1 1060 } 1061 1062 // CreateDBParameterGroupRequest indicates an expected call of CreateDBParameterGroupRequest 1063 func (mr *MockRDSAPIMockRecorder) CreateDBParameterGroupRequest(arg0 interface{}) *gomock.Call { 1064 mr.mock.ctrl.T.Helper() 1065 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDBParameterGroupRequest", reflect.TypeOf((*MockRDSAPI)(nil).CreateDBParameterGroupRequest), arg0) 1066 } 1067 1068 // CreateDBParameterGroupWithContext mocks base method 1069 func (m *MockRDSAPI) CreateDBParameterGroupWithContext(arg0 context.Context, arg1 *rds.CreateDBParameterGroupInput, arg2 ...request.Option) (*rds.CreateDBParameterGroupOutput, error) { 1070 m.ctrl.T.Helper() 1071 varargs := []interface{}{arg0, arg1} 1072 for _, a := range arg2 { 1073 varargs = append(varargs, a) 1074 } 1075 ret := m.ctrl.Call(m, "CreateDBParameterGroupWithContext", varargs...) 1076 ret0, _ := ret[0].(*rds.CreateDBParameterGroupOutput) 1077 ret1, _ := ret[1].(error) 1078 return ret0, ret1 1079 } 1080 1081 // CreateDBParameterGroupWithContext indicates an expected call of CreateDBParameterGroupWithContext 1082 func (mr *MockRDSAPIMockRecorder) CreateDBParameterGroupWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 1083 mr.mock.ctrl.T.Helper() 1084 varargs := append([]interface{}{arg0, arg1}, arg2...) 1085 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDBParameterGroupWithContext", reflect.TypeOf((*MockRDSAPI)(nil).CreateDBParameterGroupWithContext), varargs...) 1086 } 1087 1088 // CreateDBProxy mocks base method 1089 func (m *MockRDSAPI) CreateDBProxy(arg0 *rds.CreateDBProxyInput) (*rds.CreateDBProxyOutput, error) { 1090 m.ctrl.T.Helper() 1091 ret := m.ctrl.Call(m, "CreateDBProxy", arg0) 1092 ret0, _ := ret[0].(*rds.CreateDBProxyOutput) 1093 ret1, _ := ret[1].(error) 1094 return ret0, ret1 1095 } 1096 1097 // CreateDBProxy indicates an expected call of CreateDBProxy 1098 func (mr *MockRDSAPIMockRecorder) CreateDBProxy(arg0 interface{}) *gomock.Call { 1099 mr.mock.ctrl.T.Helper() 1100 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDBProxy", reflect.TypeOf((*MockRDSAPI)(nil).CreateDBProxy), arg0) 1101 } 1102 1103 // CreateDBProxyRequest mocks base method 1104 func (m *MockRDSAPI) CreateDBProxyRequest(arg0 *rds.CreateDBProxyInput) (*request.Request, *rds.CreateDBProxyOutput) { 1105 m.ctrl.T.Helper() 1106 ret := m.ctrl.Call(m, "CreateDBProxyRequest", arg0) 1107 ret0, _ := ret[0].(*request.Request) 1108 ret1, _ := ret[1].(*rds.CreateDBProxyOutput) 1109 return ret0, ret1 1110 } 1111 1112 // CreateDBProxyRequest indicates an expected call of CreateDBProxyRequest 1113 func (mr *MockRDSAPIMockRecorder) CreateDBProxyRequest(arg0 interface{}) *gomock.Call { 1114 mr.mock.ctrl.T.Helper() 1115 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDBProxyRequest", reflect.TypeOf((*MockRDSAPI)(nil).CreateDBProxyRequest), arg0) 1116 } 1117 1118 // CreateDBProxyWithContext mocks base method 1119 func (m *MockRDSAPI) CreateDBProxyWithContext(arg0 context.Context, arg1 *rds.CreateDBProxyInput, arg2 ...request.Option) (*rds.CreateDBProxyOutput, error) { 1120 m.ctrl.T.Helper() 1121 varargs := []interface{}{arg0, arg1} 1122 for _, a := range arg2 { 1123 varargs = append(varargs, a) 1124 } 1125 ret := m.ctrl.Call(m, "CreateDBProxyWithContext", varargs...) 1126 ret0, _ := ret[0].(*rds.CreateDBProxyOutput) 1127 ret1, _ := ret[1].(error) 1128 return ret0, ret1 1129 } 1130 1131 // CreateDBProxyWithContext indicates an expected call of CreateDBProxyWithContext 1132 func (mr *MockRDSAPIMockRecorder) CreateDBProxyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 1133 mr.mock.ctrl.T.Helper() 1134 varargs := append([]interface{}{arg0, arg1}, arg2...) 1135 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDBProxyWithContext", reflect.TypeOf((*MockRDSAPI)(nil).CreateDBProxyWithContext), varargs...) 1136 } 1137 1138 // CreateDBSecurityGroup mocks base method 1139 func (m *MockRDSAPI) CreateDBSecurityGroup(arg0 *rds.CreateDBSecurityGroupInput) (*rds.CreateDBSecurityGroupOutput, error) { 1140 m.ctrl.T.Helper() 1141 ret := m.ctrl.Call(m, "CreateDBSecurityGroup", arg0) 1142 ret0, _ := ret[0].(*rds.CreateDBSecurityGroupOutput) 1143 ret1, _ := ret[1].(error) 1144 return ret0, ret1 1145 } 1146 1147 // CreateDBSecurityGroup indicates an expected call of CreateDBSecurityGroup 1148 func (mr *MockRDSAPIMockRecorder) CreateDBSecurityGroup(arg0 interface{}) *gomock.Call { 1149 mr.mock.ctrl.T.Helper() 1150 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDBSecurityGroup", reflect.TypeOf((*MockRDSAPI)(nil).CreateDBSecurityGroup), arg0) 1151 } 1152 1153 // CreateDBSecurityGroupRequest mocks base method 1154 func (m *MockRDSAPI) CreateDBSecurityGroupRequest(arg0 *rds.CreateDBSecurityGroupInput) (*request.Request, *rds.CreateDBSecurityGroupOutput) { 1155 m.ctrl.T.Helper() 1156 ret := m.ctrl.Call(m, "CreateDBSecurityGroupRequest", arg0) 1157 ret0, _ := ret[0].(*request.Request) 1158 ret1, _ := ret[1].(*rds.CreateDBSecurityGroupOutput) 1159 return ret0, ret1 1160 } 1161 1162 // CreateDBSecurityGroupRequest indicates an expected call of CreateDBSecurityGroupRequest 1163 func (mr *MockRDSAPIMockRecorder) CreateDBSecurityGroupRequest(arg0 interface{}) *gomock.Call { 1164 mr.mock.ctrl.T.Helper() 1165 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDBSecurityGroupRequest", reflect.TypeOf((*MockRDSAPI)(nil).CreateDBSecurityGroupRequest), arg0) 1166 } 1167 1168 // CreateDBSecurityGroupWithContext mocks base method 1169 func (m *MockRDSAPI) CreateDBSecurityGroupWithContext(arg0 context.Context, arg1 *rds.CreateDBSecurityGroupInput, arg2 ...request.Option) (*rds.CreateDBSecurityGroupOutput, error) { 1170 m.ctrl.T.Helper() 1171 varargs := []interface{}{arg0, arg1} 1172 for _, a := range arg2 { 1173 varargs = append(varargs, a) 1174 } 1175 ret := m.ctrl.Call(m, "CreateDBSecurityGroupWithContext", varargs...) 1176 ret0, _ := ret[0].(*rds.CreateDBSecurityGroupOutput) 1177 ret1, _ := ret[1].(error) 1178 return ret0, ret1 1179 } 1180 1181 // CreateDBSecurityGroupWithContext indicates an expected call of CreateDBSecurityGroupWithContext 1182 func (mr *MockRDSAPIMockRecorder) CreateDBSecurityGroupWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 1183 mr.mock.ctrl.T.Helper() 1184 varargs := append([]interface{}{arg0, arg1}, arg2...) 1185 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDBSecurityGroupWithContext", reflect.TypeOf((*MockRDSAPI)(nil).CreateDBSecurityGroupWithContext), varargs...) 1186 } 1187 1188 // CreateDBSnapshot mocks base method 1189 func (m *MockRDSAPI) CreateDBSnapshot(arg0 *rds.CreateDBSnapshotInput) (*rds.CreateDBSnapshotOutput, error) { 1190 m.ctrl.T.Helper() 1191 ret := m.ctrl.Call(m, "CreateDBSnapshot", arg0) 1192 ret0, _ := ret[0].(*rds.CreateDBSnapshotOutput) 1193 ret1, _ := ret[1].(error) 1194 return ret0, ret1 1195 } 1196 1197 // CreateDBSnapshot indicates an expected call of CreateDBSnapshot 1198 func (mr *MockRDSAPIMockRecorder) CreateDBSnapshot(arg0 interface{}) *gomock.Call { 1199 mr.mock.ctrl.T.Helper() 1200 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDBSnapshot", reflect.TypeOf((*MockRDSAPI)(nil).CreateDBSnapshot), arg0) 1201 } 1202 1203 // CreateDBSnapshotRequest mocks base method 1204 func (m *MockRDSAPI) CreateDBSnapshotRequest(arg0 *rds.CreateDBSnapshotInput) (*request.Request, *rds.CreateDBSnapshotOutput) { 1205 m.ctrl.T.Helper() 1206 ret := m.ctrl.Call(m, "CreateDBSnapshotRequest", arg0) 1207 ret0, _ := ret[0].(*request.Request) 1208 ret1, _ := ret[1].(*rds.CreateDBSnapshotOutput) 1209 return ret0, ret1 1210 } 1211 1212 // CreateDBSnapshotRequest indicates an expected call of CreateDBSnapshotRequest 1213 func (mr *MockRDSAPIMockRecorder) CreateDBSnapshotRequest(arg0 interface{}) *gomock.Call { 1214 mr.mock.ctrl.T.Helper() 1215 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDBSnapshotRequest", reflect.TypeOf((*MockRDSAPI)(nil).CreateDBSnapshotRequest), arg0) 1216 } 1217 1218 // CreateDBSnapshotWithContext mocks base method 1219 func (m *MockRDSAPI) CreateDBSnapshotWithContext(arg0 context.Context, arg1 *rds.CreateDBSnapshotInput, arg2 ...request.Option) (*rds.CreateDBSnapshotOutput, error) { 1220 m.ctrl.T.Helper() 1221 varargs := []interface{}{arg0, arg1} 1222 for _, a := range arg2 { 1223 varargs = append(varargs, a) 1224 } 1225 ret := m.ctrl.Call(m, "CreateDBSnapshotWithContext", varargs...) 1226 ret0, _ := ret[0].(*rds.CreateDBSnapshotOutput) 1227 ret1, _ := ret[1].(error) 1228 return ret0, ret1 1229 } 1230 1231 // CreateDBSnapshotWithContext indicates an expected call of CreateDBSnapshotWithContext 1232 func (mr *MockRDSAPIMockRecorder) CreateDBSnapshotWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 1233 mr.mock.ctrl.T.Helper() 1234 varargs := append([]interface{}{arg0, arg1}, arg2...) 1235 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDBSnapshotWithContext", reflect.TypeOf((*MockRDSAPI)(nil).CreateDBSnapshotWithContext), varargs...) 1236 } 1237 1238 // CreateDBSubnetGroup mocks base method 1239 func (m *MockRDSAPI) CreateDBSubnetGroup(arg0 *rds.CreateDBSubnetGroupInput) (*rds.CreateDBSubnetGroupOutput, error) { 1240 m.ctrl.T.Helper() 1241 ret := m.ctrl.Call(m, "CreateDBSubnetGroup", arg0) 1242 ret0, _ := ret[0].(*rds.CreateDBSubnetGroupOutput) 1243 ret1, _ := ret[1].(error) 1244 return ret0, ret1 1245 } 1246 1247 // CreateDBSubnetGroup indicates an expected call of CreateDBSubnetGroup 1248 func (mr *MockRDSAPIMockRecorder) CreateDBSubnetGroup(arg0 interface{}) *gomock.Call { 1249 mr.mock.ctrl.T.Helper() 1250 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDBSubnetGroup", reflect.TypeOf((*MockRDSAPI)(nil).CreateDBSubnetGroup), arg0) 1251 } 1252 1253 // CreateDBSubnetGroupRequest mocks base method 1254 func (m *MockRDSAPI) CreateDBSubnetGroupRequest(arg0 *rds.CreateDBSubnetGroupInput) (*request.Request, *rds.CreateDBSubnetGroupOutput) { 1255 m.ctrl.T.Helper() 1256 ret := m.ctrl.Call(m, "CreateDBSubnetGroupRequest", arg0) 1257 ret0, _ := ret[0].(*request.Request) 1258 ret1, _ := ret[1].(*rds.CreateDBSubnetGroupOutput) 1259 return ret0, ret1 1260 } 1261 1262 // CreateDBSubnetGroupRequest indicates an expected call of CreateDBSubnetGroupRequest 1263 func (mr *MockRDSAPIMockRecorder) CreateDBSubnetGroupRequest(arg0 interface{}) *gomock.Call { 1264 mr.mock.ctrl.T.Helper() 1265 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDBSubnetGroupRequest", reflect.TypeOf((*MockRDSAPI)(nil).CreateDBSubnetGroupRequest), arg0) 1266 } 1267 1268 // CreateDBSubnetGroupWithContext mocks base method 1269 func (m *MockRDSAPI) CreateDBSubnetGroupWithContext(arg0 context.Context, arg1 *rds.CreateDBSubnetGroupInput, arg2 ...request.Option) (*rds.CreateDBSubnetGroupOutput, error) { 1270 m.ctrl.T.Helper() 1271 varargs := []interface{}{arg0, arg1} 1272 for _, a := range arg2 { 1273 varargs = append(varargs, a) 1274 } 1275 ret := m.ctrl.Call(m, "CreateDBSubnetGroupWithContext", varargs...) 1276 ret0, _ := ret[0].(*rds.CreateDBSubnetGroupOutput) 1277 ret1, _ := ret[1].(error) 1278 return ret0, ret1 1279 } 1280 1281 // CreateDBSubnetGroupWithContext indicates an expected call of CreateDBSubnetGroupWithContext 1282 func (mr *MockRDSAPIMockRecorder) CreateDBSubnetGroupWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 1283 mr.mock.ctrl.T.Helper() 1284 varargs := append([]interface{}{arg0, arg1}, arg2...) 1285 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDBSubnetGroupWithContext", reflect.TypeOf((*MockRDSAPI)(nil).CreateDBSubnetGroupWithContext), varargs...) 1286 } 1287 1288 // CreateEventSubscription mocks base method 1289 func (m *MockRDSAPI) CreateEventSubscription(arg0 *rds.CreateEventSubscriptionInput) (*rds.CreateEventSubscriptionOutput, error) { 1290 m.ctrl.T.Helper() 1291 ret := m.ctrl.Call(m, "CreateEventSubscription", arg0) 1292 ret0, _ := ret[0].(*rds.CreateEventSubscriptionOutput) 1293 ret1, _ := ret[1].(error) 1294 return ret0, ret1 1295 } 1296 1297 // CreateEventSubscription indicates an expected call of CreateEventSubscription 1298 func (mr *MockRDSAPIMockRecorder) CreateEventSubscription(arg0 interface{}) *gomock.Call { 1299 mr.mock.ctrl.T.Helper() 1300 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateEventSubscription", reflect.TypeOf((*MockRDSAPI)(nil).CreateEventSubscription), arg0) 1301 } 1302 1303 // CreateEventSubscriptionRequest mocks base method 1304 func (m *MockRDSAPI) CreateEventSubscriptionRequest(arg0 *rds.CreateEventSubscriptionInput) (*request.Request, *rds.CreateEventSubscriptionOutput) { 1305 m.ctrl.T.Helper() 1306 ret := m.ctrl.Call(m, "CreateEventSubscriptionRequest", arg0) 1307 ret0, _ := ret[0].(*request.Request) 1308 ret1, _ := ret[1].(*rds.CreateEventSubscriptionOutput) 1309 return ret0, ret1 1310 } 1311 1312 // CreateEventSubscriptionRequest indicates an expected call of CreateEventSubscriptionRequest 1313 func (mr *MockRDSAPIMockRecorder) CreateEventSubscriptionRequest(arg0 interface{}) *gomock.Call { 1314 mr.mock.ctrl.T.Helper() 1315 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateEventSubscriptionRequest", reflect.TypeOf((*MockRDSAPI)(nil).CreateEventSubscriptionRequest), arg0) 1316 } 1317 1318 // CreateEventSubscriptionWithContext mocks base method 1319 func (m *MockRDSAPI) CreateEventSubscriptionWithContext(arg0 context.Context, arg1 *rds.CreateEventSubscriptionInput, arg2 ...request.Option) (*rds.CreateEventSubscriptionOutput, error) { 1320 m.ctrl.T.Helper() 1321 varargs := []interface{}{arg0, arg1} 1322 for _, a := range arg2 { 1323 varargs = append(varargs, a) 1324 } 1325 ret := m.ctrl.Call(m, "CreateEventSubscriptionWithContext", varargs...) 1326 ret0, _ := ret[0].(*rds.CreateEventSubscriptionOutput) 1327 ret1, _ := ret[1].(error) 1328 return ret0, ret1 1329 } 1330 1331 // CreateEventSubscriptionWithContext indicates an expected call of CreateEventSubscriptionWithContext 1332 func (mr *MockRDSAPIMockRecorder) CreateEventSubscriptionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 1333 mr.mock.ctrl.T.Helper() 1334 varargs := append([]interface{}{arg0, arg1}, arg2...) 1335 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateEventSubscriptionWithContext", reflect.TypeOf((*MockRDSAPI)(nil).CreateEventSubscriptionWithContext), varargs...) 1336 } 1337 1338 // CreateGlobalCluster mocks base method 1339 func (m *MockRDSAPI) CreateGlobalCluster(arg0 *rds.CreateGlobalClusterInput) (*rds.CreateGlobalClusterOutput, error) { 1340 m.ctrl.T.Helper() 1341 ret := m.ctrl.Call(m, "CreateGlobalCluster", arg0) 1342 ret0, _ := ret[0].(*rds.CreateGlobalClusterOutput) 1343 ret1, _ := ret[1].(error) 1344 return ret0, ret1 1345 } 1346 1347 // CreateGlobalCluster indicates an expected call of CreateGlobalCluster 1348 func (mr *MockRDSAPIMockRecorder) CreateGlobalCluster(arg0 interface{}) *gomock.Call { 1349 mr.mock.ctrl.T.Helper() 1350 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateGlobalCluster", reflect.TypeOf((*MockRDSAPI)(nil).CreateGlobalCluster), arg0) 1351 } 1352 1353 // CreateGlobalClusterRequest mocks base method 1354 func (m *MockRDSAPI) CreateGlobalClusterRequest(arg0 *rds.CreateGlobalClusterInput) (*request.Request, *rds.CreateGlobalClusterOutput) { 1355 m.ctrl.T.Helper() 1356 ret := m.ctrl.Call(m, "CreateGlobalClusterRequest", arg0) 1357 ret0, _ := ret[0].(*request.Request) 1358 ret1, _ := ret[1].(*rds.CreateGlobalClusterOutput) 1359 return ret0, ret1 1360 } 1361 1362 // CreateGlobalClusterRequest indicates an expected call of CreateGlobalClusterRequest 1363 func (mr *MockRDSAPIMockRecorder) CreateGlobalClusterRequest(arg0 interface{}) *gomock.Call { 1364 mr.mock.ctrl.T.Helper() 1365 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateGlobalClusterRequest", reflect.TypeOf((*MockRDSAPI)(nil).CreateGlobalClusterRequest), arg0) 1366 } 1367 1368 // CreateGlobalClusterWithContext mocks base method 1369 func (m *MockRDSAPI) CreateGlobalClusterWithContext(arg0 context.Context, arg1 *rds.CreateGlobalClusterInput, arg2 ...request.Option) (*rds.CreateGlobalClusterOutput, error) { 1370 m.ctrl.T.Helper() 1371 varargs := []interface{}{arg0, arg1} 1372 for _, a := range arg2 { 1373 varargs = append(varargs, a) 1374 } 1375 ret := m.ctrl.Call(m, "CreateGlobalClusterWithContext", varargs...) 1376 ret0, _ := ret[0].(*rds.CreateGlobalClusterOutput) 1377 ret1, _ := ret[1].(error) 1378 return ret0, ret1 1379 } 1380 1381 // CreateGlobalClusterWithContext indicates an expected call of CreateGlobalClusterWithContext 1382 func (mr *MockRDSAPIMockRecorder) CreateGlobalClusterWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 1383 mr.mock.ctrl.T.Helper() 1384 varargs := append([]interface{}{arg0, arg1}, arg2...) 1385 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateGlobalClusterWithContext", reflect.TypeOf((*MockRDSAPI)(nil).CreateGlobalClusterWithContext), varargs...) 1386 } 1387 1388 // CreateOptionGroup mocks base method 1389 func (m *MockRDSAPI) CreateOptionGroup(arg0 *rds.CreateOptionGroupInput) (*rds.CreateOptionGroupOutput, error) { 1390 m.ctrl.T.Helper() 1391 ret := m.ctrl.Call(m, "CreateOptionGroup", arg0) 1392 ret0, _ := ret[0].(*rds.CreateOptionGroupOutput) 1393 ret1, _ := ret[1].(error) 1394 return ret0, ret1 1395 } 1396 1397 // CreateOptionGroup indicates an expected call of CreateOptionGroup 1398 func (mr *MockRDSAPIMockRecorder) CreateOptionGroup(arg0 interface{}) *gomock.Call { 1399 mr.mock.ctrl.T.Helper() 1400 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateOptionGroup", reflect.TypeOf((*MockRDSAPI)(nil).CreateOptionGroup), arg0) 1401 } 1402 1403 // CreateOptionGroupRequest mocks base method 1404 func (m *MockRDSAPI) CreateOptionGroupRequest(arg0 *rds.CreateOptionGroupInput) (*request.Request, *rds.CreateOptionGroupOutput) { 1405 m.ctrl.T.Helper() 1406 ret := m.ctrl.Call(m, "CreateOptionGroupRequest", arg0) 1407 ret0, _ := ret[0].(*request.Request) 1408 ret1, _ := ret[1].(*rds.CreateOptionGroupOutput) 1409 return ret0, ret1 1410 } 1411 1412 // CreateOptionGroupRequest indicates an expected call of CreateOptionGroupRequest 1413 func (mr *MockRDSAPIMockRecorder) CreateOptionGroupRequest(arg0 interface{}) *gomock.Call { 1414 mr.mock.ctrl.T.Helper() 1415 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateOptionGroupRequest", reflect.TypeOf((*MockRDSAPI)(nil).CreateOptionGroupRequest), arg0) 1416 } 1417 1418 // CreateOptionGroupWithContext mocks base method 1419 func (m *MockRDSAPI) CreateOptionGroupWithContext(arg0 context.Context, arg1 *rds.CreateOptionGroupInput, arg2 ...request.Option) (*rds.CreateOptionGroupOutput, error) { 1420 m.ctrl.T.Helper() 1421 varargs := []interface{}{arg0, arg1} 1422 for _, a := range arg2 { 1423 varargs = append(varargs, a) 1424 } 1425 ret := m.ctrl.Call(m, "CreateOptionGroupWithContext", varargs...) 1426 ret0, _ := ret[0].(*rds.CreateOptionGroupOutput) 1427 ret1, _ := ret[1].(error) 1428 return ret0, ret1 1429 } 1430 1431 // CreateOptionGroupWithContext indicates an expected call of CreateOptionGroupWithContext 1432 func (mr *MockRDSAPIMockRecorder) CreateOptionGroupWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 1433 mr.mock.ctrl.T.Helper() 1434 varargs := append([]interface{}{arg0, arg1}, arg2...) 1435 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateOptionGroupWithContext", reflect.TypeOf((*MockRDSAPI)(nil).CreateOptionGroupWithContext), varargs...) 1436 } 1437 1438 // DeleteCustomAvailabilityZone mocks base method 1439 func (m *MockRDSAPI) DeleteCustomAvailabilityZone(arg0 *rds.DeleteCustomAvailabilityZoneInput) (*rds.DeleteCustomAvailabilityZoneOutput, error) { 1440 m.ctrl.T.Helper() 1441 ret := m.ctrl.Call(m, "DeleteCustomAvailabilityZone", arg0) 1442 ret0, _ := ret[0].(*rds.DeleteCustomAvailabilityZoneOutput) 1443 ret1, _ := ret[1].(error) 1444 return ret0, ret1 1445 } 1446 1447 // DeleteCustomAvailabilityZone indicates an expected call of DeleteCustomAvailabilityZone 1448 func (mr *MockRDSAPIMockRecorder) DeleteCustomAvailabilityZone(arg0 interface{}) *gomock.Call { 1449 mr.mock.ctrl.T.Helper() 1450 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCustomAvailabilityZone", reflect.TypeOf((*MockRDSAPI)(nil).DeleteCustomAvailabilityZone), arg0) 1451 } 1452 1453 // DeleteCustomAvailabilityZoneRequest mocks base method 1454 func (m *MockRDSAPI) DeleteCustomAvailabilityZoneRequest(arg0 *rds.DeleteCustomAvailabilityZoneInput) (*request.Request, *rds.DeleteCustomAvailabilityZoneOutput) { 1455 m.ctrl.T.Helper() 1456 ret := m.ctrl.Call(m, "DeleteCustomAvailabilityZoneRequest", arg0) 1457 ret0, _ := ret[0].(*request.Request) 1458 ret1, _ := ret[1].(*rds.DeleteCustomAvailabilityZoneOutput) 1459 return ret0, ret1 1460 } 1461 1462 // DeleteCustomAvailabilityZoneRequest indicates an expected call of DeleteCustomAvailabilityZoneRequest 1463 func (mr *MockRDSAPIMockRecorder) DeleteCustomAvailabilityZoneRequest(arg0 interface{}) *gomock.Call { 1464 mr.mock.ctrl.T.Helper() 1465 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCustomAvailabilityZoneRequest", reflect.TypeOf((*MockRDSAPI)(nil).DeleteCustomAvailabilityZoneRequest), arg0) 1466 } 1467 1468 // DeleteCustomAvailabilityZoneWithContext mocks base method 1469 func (m *MockRDSAPI) DeleteCustomAvailabilityZoneWithContext(arg0 context.Context, arg1 *rds.DeleteCustomAvailabilityZoneInput, arg2 ...request.Option) (*rds.DeleteCustomAvailabilityZoneOutput, error) { 1470 m.ctrl.T.Helper() 1471 varargs := []interface{}{arg0, arg1} 1472 for _, a := range arg2 { 1473 varargs = append(varargs, a) 1474 } 1475 ret := m.ctrl.Call(m, "DeleteCustomAvailabilityZoneWithContext", varargs...) 1476 ret0, _ := ret[0].(*rds.DeleteCustomAvailabilityZoneOutput) 1477 ret1, _ := ret[1].(error) 1478 return ret0, ret1 1479 } 1480 1481 // DeleteCustomAvailabilityZoneWithContext indicates an expected call of DeleteCustomAvailabilityZoneWithContext 1482 func (mr *MockRDSAPIMockRecorder) DeleteCustomAvailabilityZoneWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 1483 mr.mock.ctrl.T.Helper() 1484 varargs := append([]interface{}{arg0, arg1}, arg2...) 1485 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCustomAvailabilityZoneWithContext", reflect.TypeOf((*MockRDSAPI)(nil).DeleteCustomAvailabilityZoneWithContext), varargs...) 1486 } 1487 1488 // DeleteDBCluster mocks base method 1489 func (m *MockRDSAPI) DeleteDBCluster(arg0 *rds.DeleteDBClusterInput) (*rds.DeleteDBClusterOutput, error) { 1490 m.ctrl.T.Helper() 1491 ret := m.ctrl.Call(m, "DeleteDBCluster", arg0) 1492 ret0, _ := ret[0].(*rds.DeleteDBClusterOutput) 1493 ret1, _ := ret[1].(error) 1494 return ret0, ret1 1495 } 1496 1497 // DeleteDBCluster indicates an expected call of DeleteDBCluster 1498 func (mr *MockRDSAPIMockRecorder) DeleteDBCluster(arg0 interface{}) *gomock.Call { 1499 mr.mock.ctrl.T.Helper() 1500 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDBCluster", reflect.TypeOf((*MockRDSAPI)(nil).DeleteDBCluster), arg0) 1501 } 1502 1503 // DeleteDBClusterEndpoint mocks base method 1504 func (m *MockRDSAPI) DeleteDBClusterEndpoint(arg0 *rds.DeleteDBClusterEndpointInput) (*rds.DeleteDBClusterEndpointOutput, error) { 1505 m.ctrl.T.Helper() 1506 ret := m.ctrl.Call(m, "DeleteDBClusterEndpoint", arg0) 1507 ret0, _ := ret[0].(*rds.DeleteDBClusterEndpointOutput) 1508 ret1, _ := ret[1].(error) 1509 return ret0, ret1 1510 } 1511 1512 // DeleteDBClusterEndpoint indicates an expected call of DeleteDBClusterEndpoint 1513 func (mr *MockRDSAPIMockRecorder) DeleteDBClusterEndpoint(arg0 interface{}) *gomock.Call { 1514 mr.mock.ctrl.T.Helper() 1515 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDBClusterEndpoint", reflect.TypeOf((*MockRDSAPI)(nil).DeleteDBClusterEndpoint), arg0) 1516 } 1517 1518 // DeleteDBClusterEndpointRequest mocks base method 1519 func (m *MockRDSAPI) DeleteDBClusterEndpointRequest(arg0 *rds.DeleteDBClusterEndpointInput) (*request.Request, *rds.DeleteDBClusterEndpointOutput) { 1520 m.ctrl.T.Helper() 1521 ret := m.ctrl.Call(m, "DeleteDBClusterEndpointRequest", arg0) 1522 ret0, _ := ret[0].(*request.Request) 1523 ret1, _ := ret[1].(*rds.DeleteDBClusterEndpointOutput) 1524 return ret0, ret1 1525 } 1526 1527 // DeleteDBClusterEndpointRequest indicates an expected call of DeleteDBClusterEndpointRequest 1528 func (mr *MockRDSAPIMockRecorder) DeleteDBClusterEndpointRequest(arg0 interface{}) *gomock.Call { 1529 mr.mock.ctrl.T.Helper() 1530 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDBClusterEndpointRequest", reflect.TypeOf((*MockRDSAPI)(nil).DeleteDBClusterEndpointRequest), arg0) 1531 } 1532 1533 // DeleteDBClusterEndpointWithContext mocks base method 1534 func (m *MockRDSAPI) DeleteDBClusterEndpointWithContext(arg0 context.Context, arg1 *rds.DeleteDBClusterEndpointInput, arg2 ...request.Option) (*rds.DeleteDBClusterEndpointOutput, error) { 1535 m.ctrl.T.Helper() 1536 varargs := []interface{}{arg0, arg1} 1537 for _, a := range arg2 { 1538 varargs = append(varargs, a) 1539 } 1540 ret := m.ctrl.Call(m, "DeleteDBClusterEndpointWithContext", varargs...) 1541 ret0, _ := ret[0].(*rds.DeleteDBClusterEndpointOutput) 1542 ret1, _ := ret[1].(error) 1543 return ret0, ret1 1544 } 1545 1546 // DeleteDBClusterEndpointWithContext indicates an expected call of DeleteDBClusterEndpointWithContext 1547 func (mr *MockRDSAPIMockRecorder) DeleteDBClusterEndpointWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 1548 mr.mock.ctrl.T.Helper() 1549 varargs := append([]interface{}{arg0, arg1}, arg2...) 1550 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDBClusterEndpointWithContext", reflect.TypeOf((*MockRDSAPI)(nil).DeleteDBClusterEndpointWithContext), varargs...) 1551 } 1552 1553 // DeleteDBClusterParameterGroup mocks base method 1554 func (m *MockRDSAPI) DeleteDBClusterParameterGroup(arg0 *rds.DeleteDBClusterParameterGroupInput) (*rds.DeleteDBClusterParameterGroupOutput, error) { 1555 m.ctrl.T.Helper() 1556 ret := m.ctrl.Call(m, "DeleteDBClusterParameterGroup", arg0) 1557 ret0, _ := ret[0].(*rds.DeleteDBClusterParameterGroupOutput) 1558 ret1, _ := ret[1].(error) 1559 return ret0, ret1 1560 } 1561 1562 // DeleteDBClusterParameterGroup indicates an expected call of DeleteDBClusterParameterGroup 1563 func (mr *MockRDSAPIMockRecorder) DeleteDBClusterParameterGroup(arg0 interface{}) *gomock.Call { 1564 mr.mock.ctrl.T.Helper() 1565 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDBClusterParameterGroup", reflect.TypeOf((*MockRDSAPI)(nil).DeleteDBClusterParameterGroup), arg0) 1566 } 1567 1568 // DeleteDBClusterParameterGroupRequest mocks base method 1569 func (m *MockRDSAPI) DeleteDBClusterParameterGroupRequest(arg0 *rds.DeleteDBClusterParameterGroupInput) (*request.Request, *rds.DeleteDBClusterParameterGroupOutput) { 1570 m.ctrl.T.Helper() 1571 ret := m.ctrl.Call(m, "DeleteDBClusterParameterGroupRequest", arg0) 1572 ret0, _ := ret[0].(*request.Request) 1573 ret1, _ := ret[1].(*rds.DeleteDBClusterParameterGroupOutput) 1574 return ret0, ret1 1575 } 1576 1577 // DeleteDBClusterParameterGroupRequest indicates an expected call of DeleteDBClusterParameterGroupRequest 1578 func (mr *MockRDSAPIMockRecorder) DeleteDBClusterParameterGroupRequest(arg0 interface{}) *gomock.Call { 1579 mr.mock.ctrl.T.Helper() 1580 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDBClusterParameterGroupRequest", reflect.TypeOf((*MockRDSAPI)(nil).DeleteDBClusterParameterGroupRequest), arg0) 1581 } 1582 1583 // DeleteDBClusterParameterGroupWithContext mocks base method 1584 func (m *MockRDSAPI) DeleteDBClusterParameterGroupWithContext(arg0 context.Context, arg1 *rds.DeleteDBClusterParameterGroupInput, arg2 ...request.Option) (*rds.DeleteDBClusterParameterGroupOutput, error) { 1585 m.ctrl.T.Helper() 1586 varargs := []interface{}{arg0, arg1} 1587 for _, a := range arg2 { 1588 varargs = append(varargs, a) 1589 } 1590 ret := m.ctrl.Call(m, "DeleteDBClusterParameterGroupWithContext", varargs...) 1591 ret0, _ := ret[0].(*rds.DeleteDBClusterParameterGroupOutput) 1592 ret1, _ := ret[1].(error) 1593 return ret0, ret1 1594 } 1595 1596 // DeleteDBClusterParameterGroupWithContext indicates an expected call of DeleteDBClusterParameterGroupWithContext 1597 func (mr *MockRDSAPIMockRecorder) DeleteDBClusterParameterGroupWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 1598 mr.mock.ctrl.T.Helper() 1599 varargs := append([]interface{}{arg0, arg1}, arg2...) 1600 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDBClusterParameterGroupWithContext", reflect.TypeOf((*MockRDSAPI)(nil).DeleteDBClusterParameterGroupWithContext), varargs...) 1601 } 1602 1603 // DeleteDBClusterRequest mocks base method 1604 func (m *MockRDSAPI) DeleteDBClusterRequest(arg0 *rds.DeleteDBClusterInput) (*request.Request, *rds.DeleteDBClusterOutput) { 1605 m.ctrl.T.Helper() 1606 ret := m.ctrl.Call(m, "DeleteDBClusterRequest", arg0) 1607 ret0, _ := ret[0].(*request.Request) 1608 ret1, _ := ret[1].(*rds.DeleteDBClusterOutput) 1609 return ret0, ret1 1610 } 1611 1612 // DeleteDBClusterRequest indicates an expected call of DeleteDBClusterRequest 1613 func (mr *MockRDSAPIMockRecorder) DeleteDBClusterRequest(arg0 interface{}) *gomock.Call { 1614 mr.mock.ctrl.T.Helper() 1615 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDBClusterRequest", reflect.TypeOf((*MockRDSAPI)(nil).DeleteDBClusterRequest), arg0) 1616 } 1617 1618 // DeleteDBClusterSnapshot mocks base method 1619 func (m *MockRDSAPI) DeleteDBClusterSnapshot(arg0 *rds.DeleteDBClusterSnapshotInput) (*rds.DeleteDBClusterSnapshotOutput, error) { 1620 m.ctrl.T.Helper() 1621 ret := m.ctrl.Call(m, "DeleteDBClusterSnapshot", arg0) 1622 ret0, _ := ret[0].(*rds.DeleteDBClusterSnapshotOutput) 1623 ret1, _ := ret[1].(error) 1624 return ret0, ret1 1625 } 1626 1627 // DeleteDBClusterSnapshot indicates an expected call of DeleteDBClusterSnapshot 1628 func (mr *MockRDSAPIMockRecorder) DeleteDBClusterSnapshot(arg0 interface{}) *gomock.Call { 1629 mr.mock.ctrl.T.Helper() 1630 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDBClusterSnapshot", reflect.TypeOf((*MockRDSAPI)(nil).DeleteDBClusterSnapshot), arg0) 1631 } 1632 1633 // DeleteDBClusterSnapshotRequest mocks base method 1634 func (m *MockRDSAPI) DeleteDBClusterSnapshotRequest(arg0 *rds.DeleteDBClusterSnapshotInput) (*request.Request, *rds.DeleteDBClusterSnapshotOutput) { 1635 m.ctrl.T.Helper() 1636 ret := m.ctrl.Call(m, "DeleteDBClusterSnapshotRequest", arg0) 1637 ret0, _ := ret[0].(*request.Request) 1638 ret1, _ := ret[1].(*rds.DeleteDBClusterSnapshotOutput) 1639 return ret0, ret1 1640 } 1641 1642 // DeleteDBClusterSnapshotRequest indicates an expected call of DeleteDBClusterSnapshotRequest 1643 func (mr *MockRDSAPIMockRecorder) DeleteDBClusterSnapshotRequest(arg0 interface{}) *gomock.Call { 1644 mr.mock.ctrl.T.Helper() 1645 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDBClusterSnapshotRequest", reflect.TypeOf((*MockRDSAPI)(nil).DeleteDBClusterSnapshotRequest), arg0) 1646 } 1647 1648 // DeleteDBClusterSnapshotWithContext mocks base method 1649 func (m *MockRDSAPI) DeleteDBClusterSnapshotWithContext(arg0 context.Context, arg1 *rds.DeleteDBClusterSnapshotInput, arg2 ...request.Option) (*rds.DeleteDBClusterSnapshotOutput, error) { 1650 m.ctrl.T.Helper() 1651 varargs := []interface{}{arg0, arg1} 1652 for _, a := range arg2 { 1653 varargs = append(varargs, a) 1654 } 1655 ret := m.ctrl.Call(m, "DeleteDBClusterSnapshotWithContext", varargs...) 1656 ret0, _ := ret[0].(*rds.DeleteDBClusterSnapshotOutput) 1657 ret1, _ := ret[1].(error) 1658 return ret0, ret1 1659 } 1660 1661 // DeleteDBClusterSnapshotWithContext indicates an expected call of DeleteDBClusterSnapshotWithContext 1662 func (mr *MockRDSAPIMockRecorder) DeleteDBClusterSnapshotWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 1663 mr.mock.ctrl.T.Helper() 1664 varargs := append([]interface{}{arg0, arg1}, arg2...) 1665 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDBClusterSnapshotWithContext", reflect.TypeOf((*MockRDSAPI)(nil).DeleteDBClusterSnapshotWithContext), varargs...) 1666 } 1667 1668 // DeleteDBClusterWithContext mocks base method 1669 func (m *MockRDSAPI) DeleteDBClusterWithContext(arg0 context.Context, arg1 *rds.DeleteDBClusterInput, arg2 ...request.Option) (*rds.DeleteDBClusterOutput, error) { 1670 m.ctrl.T.Helper() 1671 varargs := []interface{}{arg0, arg1} 1672 for _, a := range arg2 { 1673 varargs = append(varargs, a) 1674 } 1675 ret := m.ctrl.Call(m, "DeleteDBClusterWithContext", varargs...) 1676 ret0, _ := ret[0].(*rds.DeleteDBClusterOutput) 1677 ret1, _ := ret[1].(error) 1678 return ret0, ret1 1679 } 1680 1681 // DeleteDBClusterWithContext indicates an expected call of DeleteDBClusterWithContext 1682 func (mr *MockRDSAPIMockRecorder) DeleteDBClusterWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 1683 mr.mock.ctrl.T.Helper() 1684 varargs := append([]interface{}{arg0, arg1}, arg2...) 1685 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDBClusterWithContext", reflect.TypeOf((*MockRDSAPI)(nil).DeleteDBClusterWithContext), varargs...) 1686 } 1687 1688 // DeleteDBInstance mocks base method 1689 func (m *MockRDSAPI) DeleteDBInstance(arg0 *rds.DeleteDBInstanceInput) (*rds.DeleteDBInstanceOutput, error) { 1690 m.ctrl.T.Helper() 1691 ret := m.ctrl.Call(m, "DeleteDBInstance", arg0) 1692 ret0, _ := ret[0].(*rds.DeleteDBInstanceOutput) 1693 ret1, _ := ret[1].(error) 1694 return ret0, ret1 1695 } 1696 1697 // DeleteDBInstance indicates an expected call of DeleteDBInstance 1698 func (mr *MockRDSAPIMockRecorder) DeleteDBInstance(arg0 interface{}) *gomock.Call { 1699 mr.mock.ctrl.T.Helper() 1700 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDBInstance", reflect.TypeOf((*MockRDSAPI)(nil).DeleteDBInstance), arg0) 1701 } 1702 1703 // DeleteDBInstanceAutomatedBackup mocks base method 1704 func (m *MockRDSAPI) DeleteDBInstanceAutomatedBackup(arg0 *rds.DeleteDBInstanceAutomatedBackupInput) (*rds.DeleteDBInstanceAutomatedBackupOutput, error) { 1705 m.ctrl.T.Helper() 1706 ret := m.ctrl.Call(m, "DeleteDBInstanceAutomatedBackup", arg0) 1707 ret0, _ := ret[0].(*rds.DeleteDBInstanceAutomatedBackupOutput) 1708 ret1, _ := ret[1].(error) 1709 return ret0, ret1 1710 } 1711 1712 // DeleteDBInstanceAutomatedBackup indicates an expected call of DeleteDBInstanceAutomatedBackup 1713 func (mr *MockRDSAPIMockRecorder) DeleteDBInstanceAutomatedBackup(arg0 interface{}) *gomock.Call { 1714 mr.mock.ctrl.T.Helper() 1715 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDBInstanceAutomatedBackup", reflect.TypeOf((*MockRDSAPI)(nil).DeleteDBInstanceAutomatedBackup), arg0) 1716 } 1717 1718 // DeleteDBInstanceAutomatedBackupRequest mocks base method 1719 func (m *MockRDSAPI) DeleteDBInstanceAutomatedBackupRequest(arg0 *rds.DeleteDBInstanceAutomatedBackupInput) (*request.Request, *rds.DeleteDBInstanceAutomatedBackupOutput) { 1720 m.ctrl.T.Helper() 1721 ret := m.ctrl.Call(m, "DeleteDBInstanceAutomatedBackupRequest", arg0) 1722 ret0, _ := ret[0].(*request.Request) 1723 ret1, _ := ret[1].(*rds.DeleteDBInstanceAutomatedBackupOutput) 1724 return ret0, ret1 1725 } 1726 1727 // DeleteDBInstanceAutomatedBackupRequest indicates an expected call of DeleteDBInstanceAutomatedBackupRequest 1728 func (mr *MockRDSAPIMockRecorder) DeleteDBInstanceAutomatedBackupRequest(arg0 interface{}) *gomock.Call { 1729 mr.mock.ctrl.T.Helper() 1730 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDBInstanceAutomatedBackupRequest", reflect.TypeOf((*MockRDSAPI)(nil).DeleteDBInstanceAutomatedBackupRequest), arg0) 1731 } 1732 1733 // DeleteDBInstanceAutomatedBackupWithContext mocks base method 1734 func (m *MockRDSAPI) DeleteDBInstanceAutomatedBackupWithContext(arg0 context.Context, arg1 *rds.DeleteDBInstanceAutomatedBackupInput, arg2 ...request.Option) (*rds.DeleteDBInstanceAutomatedBackupOutput, error) { 1735 m.ctrl.T.Helper() 1736 varargs := []interface{}{arg0, arg1} 1737 for _, a := range arg2 { 1738 varargs = append(varargs, a) 1739 } 1740 ret := m.ctrl.Call(m, "DeleteDBInstanceAutomatedBackupWithContext", varargs...) 1741 ret0, _ := ret[0].(*rds.DeleteDBInstanceAutomatedBackupOutput) 1742 ret1, _ := ret[1].(error) 1743 return ret0, ret1 1744 } 1745 1746 // DeleteDBInstanceAutomatedBackupWithContext indicates an expected call of DeleteDBInstanceAutomatedBackupWithContext 1747 func (mr *MockRDSAPIMockRecorder) DeleteDBInstanceAutomatedBackupWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 1748 mr.mock.ctrl.T.Helper() 1749 varargs := append([]interface{}{arg0, arg1}, arg2...) 1750 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDBInstanceAutomatedBackupWithContext", reflect.TypeOf((*MockRDSAPI)(nil).DeleteDBInstanceAutomatedBackupWithContext), varargs...) 1751 } 1752 1753 // DeleteDBInstanceRequest mocks base method 1754 func (m *MockRDSAPI) DeleteDBInstanceRequest(arg0 *rds.DeleteDBInstanceInput) (*request.Request, *rds.DeleteDBInstanceOutput) { 1755 m.ctrl.T.Helper() 1756 ret := m.ctrl.Call(m, "DeleteDBInstanceRequest", arg0) 1757 ret0, _ := ret[0].(*request.Request) 1758 ret1, _ := ret[1].(*rds.DeleteDBInstanceOutput) 1759 return ret0, ret1 1760 } 1761 1762 // DeleteDBInstanceRequest indicates an expected call of DeleteDBInstanceRequest 1763 func (mr *MockRDSAPIMockRecorder) DeleteDBInstanceRequest(arg0 interface{}) *gomock.Call { 1764 mr.mock.ctrl.T.Helper() 1765 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDBInstanceRequest", reflect.TypeOf((*MockRDSAPI)(nil).DeleteDBInstanceRequest), arg0) 1766 } 1767 1768 // DeleteDBInstanceWithContext mocks base method 1769 func (m *MockRDSAPI) DeleteDBInstanceWithContext(arg0 context.Context, arg1 *rds.DeleteDBInstanceInput, arg2 ...request.Option) (*rds.DeleteDBInstanceOutput, error) { 1770 m.ctrl.T.Helper() 1771 varargs := []interface{}{arg0, arg1} 1772 for _, a := range arg2 { 1773 varargs = append(varargs, a) 1774 } 1775 ret := m.ctrl.Call(m, "DeleteDBInstanceWithContext", varargs...) 1776 ret0, _ := ret[0].(*rds.DeleteDBInstanceOutput) 1777 ret1, _ := ret[1].(error) 1778 return ret0, ret1 1779 } 1780 1781 // DeleteDBInstanceWithContext indicates an expected call of DeleteDBInstanceWithContext 1782 func (mr *MockRDSAPIMockRecorder) DeleteDBInstanceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 1783 mr.mock.ctrl.T.Helper() 1784 varargs := append([]interface{}{arg0, arg1}, arg2...) 1785 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDBInstanceWithContext", reflect.TypeOf((*MockRDSAPI)(nil).DeleteDBInstanceWithContext), varargs...) 1786 } 1787 1788 // DeleteDBParameterGroup mocks base method 1789 func (m *MockRDSAPI) DeleteDBParameterGroup(arg0 *rds.DeleteDBParameterGroupInput) (*rds.DeleteDBParameterGroupOutput, error) { 1790 m.ctrl.T.Helper() 1791 ret := m.ctrl.Call(m, "DeleteDBParameterGroup", arg0) 1792 ret0, _ := ret[0].(*rds.DeleteDBParameterGroupOutput) 1793 ret1, _ := ret[1].(error) 1794 return ret0, ret1 1795 } 1796 1797 // DeleteDBParameterGroup indicates an expected call of DeleteDBParameterGroup 1798 func (mr *MockRDSAPIMockRecorder) DeleteDBParameterGroup(arg0 interface{}) *gomock.Call { 1799 mr.mock.ctrl.T.Helper() 1800 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDBParameterGroup", reflect.TypeOf((*MockRDSAPI)(nil).DeleteDBParameterGroup), arg0) 1801 } 1802 1803 // DeleteDBParameterGroupRequest mocks base method 1804 func (m *MockRDSAPI) DeleteDBParameterGroupRequest(arg0 *rds.DeleteDBParameterGroupInput) (*request.Request, *rds.DeleteDBParameterGroupOutput) { 1805 m.ctrl.T.Helper() 1806 ret := m.ctrl.Call(m, "DeleteDBParameterGroupRequest", arg0) 1807 ret0, _ := ret[0].(*request.Request) 1808 ret1, _ := ret[1].(*rds.DeleteDBParameterGroupOutput) 1809 return ret0, ret1 1810 } 1811 1812 // DeleteDBParameterGroupRequest indicates an expected call of DeleteDBParameterGroupRequest 1813 func (mr *MockRDSAPIMockRecorder) DeleteDBParameterGroupRequest(arg0 interface{}) *gomock.Call { 1814 mr.mock.ctrl.T.Helper() 1815 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDBParameterGroupRequest", reflect.TypeOf((*MockRDSAPI)(nil).DeleteDBParameterGroupRequest), arg0) 1816 } 1817 1818 // DeleteDBParameterGroupWithContext mocks base method 1819 func (m *MockRDSAPI) DeleteDBParameterGroupWithContext(arg0 context.Context, arg1 *rds.DeleteDBParameterGroupInput, arg2 ...request.Option) (*rds.DeleteDBParameterGroupOutput, error) { 1820 m.ctrl.T.Helper() 1821 varargs := []interface{}{arg0, arg1} 1822 for _, a := range arg2 { 1823 varargs = append(varargs, a) 1824 } 1825 ret := m.ctrl.Call(m, "DeleteDBParameterGroupWithContext", varargs...) 1826 ret0, _ := ret[0].(*rds.DeleteDBParameterGroupOutput) 1827 ret1, _ := ret[1].(error) 1828 return ret0, ret1 1829 } 1830 1831 // DeleteDBParameterGroupWithContext indicates an expected call of DeleteDBParameterGroupWithContext 1832 func (mr *MockRDSAPIMockRecorder) DeleteDBParameterGroupWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 1833 mr.mock.ctrl.T.Helper() 1834 varargs := append([]interface{}{arg0, arg1}, arg2...) 1835 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDBParameterGroupWithContext", reflect.TypeOf((*MockRDSAPI)(nil).DeleteDBParameterGroupWithContext), varargs...) 1836 } 1837 1838 // DeleteDBProxy mocks base method 1839 func (m *MockRDSAPI) DeleteDBProxy(arg0 *rds.DeleteDBProxyInput) (*rds.DeleteDBProxyOutput, error) { 1840 m.ctrl.T.Helper() 1841 ret := m.ctrl.Call(m, "DeleteDBProxy", arg0) 1842 ret0, _ := ret[0].(*rds.DeleteDBProxyOutput) 1843 ret1, _ := ret[1].(error) 1844 return ret0, ret1 1845 } 1846 1847 // DeleteDBProxy indicates an expected call of DeleteDBProxy 1848 func (mr *MockRDSAPIMockRecorder) DeleteDBProxy(arg0 interface{}) *gomock.Call { 1849 mr.mock.ctrl.T.Helper() 1850 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDBProxy", reflect.TypeOf((*MockRDSAPI)(nil).DeleteDBProxy), arg0) 1851 } 1852 1853 // DeleteDBProxyRequest mocks base method 1854 func (m *MockRDSAPI) DeleteDBProxyRequest(arg0 *rds.DeleteDBProxyInput) (*request.Request, *rds.DeleteDBProxyOutput) { 1855 m.ctrl.T.Helper() 1856 ret := m.ctrl.Call(m, "DeleteDBProxyRequest", arg0) 1857 ret0, _ := ret[0].(*request.Request) 1858 ret1, _ := ret[1].(*rds.DeleteDBProxyOutput) 1859 return ret0, ret1 1860 } 1861 1862 // DeleteDBProxyRequest indicates an expected call of DeleteDBProxyRequest 1863 func (mr *MockRDSAPIMockRecorder) DeleteDBProxyRequest(arg0 interface{}) *gomock.Call { 1864 mr.mock.ctrl.T.Helper() 1865 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDBProxyRequest", reflect.TypeOf((*MockRDSAPI)(nil).DeleteDBProxyRequest), arg0) 1866 } 1867 1868 // DeleteDBProxyWithContext mocks base method 1869 func (m *MockRDSAPI) DeleteDBProxyWithContext(arg0 context.Context, arg1 *rds.DeleteDBProxyInput, arg2 ...request.Option) (*rds.DeleteDBProxyOutput, error) { 1870 m.ctrl.T.Helper() 1871 varargs := []interface{}{arg0, arg1} 1872 for _, a := range arg2 { 1873 varargs = append(varargs, a) 1874 } 1875 ret := m.ctrl.Call(m, "DeleteDBProxyWithContext", varargs...) 1876 ret0, _ := ret[0].(*rds.DeleteDBProxyOutput) 1877 ret1, _ := ret[1].(error) 1878 return ret0, ret1 1879 } 1880 1881 // DeleteDBProxyWithContext indicates an expected call of DeleteDBProxyWithContext 1882 func (mr *MockRDSAPIMockRecorder) DeleteDBProxyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 1883 mr.mock.ctrl.T.Helper() 1884 varargs := append([]interface{}{arg0, arg1}, arg2...) 1885 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDBProxyWithContext", reflect.TypeOf((*MockRDSAPI)(nil).DeleteDBProxyWithContext), varargs...) 1886 } 1887 1888 // DeleteDBSecurityGroup mocks base method 1889 func (m *MockRDSAPI) DeleteDBSecurityGroup(arg0 *rds.DeleteDBSecurityGroupInput) (*rds.DeleteDBSecurityGroupOutput, error) { 1890 m.ctrl.T.Helper() 1891 ret := m.ctrl.Call(m, "DeleteDBSecurityGroup", arg0) 1892 ret0, _ := ret[0].(*rds.DeleteDBSecurityGroupOutput) 1893 ret1, _ := ret[1].(error) 1894 return ret0, ret1 1895 } 1896 1897 // DeleteDBSecurityGroup indicates an expected call of DeleteDBSecurityGroup 1898 func (mr *MockRDSAPIMockRecorder) DeleteDBSecurityGroup(arg0 interface{}) *gomock.Call { 1899 mr.mock.ctrl.T.Helper() 1900 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDBSecurityGroup", reflect.TypeOf((*MockRDSAPI)(nil).DeleteDBSecurityGroup), arg0) 1901 } 1902 1903 // DeleteDBSecurityGroupRequest mocks base method 1904 func (m *MockRDSAPI) DeleteDBSecurityGroupRequest(arg0 *rds.DeleteDBSecurityGroupInput) (*request.Request, *rds.DeleteDBSecurityGroupOutput) { 1905 m.ctrl.T.Helper() 1906 ret := m.ctrl.Call(m, "DeleteDBSecurityGroupRequest", arg0) 1907 ret0, _ := ret[0].(*request.Request) 1908 ret1, _ := ret[1].(*rds.DeleteDBSecurityGroupOutput) 1909 return ret0, ret1 1910 } 1911 1912 // DeleteDBSecurityGroupRequest indicates an expected call of DeleteDBSecurityGroupRequest 1913 func (mr *MockRDSAPIMockRecorder) DeleteDBSecurityGroupRequest(arg0 interface{}) *gomock.Call { 1914 mr.mock.ctrl.T.Helper() 1915 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDBSecurityGroupRequest", reflect.TypeOf((*MockRDSAPI)(nil).DeleteDBSecurityGroupRequest), arg0) 1916 } 1917 1918 // DeleteDBSecurityGroupWithContext mocks base method 1919 func (m *MockRDSAPI) DeleteDBSecurityGroupWithContext(arg0 context.Context, arg1 *rds.DeleteDBSecurityGroupInput, arg2 ...request.Option) (*rds.DeleteDBSecurityGroupOutput, error) { 1920 m.ctrl.T.Helper() 1921 varargs := []interface{}{arg0, arg1} 1922 for _, a := range arg2 { 1923 varargs = append(varargs, a) 1924 } 1925 ret := m.ctrl.Call(m, "DeleteDBSecurityGroupWithContext", varargs...) 1926 ret0, _ := ret[0].(*rds.DeleteDBSecurityGroupOutput) 1927 ret1, _ := ret[1].(error) 1928 return ret0, ret1 1929 } 1930 1931 // DeleteDBSecurityGroupWithContext indicates an expected call of DeleteDBSecurityGroupWithContext 1932 func (mr *MockRDSAPIMockRecorder) DeleteDBSecurityGroupWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 1933 mr.mock.ctrl.T.Helper() 1934 varargs := append([]interface{}{arg0, arg1}, arg2...) 1935 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDBSecurityGroupWithContext", reflect.TypeOf((*MockRDSAPI)(nil).DeleteDBSecurityGroupWithContext), varargs...) 1936 } 1937 1938 // DeleteDBSnapshot mocks base method 1939 func (m *MockRDSAPI) DeleteDBSnapshot(arg0 *rds.DeleteDBSnapshotInput) (*rds.DeleteDBSnapshotOutput, error) { 1940 m.ctrl.T.Helper() 1941 ret := m.ctrl.Call(m, "DeleteDBSnapshot", arg0) 1942 ret0, _ := ret[0].(*rds.DeleteDBSnapshotOutput) 1943 ret1, _ := ret[1].(error) 1944 return ret0, ret1 1945 } 1946 1947 // DeleteDBSnapshot indicates an expected call of DeleteDBSnapshot 1948 func (mr *MockRDSAPIMockRecorder) DeleteDBSnapshot(arg0 interface{}) *gomock.Call { 1949 mr.mock.ctrl.T.Helper() 1950 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDBSnapshot", reflect.TypeOf((*MockRDSAPI)(nil).DeleteDBSnapshot), arg0) 1951 } 1952 1953 // DeleteDBSnapshotRequest mocks base method 1954 func (m *MockRDSAPI) DeleteDBSnapshotRequest(arg0 *rds.DeleteDBSnapshotInput) (*request.Request, *rds.DeleteDBSnapshotOutput) { 1955 m.ctrl.T.Helper() 1956 ret := m.ctrl.Call(m, "DeleteDBSnapshotRequest", arg0) 1957 ret0, _ := ret[0].(*request.Request) 1958 ret1, _ := ret[1].(*rds.DeleteDBSnapshotOutput) 1959 return ret0, ret1 1960 } 1961 1962 // DeleteDBSnapshotRequest indicates an expected call of DeleteDBSnapshotRequest 1963 func (mr *MockRDSAPIMockRecorder) DeleteDBSnapshotRequest(arg0 interface{}) *gomock.Call { 1964 mr.mock.ctrl.T.Helper() 1965 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDBSnapshotRequest", reflect.TypeOf((*MockRDSAPI)(nil).DeleteDBSnapshotRequest), arg0) 1966 } 1967 1968 // DeleteDBSnapshotWithContext mocks base method 1969 func (m *MockRDSAPI) DeleteDBSnapshotWithContext(arg0 context.Context, arg1 *rds.DeleteDBSnapshotInput, arg2 ...request.Option) (*rds.DeleteDBSnapshotOutput, error) { 1970 m.ctrl.T.Helper() 1971 varargs := []interface{}{arg0, arg1} 1972 for _, a := range arg2 { 1973 varargs = append(varargs, a) 1974 } 1975 ret := m.ctrl.Call(m, "DeleteDBSnapshotWithContext", varargs...) 1976 ret0, _ := ret[0].(*rds.DeleteDBSnapshotOutput) 1977 ret1, _ := ret[1].(error) 1978 return ret0, ret1 1979 } 1980 1981 // DeleteDBSnapshotWithContext indicates an expected call of DeleteDBSnapshotWithContext 1982 func (mr *MockRDSAPIMockRecorder) DeleteDBSnapshotWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 1983 mr.mock.ctrl.T.Helper() 1984 varargs := append([]interface{}{arg0, arg1}, arg2...) 1985 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDBSnapshotWithContext", reflect.TypeOf((*MockRDSAPI)(nil).DeleteDBSnapshotWithContext), varargs...) 1986 } 1987 1988 // DeleteDBSubnetGroup mocks base method 1989 func (m *MockRDSAPI) DeleteDBSubnetGroup(arg0 *rds.DeleteDBSubnetGroupInput) (*rds.DeleteDBSubnetGroupOutput, error) { 1990 m.ctrl.T.Helper() 1991 ret := m.ctrl.Call(m, "DeleteDBSubnetGroup", arg0) 1992 ret0, _ := ret[0].(*rds.DeleteDBSubnetGroupOutput) 1993 ret1, _ := ret[1].(error) 1994 return ret0, ret1 1995 } 1996 1997 // DeleteDBSubnetGroup indicates an expected call of DeleteDBSubnetGroup 1998 func (mr *MockRDSAPIMockRecorder) DeleteDBSubnetGroup(arg0 interface{}) *gomock.Call { 1999 mr.mock.ctrl.T.Helper() 2000 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDBSubnetGroup", reflect.TypeOf((*MockRDSAPI)(nil).DeleteDBSubnetGroup), arg0) 2001 } 2002 2003 // DeleteDBSubnetGroupRequest mocks base method 2004 func (m *MockRDSAPI) DeleteDBSubnetGroupRequest(arg0 *rds.DeleteDBSubnetGroupInput) (*request.Request, *rds.DeleteDBSubnetGroupOutput) { 2005 m.ctrl.T.Helper() 2006 ret := m.ctrl.Call(m, "DeleteDBSubnetGroupRequest", arg0) 2007 ret0, _ := ret[0].(*request.Request) 2008 ret1, _ := ret[1].(*rds.DeleteDBSubnetGroupOutput) 2009 return ret0, ret1 2010 } 2011 2012 // DeleteDBSubnetGroupRequest indicates an expected call of DeleteDBSubnetGroupRequest 2013 func (mr *MockRDSAPIMockRecorder) DeleteDBSubnetGroupRequest(arg0 interface{}) *gomock.Call { 2014 mr.mock.ctrl.T.Helper() 2015 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDBSubnetGroupRequest", reflect.TypeOf((*MockRDSAPI)(nil).DeleteDBSubnetGroupRequest), arg0) 2016 } 2017 2018 // DeleteDBSubnetGroupWithContext mocks base method 2019 func (m *MockRDSAPI) DeleteDBSubnetGroupWithContext(arg0 context.Context, arg1 *rds.DeleteDBSubnetGroupInput, arg2 ...request.Option) (*rds.DeleteDBSubnetGroupOutput, error) { 2020 m.ctrl.T.Helper() 2021 varargs := []interface{}{arg0, arg1} 2022 for _, a := range arg2 { 2023 varargs = append(varargs, a) 2024 } 2025 ret := m.ctrl.Call(m, "DeleteDBSubnetGroupWithContext", varargs...) 2026 ret0, _ := ret[0].(*rds.DeleteDBSubnetGroupOutput) 2027 ret1, _ := ret[1].(error) 2028 return ret0, ret1 2029 } 2030 2031 // DeleteDBSubnetGroupWithContext indicates an expected call of DeleteDBSubnetGroupWithContext 2032 func (mr *MockRDSAPIMockRecorder) DeleteDBSubnetGroupWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 2033 mr.mock.ctrl.T.Helper() 2034 varargs := append([]interface{}{arg0, arg1}, arg2...) 2035 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDBSubnetGroupWithContext", reflect.TypeOf((*MockRDSAPI)(nil).DeleteDBSubnetGroupWithContext), varargs...) 2036 } 2037 2038 // DeleteEventSubscription mocks base method 2039 func (m *MockRDSAPI) DeleteEventSubscription(arg0 *rds.DeleteEventSubscriptionInput) (*rds.DeleteEventSubscriptionOutput, error) { 2040 m.ctrl.T.Helper() 2041 ret := m.ctrl.Call(m, "DeleteEventSubscription", arg0) 2042 ret0, _ := ret[0].(*rds.DeleteEventSubscriptionOutput) 2043 ret1, _ := ret[1].(error) 2044 return ret0, ret1 2045 } 2046 2047 // DeleteEventSubscription indicates an expected call of DeleteEventSubscription 2048 func (mr *MockRDSAPIMockRecorder) DeleteEventSubscription(arg0 interface{}) *gomock.Call { 2049 mr.mock.ctrl.T.Helper() 2050 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteEventSubscription", reflect.TypeOf((*MockRDSAPI)(nil).DeleteEventSubscription), arg0) 2051 } 2052 2053 // DeleteEventSubscriptionRequest mocks base method 2054 func (m *MockRDSAPI) DeleteEventSubscriptionRequest(arg0 *rds.DeleteEventSubscriptionInput) (*request.Request, *rds.DeleteEventSubscriptionOutput) { 2055 m.ctrl.T.Helper() 2056 ret := m.ctrl.Call(m, "DeleteEventSubscriptionRequest", arg0) 2057 ret0, _ := ret[0].(*request.Request) 2058 ret1, _ := ret[1].(*rds.DeleteEventSubscriptionOutput) 2059 return ret0, ret1 2060 } 2061 2062 // DeleteEventSubscriptionRequest indicates an expected call of DeleteEventSubscriptionRequest 2063 func (mr *MockRDSAPIMockRecorder) DeleteEventSubscriptionRequest(arg0 interface{}) *gomock.Call { 2064 mr.mock.ctrl.T.Helper() 2065 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteEventSubscriptionRequest", reflect.TypeOf((*MockRDSAPI)(nil).DeleteEventSubscriptionRequest), arg0) 2066 } 2067 2068 // DeleteEventSubscriptionWithContext mocks base method 2069 func (m *MockRDSAPI) DeleteEventSubscriptionWithContext(arg0 context.Context, arg1 *rds.DeleteEventSubscriptionInput, arg2 ...request.Option) (*rds.DeleteEventSubscriptionOutput, error) { 2070 m.ctrl.T.Helper() 2071 varargs := []interface{}{arg0, arg1} 2072 for _, a := range arg2 { 2073 varargs = append(varargs, a) 2074 } 2075 ret := m.ctrl.Call(m, "DeleteEventSubscriptionWithContext", varargs...) 2076 ret0, _ := ret[0].(*rds.DeleteEventSubscriptionOutput) 2077 ret1, _ := ret[1].(error) 2078 return ret0, ret1 2079 } 2080 2081 // DeleteEventSubscriptionWithContext indicates an expected call of DeleteEventSubscriptionWithContext 2082 func (mr *MockRDSAPIMockRecorder) DeleteEventSubscriptionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 2083 mr.mock.ctrl.T.Helper() 2084 varargs := append([]interface{}{arg0, arg1}, arg2...) 2085 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteEventSubscriptionWithContext", reflect.TypeOf((*MockRDSAPI)(nil).DeleteEventSubscriptionWithContext), varargs...) 2086 } 2087 2088 // DeleteGlobalCluster mocks base method 2089 func (m *MockRDSAPI) DeleteGlobalCluster(arg0 *rds.DeleteGlobalClusterInput) (*rds.DeleteGlobalClusterOutput, error) { 2090 m.ctrl.T.Helper() 2091 ret := m.ctrl.Call(m, "DeleteGlobalCluster", arg0) 2092 ret0, _ := ret[0].(*rds.DeleteGlobalClusterOutput) 2093 ret1, _ := ret[1].(error) 2094 return ret0, ret1 2095 } 2096 2097 // DeleteGlobalCluster indicates an expected call of DeleteGlobalCluster 2098 func (mr *MockRDSAPIMockRecorder) DeleteGlobalCluster(arg0 interface{}) *gomock.Call { 2099 mr.mock.ctrl.T.Helper() 2100 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteGlobalCluster", reflect.TypeOf((*MockRDSAPI)(nil).DeleteGlobalCluster), arg0) 2101 } 2102 2103 // DeleteGlobalClusterRequest mocks base method 2104 func (m *MockRDSAPI) DeleteGlobalClusterRequest(arg0 *rds.DeleteGlobalClusterInput) (*request.Request, *rds.DeleteGlobalClusterOutput) { 2105 m.ctrl.T.Helper() 2106 ret := m.ctrl.Call(m, "DeleteGlobalClusterRequest", arg0) 2107 ret0, _ := ret[0].(*request.Request) 2108 ret1, _ := ret[1].(*rds.DeleteGlobalClusterOutput) 2109 return ret0, ret1 2110 } 2111 2112 // DeleteGlobalClusterRequest indicates an expected call of DeleteGlobalClusterRequest 2113 func (mr *MockRDSAPIMockRecorder) DeleteGlobalClusterRequest(arg0 interface{}) *gomock.Call { 2114 mr.mock.ctrl.T.Helper() 2115 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteGlobalClusterRequest", reflect.TypeOf((*MockRDSAPI)(nil).DeleteGlobalClusterRequest), arg0) 2116 } 2117 2118 // DeleteGlobalClusterWithContext mocks base method 2119 func (m *MockRDSAPI) DeleteGlobalClusterWithContext(arg0 context.Context, arg1 *rds.DeleteGlobalClusterInput, arg2 ...request.Option) (*rds.DeleteGlobalClusterOutput, error) { 2120 m.ctrl.T.Helper() 2121 varargs := []interface{}{arg0, arg1} 2122 for _, a := range arg2 { 2123 varargs = append(varargs, a) 2124 } 2125 ret := m.ctrl.Call(m, "DeleteGlobalClusterWithContext", varargs...) 2126 ret0, _ := ret[0].(*rds.DeleteGlobalClusterOutput) 2127 ret1, _ := ret[1].(error) 2128 return ret0, ret1 2129 } 2130 2131 // DeleteGlobalClusterWithContext indicates an expected call of DeleteGlobalClusterWithContext 2132 func (mr *MockRDSAPIMockRecorder) DeleteGlobalClusterWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 2133 mr.mock.ctrl.T.Helper() 2134 varargs := append([]interface{}{arg0, arg1}, arg2...) 2135 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteGlobalClusterWithContext", reflect.TypeOf((*MockRDSAPI)(nil).DeleteGlobalClusterWithContext), varargs...) 2136 } 2137 2138 // DeleteInstallationMedia mocks base method 2139 func (m *MockRDSAPI) DeleteInstallationMedia(arg0 *rds.DeleteInstallationMediaInput) (*rds.DeleteInstallationMediaOutput, error) { 2140 m.ctrl.T.Helper() 2141 ret := m.ctrl.Call(m, "DeleteInstallationMedia", arg0) 2142 ret0, _ := ret[0].(*rds.DeleteInstallationMediaOutput) 2143 ret1, _ := ret[1].(error) 2144 return ret0, ret1 2145 } 2146 2147 // DeleteInstallationMedia indicates an expected call of DeleteInstallationMedia 2148 func (mr *MockRDSAPIMockRecorder) DeleteInstallationMedia(arg0 interface{}) *gomock.Call { 2149 mr.mock.ctrl.T.Helper() 2150 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteInstallationMedia", reflect.TypeOf((*MockRDSAPI)(nil).DeleteInstallationMedia), arg0) 2151 } 2152 2153 // DeleteInstallationMediaRequest mocks base method 2154 func (m *MockRDSAPI) DeleteInstallationMediaRequest(arg0 *rds.DeleteInstallationMediaInput) (*request.Request, *rds.DeleteInstallationMediaOutput) { 2155 m.ctrl.T.Helper() 2156 ret := m.ctrl.Call(m, "DeleteInstallationMediaRequest", arg0) 2157 ret0, _ := ret[0].(*request.Request) 2158 ret1, _ := ret[1].(*rds.DeleteInstallationMediaOutput) 2159 return ret0, ret1 2160 } 2161 2162 // DeleteInstallationMediaRequest indicates an expected call of DeleteInstallationMediaRequest 2163 func (mr *MockRDSAPIMockRecorder) DeleteInstallationMediaRequest(arg0 interface{}) *gomock.Call { 2164 mr.mock.ctrl.T.Helper() 2165 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteInstallationMediaRequest", reflect.TypeOf((*MockRDSAPI)(nil).DeleteInstallationMediaRequest), arg0) 2166 } 2167 2168 // DeleteInstallationMediaWithContext mocks base method 2169 func (m *MockRDSAPI) DeleteInstallationMediaWithContext(arg0 context.Context, arg1 *rds.DeleteInstallationMediaInput, arg2 ...request.Option) (*rds.DeleteInstallationMediaOutput, error) { 2170 m.ctrl.T.Helper() 2171 varargs := []interface{}{arg0, arg1} 2172 for _, a := range arg2 { 2173 varargs = append(varargs, a) 2174 } 2175 ret := m.ctrl.Call(m, "DeleteInstallationMediaWithContext", varargs...) 2176 ret0, _ := ret[0].(*rds.DeleteInstallationMediaOutput) 2177 ret1, _ := ret[1].(error) 2178 return ret0, ret1 2179 } 2180 2181 // DeleteInstallationMediaWithContext indicates an expected call of DeleteInstallationMediaWithContext 2182 func (mr *MockRDSAPIMockRecorder) DeleteInstallationMediaWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 2183 mr.mock.ctrl.T.Helper() 2184 varargs := append([]interface{}{arg0, arg1}, arg2...) 2185 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteInstallationMediaWithContext", reflect.TypeOf((*MockRDSAPI)(nil).DeleteInstallationMediaWithContext), varargs...) 2186 } 2187 2188 // DeleteOptionGroup mocks base method 2189 func (m *MockRDSAPI) DeleteOptionGroup(arg0 *rds.DeleteOptionGroupInput) (*rds.DeleteOptionGroupOutput, error) { 2190 m.ctrl.T.Helper() 2191 ret := m.ctrl.Call(m, "DeleteOptionGroup", arg0) 2192 ret0, _ := ret[0].(*rds.DeleteOptionGroupOutput) 2193 ret1, _ := ret[1].(error) 2194 return ret0, ret1 2195 } 2196 2197 // DeleteOptionGroup indicates an expected call of DeleteOptionGroup 2198 func (mr *MockRDSAPIMockRecorder) DeleteOptionGroup(arg0 interface{}) *gomock.Call { 2199 mr.mock.ctrl.T.Helper() 2200 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteOptionGroup", reflect.TypeOf((*MockRDSAPI)(nil).DeleteOptionGroup), arg0) 2201 } 2202 2203 // DeleteOptionGroupRequest mocks base method 2204 func (m *MockRDSAPI) DeleteOptionGroupRequest(arg0 *rds.DeleteOptionGroupInput) (*request.Request, *rds.DeleteOptionGroupOutput) { 2205 m.ctrl.T.Helper() 2206 ret := m.ctrl.Call(m, "DeleteOptionGroupRequest", arg0) 2207 ret0, _ := ret[0].(*request.Request) 2208 ret1, _ := ret[1].(*rds.DeleteOptionGroupOutput) 2209 return ret0, ret1 2210 } 2211 2212 // DeleteOptionGroupRequest indicates an expected call of DeleteOptionGroupRequest 2213 func (mr *MockRDSAPIMockRecorder) DeleteOptionGroupRequest(arg0 interface{}) *gomock.Call { 2214 mr.mock.ctrl.T.Helper() 2215 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteOptionGroupRequest", reflect.TypeOf((*MockRDSAPI)(nil).DeleteOptionGroupRequest), arg0) 2216 } 2217 2218 // DeleteOptionGroupWithContext mocks base method 2219 func (m *MockRDSAPI) DeleteOptionGroupWithContext(arg0 context.Context, arg1 *rds.DeleteOptionGroupInput, arg2 ...request.Option) (*rds.DeleteOptionGroupOutput, error) { 2220 m.ctrl.T.Helper() 2221 varargs := []interface{}{arg0, arg1} 2222 for _, a := range arg2 { 2223 varargs = append(varargs, a) 2224 } 2225 ret := m.ctrl.Call(m, "DeleteOptionGroupWithContext", varargs...) 2226 ret0, _ := ret[0].(*rds.DeleteOptionGroupOutput) 2227 ret1, _ := ret[1].(error) 2228 return ret0, ret1 2229 } 2230 2231 // DeleteOptionGroupWithContext indicates an expected call of DeleteOptionGroupWithContext 2232 func (mr *MockRDSAPIMockRecorder) DeleteOptionGroupWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 2233 mr.mock.ctrl.T.Helper() 2234 varargs := append([]interface{}{arg0, arg1}, arg2...) 2235 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteOptionGroupWithContext", reflect.TypeOf((*MockRDSAPI)(nil).DeleteOptionGroupWithContext), varargs...) 2236 } 2237 2238 // DeregisterDBProxyTargets mocks base method 2239 func (m *MockRDSAPI) DeregisterDBProxyTargets(arg0 *rds.DeregisterDBProxyTargetsInput) (*rds.DeregisterDBProxyTargetsOutput, error) { 2240 m.ctrl.T.Helper() 2241 ret := m.ctrl.Call(m, "DeregisterDBProxyTargets", arg0) 2242 ret0, _ := ret[0].(*rds.DeregisterDBProxyTargetsOutput) 2243 ret1, _ := ret[1].(error) 2244 return ret0, ret1 2245 } 2246 2247 // DeregisterDBProxyTargets indicates an expected call of DeregisterDBProxyTargets 2248 func (mr *MockRDSAPIMockRecorder) DeregisterDBProxyTargets(arg0 interface{}) *gomock.Call { 2249 mr.mock.ctrl.T.Helper() 2250 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeregisterDBProxyTargets", reflect.TypeOf((*MockRDSAPI)(nil).DeregisterDBProxyTargets), arg0) 2251 } 2252 2253 // DeregisterDBProxyTargetsRequest mocks base method 2254 func (m *MockRDSAPI) DeregisterDBProxyTargetsRequest(arg0 *rds.DeregisterDBProxyTargetsInput) (*request.Request, *rds.DeregisterDBProxyTargetsOutput) { 2255 m.ctrl.T.Helper() 2256 ret := m.ctrl.Call(m, "DeregisterDBProxyTargetsRequest", arg0) 2257 ret0, _ := ret[0].(*request.Request) 2258 ret1, _ := ret[1].(*rds.DeregisterDBProxyTargetsOutput) 2259 return ret0, ret1 2260 } 2261 2262 // DeregisterDBProxyTargetsRequest indicates an expected call of DeregisterDBProxyTargetsRequest 2263 func (mr *MockRDSAPIMockRecorder) DeregisterDBProxyTargetsRequest(arg0 interface{}) *gomock.Call { 2264 mr.mock.ctrl.T.Helper() 2265 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeregisterDBProxyTargetsRequest", reflect.TypeOf((*MockRDSAPI)(nil).DeregisterDBProxyTargetsRequest), arg0) 2266 } 2267 2268 // DeregisterDBProxyTargetsWithContext mocks base method 2269 func (m *MockRDSAPI) DeregisterDBProxyTargetsWithContext(arg0 context.Context, arg1 *rds.DeregisterDBProxyTargetsInput, arg2 ...request.Option) (*rds.DeregisterDBProxyTargetsOutput, error) { 2270 m.ctrl.T.Helper() 2271 varargs := []interface{}{arg0, arg1} 2272 for _, a := range arg2 { 2273 varargs = append(varargs, a) 2274 } 2275 ret := m.ctrl.Call(m, "DeregisterDBProxyTargetsWithContext", varargs...) 2276 ret0, _ := ret[0].(*rds.DeregisterDBProxyTargetsOutput) 2277 ret1, _ := ret[1].(error) 2278 return ret0, ret1 2279 } 2280 2281 // DeregisterDBProxyTargetsWithContext indicates an expected call of DeregisterDBProxyTargetsWithContext 2282 func (mr *MockRDSAPIMockRecorder) DeregisterDBProxyTargetsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 2283 mr.mock.ctrl.T.Helper() 2284 varargs := append([]interface{}{arg0, arg1}, arg2...) 2285 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeregisterDBProxyTargetsWithContext", reflect.TypeOf((*MockRDSAPI)(nil).DeregisterDBProxyTargetsWithContext), varargs...) 2286 } 2287 2288 // DescribeAccountAttributes mocks base method 2289 func (m *MockRDSAPI) DescribeAccountAttributes(arg0 *rds.DescribeAccountAttributesInput) (*rds.DescribeAccountAttributesOutput, error) { 2290 m.ctrl.T.Helper() 2291 ret := m.ctrl.Call(m, "DescribeAccountAttributes", arg0) 2292 ret0, _ := ret[0].(*rds.DescribeAccountAttributesOutput) 2293 ret1, _ := ret[1].(error) 2294 return ret0, ret1 2295 } 2296 2297 // DescribeAccountAttributes indicates an expected call of DescribeAccountAttributes 2298 func (mr *MockRDSAPIMockRecorder) DescribeAccountAttributes(arg0 interface{}) *gomock.Call { 2299 mr.mock.ctrl.T.Helper() 2300 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAccountAttributes", reflect.TypeOf((*MockRDSAPI)(nil).DescribeAccountAttributes), arg0) 2301 } 2302 2303 // DescribeAccountAttributesRequest mocks base method 2304 func (m *MockRDSAPI) DescribeAccountAttributesRequest(arg0 *rds.DescribeAccountAttributesInput) (*request.Request, *rds.DescribeAccountAttributesOutput) { 2305 m.ctrl.T.Helper() 2306 ret := m.ctrl.Call(m, "DescribeAccountAttributesRequest", arg0) 2307 ret0, _ := ret[0].(*request.Request) 2308 ret1, _ := ret[1].(*rds.DescribeAccountAttributesOutput) 2309 return ret0, ret1 2310 } 2311 2312 // DescribeAccountAttributesRequest indicates an expected call of DescribeAccountAttributesRequest 2313 func (mr *MockRDSAPIMockRecorder) DescribeAccountAttributesRequest(arg0 interface{}) *gomock.Call { 2314 mr.mock.ctrl.T.Helper() 2315 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAccountAttributesRequest", reflect.TypeOf((*MockRDSAPI)(nil).DescribeAccountAttributesRequest), arg0) 2316 } 2317 2318 // DescribeAccountAttributesWithContext mocks base method 2319 func (m *MockRDSAPI) DescribeAccountAttributesWithContext(arg0 context.Context, arg1 *rds.DescribeAccountAttributesInput, arg2 ...request.Option) (*rds.DescribeAccountAttributesOutput, error) { 2320 m.ctrl.T.Helper() 2321 varargs := []interface{}{arg0, arg1} 2322 for _, a := range arg2 { 2323 varargs = append(varargs, a) 2324 } 2325 ret := m.ctrl.Call(m, "DescribeAccountAttributesWithContext", varargs...) 2326 ret0, _ := ret[0].(*rds.DescribeAccountAttributesOutput) 2327 ret1, _ := ret[1].(error) 2328 return ret0, ret1 2329 } 2330 2331 // DescribeAccountAttributesWithContext indicates an expected call of DescribeAccountAttributesWithContext 2332 func (mr *MockRDSAPIMockRecorder) DescribeAccountAttributesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 2333 mr.mock.ctrl.T.Helper() 2334 varargs := append([]interface{}{arg0, arg1}, arg2...) 2335 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAccountAttributesWithContext", reflect.TypeOf((*MockRDSAPI)(nil).DescribeAccountAttributesWithContext), varargs...) 2336 } 2337 2338 // DescribeCertificates mocks base method 2339 func (m *MockRDSAPI) DescribeCertificates(arg0 *rds.DescribeCertificatesInput) (*rds.DescribeCertificatesOutput, error) { 2340 m.ctrl.T.Helper() 2341 ret := m.ctrl.Call(m, "DescribeCertificates", arg0) 2342 ret0, _ := ret[0].(*rds.DescribeCertificatesOutput) 2343 ret1, _ := ret[1].(error) 2344 return ret0, ret1 2345 } 2346 2347 // DescribeCertificates indicates an expected call of DescribeCertificates 2348 func (mr *MockRDSAPIMockRecorder) DescribeCertificates(arg0 interface{}) *gomock.Call { 2349 mr.mock.ctrl.T.Helper() 2350 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCertificates", reflect.TypeOf((*MockRDSAPI)(nil).DescribeCertificates), arg0) 2351 } 2352 2353 // DescribeCertificatesPages mocks base method 2354 func (m *MockRDSAPI) DescribeCertificatesPages(arg0 *rds.DescribeCertificatesInput, arg1 func(*rds.DescribeCertificatesOutput, bool) bool) error { 2355 m.ctrl.T.Helper() 2356 ret := m.ctrl.Call(m, "DescribeCertificatesPages", arg0, arg1) 2357 ret0, _ := ret[0].(error) 2358 return ret0 2359 } 2360 2361 // DescribeCertificatesPages indicates an expected call of DescribeCertificatesPages 2362 func (mr *MockRDSAPIMockRecorder) DescribeCertificatesPages(arg0, arg1 interface{}) *gomock.Call { 2363 mr.mock.ctrl.T.Helper() 2364 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCertificatesPages", reflect.TypeOf((*MockRDSAPI)(nil).DescribeCertificatesPages), arg0, arg1) 2365 } 2366 2367 // DescribeCertificatesPagesWithContext mocks base method 2368 func (m *MockRDSAPI) DescribeCertificatesPagesWithContext(arg0 context.Context, arg1 *rds.DescribeCertificatesInput, arg2 func(*rds.DescribeCertificatesOutput, bool) bool, arg3 ...request.Option) error { 2369 m.ctrl.T.Helper() 2370 varargs := []interface{}{arg0, arg1, arg2} 2371 for _, a := range arg3 { 2372 varargs = append(varargs, a) 2373 } 2374 ret := m.ctrl.Call(m, "DescribeCertificatesPagesWithContext", varargs...) 2375 ret0, _ := ret[0].(error) 2376 return ret0 2377 } 2378 2379 // DescribeCertificatesPagesWithContext indicates an expected call of DescribeCertificatesPagesWithContext 2380 func (mr *MockRDSAPIMockRecorder) DescribeCertificatesPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 2381 mr.mock.ctrl.T.Helper() 2382 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 2383 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCertificatesPagesWithContext", reflect.TypeOf((*MockRDSAPI)(nil).DescribeCertificatesPagesWithContext), varargs...) 2384 } 2385 2386 // DescribeCertificatesRequest mocks base method 2387 func (m *MockRDSAPI) DescribeCertificatesRequest(arg0 *rds.DescribeCertificatesInput) (*request.Request, *rds.DescribeCertificatesOutput) { 2388 m.ctrl.T.Helper() 2389 ret := m.ctrl.Call(m, "DescribeCertificatesRequest", arg0) 2390 ret0, _ := ret[0].(*request.Request) 2391 ret1, _ := ret[1].(*rds.DescribeCertificatesOutput) 2392 return ret0, ret1 2393 } 2394 2395 // DescribeCertificatesRequest indicates an expected call of DescribeCertificatesRequest 2396 func (mr *MockRDSAPIMockRecorder) DescribeCertificatesRequest(arg0 interface{}) *gomock.Call { 2397 mr.mock.ctrl.T.Helper() 2398 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCertificatesRequest", reflect.TypeOf((*MockRDSAPI)(nil).DescribeCertificatesRequest), arg0) 2399 } 2400 2401 // DescribeCertificatesWithContext mocks base method 2402 func (m *MockRDSAPI) DescribeCertificatesWithContext(arg0 context.Context, arg1 *rds.DescribeCertificatesInput, arg2 ...request.Option) (*rds.DescribeCertificatesOutput, error) { 2403 m.ctrl.T.Helper() 2404 varargs := []interface{}{arg0, arg1} 2405 for _, a := range arg2 { 2406 varargs = append(varargs, a) 2407 } 2408 ret := m.ctrl.Call(m, "DescribeCertificatesWithContext", varargs...) 2409 ret0, _ := ret[0].(*rds.DescribeCertificatesOutput) 2410 ret1, _ := ret[1].(error) 2411 return ret0, ret1 2412 } 2413 2414 // DescribeCertificatesWithContext indicates an expected call of DescribeCertificatesWithContext 2415 func (mr *MockRDSAPIMockRecorder) DescribeCertificatesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 2416 mr.mock.ctrl.T.Helper() 2417 varargs := append([]interface{}{arg0, arg1}, arg2...) 2418 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCertificatesWithContext", reflect.TypeOf((*MockRDSAPI)(nil).DescribeCertificatesWithContext), varargs...) 2419 } 2420 2421 // DescribeCustomAvailabilityZones mocks base method 2422 func (m *MockRDSAPI) DescribeCustomAvailabilityZones(arg0 *rds.DescribeCustomAvailabilityZonesInput) (*rds.DescribeCustomAvailabilityZonesOutput, error) { 2423 m.ctrl.T.Helper() 2424 ret := m.ctrl.Call(m, "DescribeCustomAvailabilityZones", arg0) 2425 ret0, _ := ret[0].(*rds.DescribeCustomAvailabilityZonesOutput) 2426 ret1, _ := ret[1].(error) 2427 return ret0, ret1 2428 } 2429 2430 // DescribeCustomAvailabilityZones indicates an expected call of DescribeCustomAvailabilityZones 2431 func (mr *MockRDSAPIMockRecorder) DescribeCustomAvailabilityZones(arg0 interface{}) *gomock.Call { 2432 mr.mock.ctrl.T.Helper() 2433 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCustomAvailabilityZones", reflect.TypeOf((*MockRDSAPI)(nil).DescribeCustomAvailabilityZones), arg0) 2434 } 2435 2436 // DescribeCustomAvailabilityZonesPages mocks base method 2437 func (m *MockRDSAPI) DescribeCustomAvailabilityZonesPages(arg0 *rds.DescribeCustomAvailabilityZonesInput, arg1 func(*rds.DescribeCustomAvailabilityZonesOutput, bool) bool) error { 2438 m.ctrl.T.Helper() 2439 ret := m.ctrl.Call(m, "DescribeCustomAvailabilityZonesPages", arg0, arg1) 2440 ret0, _ := ret[0].(error) 2441 return ret0 2442 } 2443 2444 // DescribeCustomAvailabilityZonesPages indicates an expected call of DescribeCustomAvailabilityZonesPages 2445 func (mr *MockRDSAPIMockRecorder) DescribeCustomAvailabilityZonesPages(arg0, arg1 interface{}) *gomock.Call { 2446 mr.mock.ctrl.T.Helper() 2447 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCustomAvailabilityZonesPages", reflect.TypeOf((*MockRDSAPI)(nil).DescribeCustomAvailabilityZonesPages), arg0, arg1) 2448 } 2449 2450 // DescribeCustomAvailabilityZonesPagesWithContext mocks base method 2451 func (m *MockRDSAPI) DescribeCustomAvailabilityZonesPagesWithContext(arg0 context.Context, arg1 *rds.DescribeCustomAvailabilityZonesInput, arg2 func(*rds.DescribeCustomAvailabilityZonesOutput, bool) bool, arg3 ...request.Option) error { 2452 m.ctrl.T.Helper() 2453 varargs := []interface{}{arg0, arg1, arg2} 2454 for _, a := range arg3 { 2455 varargs = append(varargs, a) 2456 } 2457 ret := m.ctrl.Call(m, "DescribeCustomAvailabilityZonesPagesWithContext", varargs...) 2458 ret0, _ := ret[0].(error) 2459 return ret0 2460 } 2461 2462 // DescribeCustomAvailabilityZonesPagesWithContext indicates an expected call of DescribeCustomAvailabilityZonesPagesWithContext 2463 func (mr *MockRDSAPIMockRecorder) DescribeCustomAvailabilityZonesPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 2464 mr.mock.ctrl.T.Helper() 2465 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 2466 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCustomAvailabilityZonesPagesWithContext", reflect.TypeOf((*MockRDSAPI)(nil).DescribeCustomAvailabilityZonesPagesWithContext), varargs...) 2467 } 2468 2469 // DescribeCustomAvailabilityZonesRequest mocks base method 2470 func (m *MockRDSAPI) DescribeCustomAvailabilityZonesRequest(arg0 *rds.DescribeCustomAvailabilityZonesInput) (*request.Request, *rds.DescribeCustomAvailabilityZonesOutput) { 2471 m.ctrl.T.Helper() 2472 ret := m.ctrl.Call(m, "DescribeCustomAvailabilityZonesRequest", arg0) 2473 ret0, _ := ret[0].(*request.Request) 2474 ret1, _ := ret[1].(*rds.DescribeCustomAvailabilityZonesOutput) 2475 return ret0, ret1 2476 } 2477 2478 // DescribeCustomAvailabilityZonesRequest indicates an expected call of DescribeCustomAvailabilityZonesRequest 2479 func (mr *MockRDSAPIMockRecorder) DescribeCustomAvailabilityZonesRequest(arg0 interface{}) *gomock.Call { 2480 mr.mock.ctrl.T.Helper() 2481 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCustomAvailabilityZonesRequest", reflect.TypeOf((*MockRDSAPI)(nil).DescribeCustomAvailabilityZonesRequest), arg0) 2482 } 2483 2484 // DescribeCustomAvailabilityZonesWithContext mocks base method 2485 func (m *MockRDSAPI) DescribeCustomAvailabilityZonesWithContext(arg0 context.Context, arg1 *rds.DescribeCustomAvailabilityZonesInput, arg2 ...request.Option) (*rds.DescribeCustomAvailabilityZonesOutput, error) { 2486 m.ctrl.T.Helper() 2487 varargs := []interface{}{arg0, arg1} 2488 for _, a := range arg2 { 2489 varargs = append(varargs, a) 2490 } 2491 ret := m.ctrl.Call(m, "DescribeCustomAvailabilityZonesWithContext", varargs...) 2492 ret0, _ := ret[0].(*rds.DescribeCustomAvailabilityZonesOutput) 2493 ret1, _ := ret[1].(error) 2494 return ret0, ret1 2495 } 2496 2497 // DescribeCustomAvailabilityZonesWithContext indicates an expected call of DescribeCustomAvailabilityZonesWithContext 2498 func (mr *MockRDSAPIMockRecorder) DescribeCustomAvailabilityZonesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 2499 mr.mock.ctrl.T.Helper() 2500 varargs := append([]interface{}{arg0, arg1}, arg2...) 2501 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCustomAvailabilityZonesWithContext", reflect.TypeOf((*MockRDSAPI)(nil).DescribeCustomAvailabilityZonesWithContext), varargs...) 2502 } 2503 2504 // DescribeDBClusterBacktracks mocks base method 2505 func (m *MockRDSAPI) DescribeDBClusterBacktracks(arg0 *rds.DescribeDBClusterBacktracksInput) (*rds.DescribeDBClusterBacktracksOutput, error) { 2506 m.ctrl.T.Helper() 2507 ret := m.ctrl.Call(m, "DescribeDBClusterBacktracks", arg0) 2508 ret0, _ := ret[0].(*rds.DescribeDBClusterBacktracksOutput) 2509 ret1, _ := ret[1].(error) 2510 return ret0, ret1 2511 } 2512 2513 // DescribeDBClusterBacktracks indicates an expected call of DescribeDBClusterBacktracks 2514 func (mr *MockRDSAPIMockRecorder) DescribeDBClusterBacktracks(arg0 interface{}) *gomock.Call { 2515 mr.mock.ctrl.T.Helper() 2516 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDBClusterBacktracks", reflect.TypeOf((*MockRDSAPI)(nil).DescribeDBClusterBacktracks), arg0) 2517 } 2518 2519 // DescribeDBClusterBacktracksPages mocks base method 2520 func (m *MockRDSAPI) DescribeDBClusterBacktracksPages(arg0 *rds.DescribeDBClusterBacktracksInput, arg1 func(*rds.DescribeDBClusterBacktracksOutput, bool) bool) error { 2521 m.ctrl.T.Helper() 2522 ret := m.ctrl.Call(m, "DescribeDBClusterBacktracksPages", arg0, arg1) 2523 ret0, _ := ret[0].(error) 2524 return ret0 2525 } 2526 2527 // DescribeDBClusterBacktracksPages indicates an expected call of DescribeDBClusterBacktracksPages 2528 func (mr *MockRDSAPIMockRecorder) DescribeDBClusterBacktracksPages(arg0, arg1 interface{}) *gomock.Call { 2529 mr.mock.ctrl.T.Helper() 2530 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDBClusterBacktracksPages", reflect.TypeOf((*MockRDSAPI)(nil).DescribeDBClusterBacktracksPages), arg0, arg1) 2531 } 2532 2533 // DescribeDBClusterBacktracksPagesWithContext mocks base method 2534 func (m *MockRDSAPI) DescribeDBClusterBacktracksPagesWithContext(arg0 context.Context, arg1 *rds.DescribeDBClusterBacktracksInput, arg2 func(*rds.DescribeDBClusterBacktracksOutput, bool) bool, arg3 ...request.Option) error { 2535 m.ctrl.T.Helper() 2536 varargs := []interface{}{arg0, arg1, arg2} 2537 for _, a := range arg3 { 2538 varargs = append(varargs, a) 2539 } 2540 ret := m.ctrl.Call(m, "DescribeDBClusterBacktracksPagesWithContext", varargs...) 2541 ret0, _ := ret[0].(error) 2542 return ret0 2543 } 2544 2545 // DescribeDBClusterBacktracksPagesWithContext indicates an expected call of DescribeDBClusterBacktracksPagesWithContext 2546 func (mr *MockRDSAPIMockRecorder) DescribeDBClusterBacktracksPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 2547 mr.mock.ctrl.T.Helper() 2548 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 2549 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDBClusterBacktracksPagesWithContext", reflect.TypeOf((*MockRDSAPI)(nil).DescribeDBClusterBacktracksPagesWithContext), varargs...) 2550 } 2551 2552 // DescribeDBClusterBacktracksRequest mocks base method 2553 func (m *MockRDSAPI) DescribeDBClusterBacktracksRequest(arg0 *rds.DescribeDBClusterBacktracksInput) (*request.Request, *rds.DescribeDBClusterBacktracksOutput) { 2554 m.ctrl.T.Helper() 2555 ret := m.ctrl.Call(m, "DescribeDBClusterBacktracksRequest", arg0) 2556 ret0, _ := ret[0].(*request.Request) 2557 ret1, _ := ret[1].(*rds.DescribeDBClusterBacktracksOutput) 2558 return ret0, ret1 2559 } 2560 2561 // DescribeDBClusterBacktracksRequest indicates an expected call of DescribeDBClusterBacktracksRequest 2562 func (mr *MockRDSAPIMockRecorder) DescribeDBClusterBacktracksRequest(arg0 interface{}) *gomock.Call { 2563 mr.mock.ctrl.T.Helper() 2564 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDBClusterBacktracksRequest", reflect.TypeOf((*MockRDSAPI)(nil).DescribeDBClusterBacktracksRequest), arg0) 2565 } 2566 2567 // DescribeDBClusterBacktracksWithContext mocks base method 2568 func (m *MockRDSAPI) DescribeDBClusterBacktracksWithContext(arg0 context.Context, arg1 *rds.DescribeDBClusterBacktracksInput, arg2 ...request.Option) (*rds.DescribeDBClusterBacktracksOutput, error) { 2569 m.ctrl.T.Helper() 2570 varargs := []interface{}{arg0, arg1} 2571 for _, a := range arg2 { 2572 varargs = append(varargs, a) 2573 } 2574 ret := m.ctrl.Call(m, "DescribeDBClusterBacktracksWithContext", varargs...) 2575 ret0, _ := ret[0].(*rds.DescribeDBClusterBacktracksOutput) 2576 ret1, _ := ret[1].(error) 2577 return ret0, ret1 2578 } 2579 2580 // DescribeDBClusterBacktracksWithContext indicates an expected call of DescribeDBClusterBacktracksWithContext 2581 func (mr *MockRDSAPIMockRecorder) DescribeDBClusterBacktracksWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 2582 mr.mock.ctrl.T.Helper() 2583 varargs := append([]interface{}{arg0, arg1}, arg2...) 2584 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDBClusterBacktracksWithContext", reflect.TypeOf((*MockRDSAPI)(nil).DescribeDBClusterBacktracksWithContext), varargs...) 2585 } 2586 2587 // DescribeDBClusterEndpoints mocks base method 2588 func (m *MockRDSAPI) DescribeDBClusterEndpoints(arg0 *rds.DescribeDBClusterEndpointsInput) (*rds.DescribeDBClusterEndpointsOutput, error) { 2589 m.ctrl.T.Helper() 2590 ret := m.ctrl.Call(m, "DescribeDBClusterEndpoints", arg0) 2591 ret0, _ := ret[0].(*rds.DescribeDBClusterEndpointsOutput) 2592 ret1, _ := ret[1].(error) 2593 return ret0, ret1 2594 } 2595 2596 // DescribeDBClusterEndpoints indicates an expected call of DescribeDBClusterEndpoints 2597 func (mr *MockRDSAPIMockRecorder) DescribeDBClusterEndpoints(arg0 interface{}) *gomock.Call { 2598 mr.mock.ctrl.T.Helper() 2599 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDBClusterEndpoints", reflect.TypeOf((*MockRDSAPI)(nil).DescribeDBClusterEndpoints), arg0) 2600 } 2601 2602 // DescribeDBClusterEndpointsPages mocks base method 2603 func (m *MockRDSAPI) DescribeDBClusterEndpointsPages(arg0 *rds.DescribeDBClusterEndpointsInput, arg1 func(*rds.DescribeDBClusterEndpointsOutput, bool) bool) error { 2604 m.ctrl.T.Helper() 2605 ret := m.ctrl.Call(m, "DescribeDBClusterEndpointsPages", arg0, arg1) 2606 ret0, _ := ret[0].(error) 2607 return ret0 2608 } 2609 2610 // DescribeDBClusterEndpointsPages indicates an expected call of DescribeDBClusterEndpointsPages 2611 func (mr *MockRDSAPIMockRecorder) DescribeDBClusterEndpointsPages(arg0, arg1 interface{}) *gomock.Call { 2612 mr.mock.ctrl.T.Helper() 2613 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDBClusterEndpointsPages", reflect.TypeOf((*MockRDSAPI)(nil).DescribeDBClusterEndpointsPages), arg0, arg1) 2614 } 2615 2616 // DescribeDBClusterEndpointsPagesWithContext mocks base method 2617 func (m *MockRDSAPI) DescribeDBClusterEndpointsPagesWithContext(arg0 context.Context, arg1 *rds.DescribeDBClusterEndpointsInput, arg2 func(*rds.DescribeDBClusterEndpointsOutput, bool) bool, arg3 ...request.Option) error { 2618 m.ctrl.T.Helper() 2619 varargs := []interface{}{arg0, arg1, arg2} 2620 for _, a := range arg3 { 2621 varargs = append(varargs, a) 2622 } 2623 ret := m.ctrl.Call(m, "DescribeDBClusterEndpointsPagesWithContext", varargs...) 2624 ret0, _ := ret[0].(error) 2625 return ret0 2626 } 2627 2628 // DescribeDBClusterEndpointsPagesWithContext indicates an expected call of DescribeDBClusterEndpointsPagesWithContext 2629 func (mr *MockRDSAPIMockRecorder) DescribeDBClusterEndpointsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 2630 mr.mock.ctrl.T.Helper() 2631 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 2632 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDBClusterEndpointsPagesWithContext", reflect.TypeOf((*MockRDSAPI)(nil).DescribeDBClusterEndpointsPagesWithContext), varargs...) 2633 } 2634 2635 // DescribeDBClusterEndpointsRequest mocks base method 2636 func (m *MockRDSAPI) DescribeDBClusterEndpointsRequest(arg0 *rds.DescribeDBClusterEndpointsInput) (*request.Request, *rds.DescribeDBClusterEndpointsOutput) { 2637 m.ctrl.T.Helper() 2638 ret := m.ctrl.Call(m, "DescribeDBClusterEndpointsRequest", arg0) 2639 ret0, _ := ret[0].(*request.Request) 2640 ret1, _ := ret[1].(*rds.DescribeDBClusterEndpointsOutput) 2641 return ret0, ret1 2642 } 2643 2644 // DescribeDBClusterEndpointsRequest indicates an expected call of DescribeDBClusterEndpointsRequest 2645 func (mr *MockRDSAPIMockRecorder) DescribeDBClusterEndpointsRequest(arg0 interface{}) *gomock.Call { 2646 mr.mock.ctrl.T.Helper() 2647 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDBClusterEndpointsRequest", reflect.TypeOf((*MockRDSAPI)(nil).DescribeDBClusterEndpointsRequest), arg0) 2648 } 2649 2650 // DescribeDBClusterEndpointsWithContext mocks base method 2651 func (m *MockRDSAPI) DescribeDBClusterEndpointsWithContext(arg0 context.Context, arg1 *rds.DescribeDBClusterEndpointsInput, arg2 ...request.Option) (*rds.DescribeDBClusterEndpointsOutput, error) { 2652 m.ctrl.T.Helper() 2653 varargs := []interface{}{arg0, arg1} 2654 for _, a := range arg2 { 2655 varargs = append(varargs, a) 2656 } 2657 ret := m.ctrl.Call(m, "DescribeDBClusterEndpointsWithContext", varargs...) 2658 ret0, _ := ret[0].(*rds.DescribeDBClusterEndpointsOutput) 2659 ret1, _ := ret[1].(error) 2660 return ret0, ret1 2661 } 2662 2663 // DescribeDBClusterEndpointsWithContext indicates an expected call of DescribeDBClusterEndpointsWithContext 2664 func (mr *MockRDSAPIMockRecorder) DescribeDBClusterEndpointsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 2665 mr.mock.ctrl.T.Helper() 2666 varargs := append([]interface{}{arg0, arg1}, arg2...) 2667 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDBClusterEndpointsWithContext", reflect.TypeOf((*MockRDSAPI)(nil).DescribeDBClusterEndpointsWithContext), varargs...) 2668 } 2669 2670 // DescribeDBClusterParameterGroups mocks base method 2671 func (m *MockRDSAPI) DescribeDBClusterParameterGroups(arg0 *rds.DescribeDBClusterParameterGroupsInput) (*rds.DescribeDBClusterParameterGroupsOutput, error) { 2672 m.ctrl.T.Helper() 2673 ret := m.ctrl.Call(m, "DescribeDBClusterParameterGroups", arg0) 2674 ret0, _ := ret[0].(*rds.DescribeDBClusterParameterGroupsOutput) 2675 ret1, _ := ret[1].(error) 2676 return ret0, ret1 2677 } 2678 2679 // DescribeDBClusterParameterGroups indicates an expected call of DescribeDBClusterParameterGroups 2680 func (mr *MockRDSAPIMockRecorder) DescribeDBClusterParameterGroups(arg0 interface{}) *gomock.Call { 2681 mr.mock.ctrl.T.Helper() 2682 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDBClusterParameterGroups", reflect.TypeOf((*MockRDSAPI)(nil).DescribeDBClusterParameterGroups), arg0) 2683 } 2684 2685 // DescribeDBClusterParameterGroupsPages mocks base method 2686 func (m *MockRDSAPI) DescribeDBClusterParameterGroupsPages(arg0 *rds.DescribeDBClusterParameterGroupsInput, arg1 func(*rds.DescribeDBClusterParameterGroupsOutput, bool) bool) error { 2687 m.ctrl.T.Helper() 2688 ret := m.ctrl.Call(m, "DescribeDBClusterParameterGroupsPages", arg0, arg1) 2689 ret0, _ := ret[0].(error) 2690 return ret0 2691 } 2692 2693 // DescribeDBClusterParameterGroupsPages indicates an expected call of DescribeDBClusterParameterGroupsPages 2694 func (mr *MockRDSAPIMockRecorder) DescribeDBClusterParameterGroupsPages(arg0, arg1 interface{}) *gomock.Call { 2695 mr.mock.ctrl.T.Helper() 2696 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDBClusterParameterGroupsPages", reflect.TypeOf((*MockRDSAPI)(nil).DescribeDBClusterParameterGroupsPages), arg0, arg1) 2697 } 2698 2699 // DescribeDBClusterParameterGroupsPagesWithContext mocks base method 2700 func (m *MockRDSAPI) DescribeDBClusterParameterGroupsPagesWithContext(arg0 context.Context, arg1 *rds.DescribeDBClusterParameterGroupsInput, arg2 func(*rds.DescribeDBClusterParameterGroupsOutput, bool) bool, arg3 ...request.Option) error { 2701 m.ctrl.T.Helper() 2702 varargs := []interface{}{arg0, arg1, arg2} 2703 for _, a := range arg3 { 2704 varargs = append(varargs, a) 2705 } 2706 ret := m.ctrl.Call(m, "DescribeDBClusterParameterGroupsPagesWithContext", varargs...) 2707 ret0, _ := ret[0].(error) 2708 return ret0 2709 } 2710 2711 // DescribeDBClusterParameterGroupsPagesWithContext indicates an expected call of DescribeDBClusterParameterGroupsPagesWithContext 2712 func (mr *MockRDSAPIMockRecorder) DescribeDBClusterParameterGroupsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 2713 mr.mock.ctrl.T.Helper() 2714 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 2715 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDBClusterParameterGroupsPagesWithContext", reflect.TypeOf((*MockRDSAPI)(nil).DescribeDBClusterParameterGroupsPagesWithContext), varargs...) 2716 } 2717 2718 // DescribeDBClusterParameterGroupsRequest mocks base method 2719 func (m *MockRDSAPI) DescribeDBClusterParameterGroupsRequest(arg0 *rds.DescribeDBClusterParameterGroupsInput) (*request.Request, *rds.DescribeDBClusterParameterGroupsOutput) { 2720 m.ctrl.T.Helper() 2721 ret := m.ctrl.Call(m, "DescribeDBClusterParameterGroupsRequest", arg0) 2722 ret0, _ := ret[0].(*request.Request) 2723 ret1, _ := ret[1].(*rds.DescribeDBClusterParameterGroupsOutput) 2724 return ret0, ret1 2725 } 2726 2727 // DescribeDBClusterParameterGroupsRequest indicates an expected call of DescribeDBClusterParameterGroupsRequest 2728 func (mr *MockRDSAPIMockRecorder) DescribeDBClusterParameterGroupsRequest(arg0 interface{}) *gomock.Call { 2729 mr.mock.ctrl.T.Helper() 2730 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDBClusterParameterGroupsRequest", reflect.TypeOf((*MockRDSAPI)(nil).DescribeDBClusterParameterGroupsRequest), arg0) 2731 } 2732 2733 // DescribeDBClusterParameterGroupsWithContext mocks base method 2734 func (m *MockRDSAPI) DescribeDBClusterParameterGroupsWithContext(arg0 context.Context, arg1 *rds.DescribeDBClusterParameterGroupsInput, arg2 ...request.Option) (*rds.DescribeDBClusterParameterGroupsOutput, error) { 2735 m.ctrl.T.Helper() 2736 varargs := []interface{}{arg0, arg1} 2737 for _, a := range arg2 { 2738 varargs = append(varargs, a) 2739 } 2740 ret := m.ctrl.Call(m, "DescribeDBClusterParameterGroupsWithContext", varargs...) 2741 ret0, _ := ret[0].(*rds.DescribeDBClusterParameterGroupsOutput) 2742 ret1, _ := ret[1].(error) 2743 return ret0, ret1 2744 } 2745 2746 // DescribeDBClusterParameterGroupsWithContext indicates an expected call of DescribeDBClusterParameterGroupsWithContext 2747 func (mr *MockRDSAPIMockRecorder) DescribeDBClusterParameterGroupsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 2748 mr.mock.ctrl.T.Helper() 2749 varargs := append([]interface{}{arg0, arg1}, arg2...) 2750 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDBClusterParameterGroupsWithContext", reflect.TypeOf((*MockRDSAPI)(nil).DescribeDBClusterParameterGroupsWithContext), varargs...) 2751 } 2752 2753 // DescribeDBClusterParameters mocks base method 2754 func (m *MockRDSAPI) DescribeDBClusterParameters(arg0 *rds.DescribeDBClusterParametersInput) (*rds.DescribeDBClusterParametersOutput, error) { 2755 m.ctrl.T.Helper() 2756 ret := m.ctrl.Call(m, "DescribeDBClusterParameters", arg0) 2757 ret0, _ := ret[0].(*rds.DescribeDBClusterParametersOutput) 2758 ret1, _ := ret[1].(error) 2759 return ret0, ret1 2760 } 2761 2762 // DescribeDBClusterParameters indicates an expected call of DescribeDBClusterParameters 2763 func (mr *MockRDSAPIMockRecorder) DescribeDBClusterParameters(arg0 interface{}) *gomock.Call { 2764 mr.mock.ctrl.T.Helper() 2765 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDBClusterParameters", reflect.TypeOf((*MockRDSAPI)(nil).DescribeDBClusterParameters), arg0) 2766 } 2767 2768 // DescribeDBClusterParametersPages mocks base method 2769 func (m *MockRDSAPI) DescribeDBClusterParametersPages(arg0 *rds.DescribeDBClusterParametersInput, arg1 func(*rds.DescribeDBClusterParametersOutput, bool) bool) error { 2770 m.ctrl.T.Helper() 2771 ret := m.ctrl.Call(m, "DescribeDBClusterParametersPages", arg0, arg1) 2772 ret0, _ := ret[0].(error) 2773 return ret0 2774 } 2775 2776 // DescribeDBClusterParametersPages indicates an expected call of DescribeDBClusterParametersPages 2777 func (mr *MockRDSAPIMockRecorder) DescribeDBClusterParametersPages(arg0, arg1 interface{}) *gomock.Call { 2778 mr.mock.ctrl.T.Helper() 2779 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDBClusterParametersPages", reflect.TypeOf((*MockRDSAPI)(nil).DescribeDBClusterParametersPages), arg0, arg1) 2780 } 2781 2782 // DescribeDBClusterParametersPagesWithContext mocks base method 2783 func (m *MockRDSAPI) DescribeDBClusterParametersPagesWithContext(arg0 context.Context, arg1 *rds.DescribeDBClusterParametersInput, arg2 func(*rds.DescribeDBClusterParametersOutput, bool) bool, arg3 ...request.Option) error { 2784 m.ctrl.T.Helper() 2785 varargs := []interface{}{arg0, arg1, arg2} 2786 for _, a := range arg3 { 2787 varargs = append(varargs, a) 2788 } 2789 ret := m.ctrl.Call(m, "DescribeDBClusterParametersPagesWithContext", varargs...) 2790 ret0, _ := ret[0].(error) 2791 return ret0 2792 } 2793 2794 // DescribeDBClusterParametersPagesWithContext indicates an expected call of DescribeDBClusterParametersPagesWithContext 2795 func (mr *MockRDSAPIMockRecorder) DescribeDBClusterParametersPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 2796 mr.mock.ctrl.T.Helper() 2797 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 2798 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDBClusterParametersPagesWithContext", reflect.TypeOf((*MockRDSAPI)(nil).DescribeDBClusterParametersPagesWithContext), varargs...) 2799 } 2800 2801 // DescribeDBClusterParametersRequest mocks base method 2802 func (m *MockRDSAPI) DescribeDBClusterParametersRequest(arg0 *rds.DescribeDBClusterParametersInput) (*request.Request, *rds.DescribeDBClusterParametersOutput) { 2803 m.ctrl.T.Helper() 2804 ret := m.ctrl.Call(m, "DescribeDBClusterParametersRequest", arg0) 2805 ret0, _ := ret[0].(*request.Request) 2806 ret1, _ := ret[1].(*rds.DescribeDBClusterParametersOutput) 2807 return ret0, ret1 2808 } 2809 2810 // DescribeDBClusterParametersRequest indicates an expected call of DescribeDBClusterParametersRequest 2811 func (mr *MockRDSAPIMockRecorder) DescribeDBClusterParametersRequest(arg0 interface{}) *gomock.Call { 2812 mr.mock.ctrl.T.Helper() 2813 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDBClusterParametersRequest", reflect.TypeOf((*MockRDSAPI)(nil).DescribeDBClusterParametersRequest), arg0) 2814 } 2815 2816 // DescribeDBClusterParametersWithContext mocks base method 2817 func (m *MockRDSAPI) DescribeDBClusterParametersWithContext(arg0 context.Context, arg1 *rds.DescribeDBClusterParametersInput, arg2 ...request.Option) (*rds.DescribeDBClusterParametersOutput, error) { 2818 m.ctrl.T.Helper() 2819 varargs := []interface{}{arg0, arg1} 2820 for _, a := range arg2 { 2821 varargs = append(varargs, a) 2822 } 2823 ret := m.ctrl.Call(m, "DescribeDBClusterParametersWithContext", varargs...) 2824 ret0, _ := ret[0].(*rds.DescribeDBClusterParametersOutput) 2825 ret1, _ := ret[1].(error) 2826 return ret0, ret1 2827 } 2828 2829 // DescribeDBClusterParametersWithContext indicates an expected call of DescribeDBClusterParametersWithContext 2830 func (mr *MockRDSAPIMockRecorder) DescribeDBClusterParametersWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 2831 mr.mock.ctrl.T.Helper() 2832 varargs := append([]interface{}{arg0, arg1}, arg2...) 2833 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDBClusterParametersWithContext", reflect.TypeOf((*MockRDSAPI)(nil).DescribeDBClusterParametersWithContext), varargs...) 2834 } 2835 2836 // DescribeDBClusterSnapshotAttributes mocks base method 2837 func (m *MockRDSAPI) DescribeDBClusterSnapshotAttributes(arg0 *rds.DescribeDBClusterSnapshotAttributesInput) (*rds.DescribeDBClusterSnapshotAttributesOutput, error) { 2838 m.ctrl.T.Helper() 2839 ret := m.ctrl.Call(m, "DescribeDBClusterSnapshotAttributes", arg0) 2840 ret0, _ := ret[0].(*rds.DescribeDBClusterSnapshotAttributesOutput) 2841 ret1, _ := ret[1].(error) 2842 return ret0, ret1 2843 } 2844 2845 // DescribeDBClusterSnapshotAttributes indicates an expected call of DescribeDBClusterSnapshotAttributes 2846 func (mr *MockRDSAPIMockRecorder) DescribeDBClusterSnapshotAttributes(arg0 interface{}) *gomock.Call { 2847 mr.mock.ctrl.T.Helper() 2848 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDBClusterSnapshotAttributes", reflect.TypeOf((*MockRDSAPI)(nil).DescribeDBClusterSnapshotAttributes), arg0) 2849 } 2850 2851 // DescribeDBClusterSnapshotAttributesRequest mocks base method 2852 func (m *MockRDSAPI) DescribeDBClusterSnapshotAttributesRequest(arg0 *rds.DescribeDBClusterSnapshotAttributesInput) (*request.Request, *rds.DescribeDBClusterSnapshotAttributesOutput) { 2853 m.ctrl.T.Helper() 2854 ret := m.ctrl.Call(m, "DescribeDBClusterSnapshotAttributesRequest", arg0) 2855 ret0, _ := ret[0].(*request.Request) 2856 ret1, _ := ret[1].(*rds.DescribeDBClusterSnapshotAttributesOutput) 2857 return ret0, ret1 2858 } 2859 2860 // DescribeDBClusterSnapshotAttributesRequest indicates an expected call of DescribeDBClusterSnapshotAttributesRequest 2861 func (mr *MockRDSAPIMockRecorder) DescribeDBClusterSnapshotAttributesRequest(arg0 interface{}) *gomock.Call { 2862 mr.mock.ctrl.T.Helper() 2863 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDBClusterSnapshotAttributesRequest", reflect.TypeOf((*MockRDSAPI)(nil).DescribeDBClusterSnapshotAttributesRequest), arg0) 2864 } 2865 2866 // DescribeDBClusterSnapshotAttributesWithContext mocks base method 2867 func (m *MockRDSAPI) DescribeDBClusterSnapshotAttributesWithContext(arg0 context.Context, arg1 *rds.DescribeDBClusterSnapshotAttributesInput, arg2 ...request.Option) (*rds.DescribeDBClusterSnapshotAttributesOutput, error) { 2868 m.ctrl.T.Helper() 2869 varargs := []interface{}{arg0, arg1} 2870 for _, a := range arg2 { 2871 varargs = append(varargs, a) 2872 } 2873 ret := m.ctrl.Call(m, "DescribeDBClusterSnapshotAttributesWithContext", varargs...) 2874 ret0, _ := ret[0].(*rds.DescribeDBClusterSnapshotAttributesOutput) 2875 ret1, _ := ret[1].(error) 2876 return ret0, ret1 2877 } 2878 2879 // DescribeDBClusterSnapshotAttributesWithContext indicates an expected call of DescribeDBClusterSnapshotAttributesWithContext 2880 func (mr *MockRDSAPIMockRecorder) DescribeDBClusterSnapshotAttributesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 2881 mr.mock.ctrl.T.Helper() 2882 varargs := append([]interface{}{arg0, arg1}, arg2...) 2883 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDBClusterSnapshotAttributesWithContext", reflect.TypeOf((*MockRDSAPI)(nil).DescribeDBClusterSnapshotAttributesWithContext), varargs...) 2884 } 2885 2886 // DescribeDBClusterSnapshots mocks base method 2887 func (m *MockRDSAPI) DescribeDBClusterSnapshots(arg0 *rds.DescribeDBClusterSnapshotsInput) (*rds.DescribeDBClusterSnapshotsOutput, error) { 2888 m.ctrl.T.Helper() 2889 ret := m.ctrl.Call(m, "DescribeDBClusterSnapshots", arg0) 2890 ret0, _ := ret[0].(*rds.DescribeDBClusterSnapshotsOutput) 2891 ret1, _ := ret[1].(error) 2892 return ret0, ret1 2893 } 2894 2895 // DescribeDBClusterSnapshots indicates an expected call of DescribeDBClusterSnapshots 2896 func (mr *MockRDSAPIMockRecorder) DescribeDBClusterSnapshots(arg0 interface{}) *gomock.Call { 2897 mr.mock.ctrl.T.Helper() 2898 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDBClusterSnapshots", reflect.TypeOf((*MockRDSAPI)(nil).DescribeDBClusterSnapshots), arg0) 2899 } 2900 2901 // DescribeDBClusterSnapshotsPages mocks base method 2902 func (m *MockRDSAPI) DescribeDBClusterSnapshotsPages(arg0 *rds.DescribeDBClusterSnapshotsInput, arg1 func(*rds.DescribeDBClusterSnapshotsOutput, bool) bool) error { 2903 m.ctrl.T.Helper() 2904 ret := m.ctrl.Call(m, "DescribeDBClusterSnapshotsPages", arg0, arg1) 2905 ret0, _ := ret[0].(error) 2906 return ret0 2907 } 2908 2909 // DescribeDBClusterSnapshotsPages indicates an expected call of DescribeDBClusterSnapshotsPages 2910 func (mr *MockRDSAPIMockRecorder) DescribeDBClusterSnapshotsPages(arg0, arg1 interface{}) *gomock.Call { 2911 mr.mock.ctrl.T.Helper() 2912 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDBClusterSnapshotsPages", reflect.TypeOf((*MockRDSAPI)(nil).DescribeDBClusterSnapshotsPages), arg0, arg1) 2913 } 2914 2915 // DescribeDBClusterSnapshotsPagesWithContext mocks base method 2916 func (m *MockRDSAPI) DescribeDBClusterSnapshotsPagesWithContext(arg0 context.Context, arg1 *rds.DescribeDBClusterSnapshotsInput, arg2 func(*rds.DescribeDBClusterSnapshotsOutput, bool) bool, arg3 ...request.Option) error { 2917 m.ctrl.T.Helper() 2918 varargs := []interface{}{arg0, arg1, arg2} 2919 for _, a := range arg3 { 2920 varargs = append(varargs, a) 2921 } 2922 ret := m.ctrl.Call(m, "DescribeDBClusterSnapshotsPagesWithContext", varargs...) 2923 ret0, _ := ret[0].(error) 2924 return ret0 2925 } 2926 2927 // DescribeDBClusterSnapshotsPagesWithContext indicates an expected call of DescribeDBClusterSnapshotsPagesWithContext 2928 func (mr *MockRDSAPIMockRecorder) DescribeDBClusterSnapshotsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 2929 mr.mock.ctrl.T.Helper() 2930 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 2931 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDBClusterSnapshotsPagesWithContext", reflect.TypeOf((*MockRDSAPI)(nil).DescribeDBClusterSnapshotsPagesWithContext), varargs...) 2932 } 2933 2934 // DescribeDBClusterSnapshotsRequest mocks base method 2935 func (m *MockRDSAPI) DescribeDBClusterSnapshotsRequest(arg0 *rds.DescribeDBClusterSnapshotsInput) (*request.Request, *rds.DescribeDBClusterSnapshotsOutput) { 2936 m.ctrl.T.Helper() 2937 ret := m.ctrl.Call(m, "DescribeDBClusterSnapshotsRequest", arg0) 2938 ret0, _ := ret[0].(*request.Request) 2939 ret1, _ := ret[1].(*rds.DescribeDBClusterSnapshotsOutput) 2940 return ret0, ret1 2941 } 2942 2943 // DescribeDBClusterSnapshotsRequest indicates an expected call of DescribeDBClusterSnapshotsRequest 2944 func (mr *MockRDSAPIMockRecorder) DescribeDBClusterSnapshotsRequest(arg0 interface{}) *gomock.Call { 2945 mr.mock.ctrl.T.Helper() 2946 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDBClusterSnapshotsRequest", reflect.TypeOf((*MockRDSAPI)(nil).DescribeDBClusterSnapshotsRequest), arg0) 2947 } 2948 2949 // DescribeDBClusterSnapshotsWithContext mocks base method 2950 func (m *MockRDSAPI) DescribeDBClusterSnapshotsWithContext(arg0 context.Context, arg1 *rds.DescribeDBClusterSnapshotsInput, arg2 ...request.Option) (*rds.DescribeDBClusterSnapshotsOutput, error) { 2951 m.ctrl.T.Helper() 2952 varargs := []interface{}{arg0, arg1} 2953 for _, a := range arg2 { 2954 varargs = append(varargs, a) 2955 } 2956 ret := m.ctrl.Call(m, "DescribeDBClusterSnapshotsWithContext", varargs...) 2957 ret0, _ := ret[0].(*rds.DescribeDBClusterSnapshotsOutput) 2958 ret1, _ := ret[1].(error) 2959 return ret0, ret1 2960 } 2961 2962 // DescribeDBClusterSnapshotsWithContext indicates an expected call of DescribeDBClusterSnapshotsWithContext 2963 func (mr *MockRDSAPIMockRecorder) DescribeDBClusterSnapshotsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 2964 mr.mock.ctrl.T.Helper() 2965 varargs := append([]interface{}{arg0, arg1}, arg2...) 2966 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDBClusterSnapshotsWithContext", reflect.TypeOf((*MockRDSAPI)(nil).DescribeDBClusterSnapshotsWithContext), varargs...) 2967 } 2968 2969 // DescribeDBClusters mocks base method 2970 func (m *MockRDSAPI) DescribeDBClusters(arg0 *rds.DescribeDBClustersInput) (*rds.DescribeDBClustersOutput, error) { 2971 m.ctrl.T.Helper() 2972 ret := m.ctrl.Call(m, "DescribeDBClusters", arg0) 2973 ret0, _ := ret[0].(*rds.DescribeDBClustersOutput) 2974 ret1, _ := ret[1].(error) 2975 return ret0, ret1 2976 } 2977 2978 // DescribeDBClusters indicates an expected call of DescribeDBClusters 2979 func (mr *MockRDSAPIMockRecorder) DescribeDBClusters(arg0 interface{}) *gomock.Call { 2980 mr.mock.ctrl.T.Helper() 2981 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDBClusters", reflect.TypeOf((*MockRDSAPI)(nil).DescribeDBClusters), arg0) 2982 } 2983 2984 // DescribeDBClustersPages mocks base method 2985 func (m *MockRDSAPI) DescribeDBClustersPages(arg0 *rds.DescribeDBClustersInput, arg1 func(*rds.DescribeDBClustersOutput, bool) bool) error { 2986 m.ctrl.T.Helper() 2987 ret := m.ctrl.Call(m, "DescribeDBClustersPages", arg0, arg1) 2988 ret0, _ := ret[0].(error) 2989 return ret0 2990 } 2991 2992 // DescribeDBClustersPages indicates an expected call of DescribeDBClustersPages 2993 func (mr *MockRDSAPIMockRecorder) DescribeDBClustersPages(arg0, arg1 interface{}) *gomock.Call { 2994 mr.mock.ctrl.T.Helper() 2995 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDBClustersPages", reflect.TypeOf((*MockRDSAPI)(nil).DescribeDBClustersPages), arg0, arg1) 2996 } 2997 2998 // DescribeDBClustersPagesWithContext mocks base method 2999 func (m *MockRDSAPI) DescribeDBClustersPagesWithContext(arg0 context.Context, arg1 *rds.DescribeDBClustersInput, arg2 func(*rds.DescribeDBClustersOutput, bool) bool, arg3 ...request.Option) error { 3000 m.ctrl.T.Helper() 3001 varargs := []interface{}{arg0, arg1, arg2} 3002 for _, a := range arg3 { 3003 varargs = append(varargs, a) 3004 } 3005 ret := m.ctrl.Call(m, "DescribeDBClustersPagesWithContext", varargs...) 3006 ret0, _ := ret[0].(error) 3007 return ret0 3008 } 3009 3010 // DescribeDBClustersPagesWithContext indicates an expected call of DescribeDBClustersPagesWithContext 3011 func (mr *MockRDSAPIMockRecorder) DescribeDBClustersPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 3012 mr.mock.ctrl.T.Helper() 3013 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 3014 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDBClustersPagesWithContext", reflect.TypeOf((*MockRDSAPI)(nil).DescribeDBClustersPagesWithContext), varargs...) 3015 } 3016 3017 // DescribeDBClustersRequest mocks base method 3018 func (m *MockRDSAPI) DescribeDBClustersRequest(arg0 *rds.DescribeDBClustersInput) (*request.Request, *rds.DescribeDBClustersOutput) { 3019 m.ctrl.T.Helper() 3020 ret := m.ctrl.Call(m, "DescribeDBClustersRequest", arg0) 3021 ret0, _ := ret[0].(*request.Request) 3022 ret1, _ := ret[1].(*rds.DescribeDBClustersOutput) 3023 return ret0, ret1 3024 } 3025 3026 // DescribeDBClustersRequest indicates an expected call of DescribeDBClustersRequest 3027 func (mr *MockRDSAPIMockRecorder) DescribeDBClustersRequest(arg0 interface{}) *gomock.Call { 3028 mr.mock.ctrl.T.Helper() 3029 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDBClustersRequest", reflect.TypeOf((*MockRDSAPI)(nil).DescribeDBClustersRequest), arg0) 3030 } 3031 3032 // DescribeDBClustersWithContext mocks base method 3033 func (m *MockRDSAPI) DescribeDBClustersWithContext(arg0 context.Context, arg1 *rds.DescribeDBClustersInput, arg2 ...request.Option) (*rds.DescribeDBClustersOutput, error) { 3034 m.ctrl.T.Helper() 3035 varargs := []interface{}{arg0, arg1} 3036 for _, a := range arg2 { 3037 varargs = append(varargs, a) 3038 } 3039 ret := m.ctrl.Call(m, "DescribeDBClustersWithContext", varargs...) 3040 ret0, _ := ret[0].(*rds.DescribeDBClustersOutput) 3041 ret1, _ := ret[1].(error) 3042 return ret0, ret1 3043 } 3044 3045 // DescribeDBClustersWithContext indicates an expected call of DescribeDBClustersWithContext 3046 func (mr *MockRDSAPIMockRecorder) DescribeDBClustersWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 3047 mr.mock.ctrl.T.Helper() 3048 varargs := append([]interface{}{arg0, arg1}, arg2...) 3049 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDBClustersWithContext", reflect.TypeOf((*MockRDSAPI)(nil).DescribeDBClustersWithContext), varargs...) 3050 } 3051 3052 // DescribeDBEngineVersions mocks base method 3053 func (m *MockRDSAPI) DescribeDBEngineVersions(arg0 *rds.DescribeDBEngineVersionsInput) (*rds.DescribeDBEngineVersionsOutput, error) { 3054 m.ctrl.T.Helper() 3055 ret := m.ctrl.Call(m, "DescribeDBEngineVersions", arg0) 3056 ret0, _ := ret[0].(*rds.DescribeDBEngineVersionsOutput) 3057 ret1, _ := ret[1].(error) 3058 return ret0, ret1 3059 } 3060 3061 // DescribeDBEngineVersions indicates an expected call of DescribeDBEngineVersions 3062 func (mr *MockRDSAPIMockRecorder) DescribeDBEngineVersions(arg0 interface{}) *gomock.Call { 3063 mr.mock.ctrl.T.Helper() 3064 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDBEngineVersions", reflect.TypeOf((*MockRDSAPI)(nil).DescribeDBEngineVersions), arg0) 3065 } 3066 3067 // DescribeDBEngineVersionsPages mocks base method 3068 func (m *MockRDSAPI) DescribeDBEngineVersionsPages(arg0 *rds.DescribeDBEngineVersionsInput, arg1 func(*rds.DescribeDBEngineVersionsOutput, bool) bool) error { 3069 m.ctrl.T.Helper() 3070 ret := m.ctrl.Call(m, "DescribeDBEngineVersionsPages", arg0, arg1) 3071 ret0, _ := ret[0].(error) 3072 return ret0 3073 } 3074 3075 // DescribeDBEngineVersionsPages indicates an expected call of DescribeDBEngineVersionsPages 3076 func (mr *MockRDSAPIMockRecorder) DescribeDBEngineVersionsPages(arg0, arg1 interface{}) *gomock.Call { 3077 mr.mock.ctrl.T.Helper() 3078 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDBEngineVersionsPages", reflect.TypeOf((*MockRDSAPI)(nil).DescribeDBEngineVersionsPages), arg0, arg1) 3079 } 3080 3081 // DescribeDBEngineVersionsPagesWithContext mocks base method 3082 func (m *MockRDSAPI) DescribeDBEngineVersionsPagesWithContext(arg0 context.Context, arg1 *rds.DescribeDBEngineVersionsInput, arg2 func(*rds.DescribeDBEngineVersionsOutput, bool) bool, arg3 ...request.Option) error { 3083 m.ctrl.T.Helper() 3084 varargs := []interface{}{arg0, arg1, arg2} 3085 for _, a := range arg3 { 3086 varargs = append(varargs, a) 3087 } 3088 ret := m.ctrl.Call(m, "DescribeDBEngineVersionsPagesWithContext", varargs...) 3089 ret0, _ := ret[0].(error) 3090 return ret0 3091 } 3092 3093 // DescribeDBEngineVersionsPagesWithContext indicates an expected call of DescribeDBEngineVersionsPagesWithContext 3094 func (mr *MockRDSAPIMockRecorder) DescribeDBEngineVersionsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 3095 mr.mock.ctrl.T.Helper() 3096 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 3097 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDBEngineVersionsPagesWithContext", reflect.TypeOf((*MockRDSAPI)(nil).DescribeDBEngineVersionsPagesWithContext), varargs...) 3098 } 3099 3100 // DescribeDBEngineVersionsRequest mocks base method 3101 func (m *MockRDSAPI) DescribeDBEngineVersionsRequest(arg0 *rds.DescribeDBEngineVersionsInput) (*request.Request, *rds.DescribeDBEngineVersionsOutput) { 3102 m.ctrl.T.Helper() 3103 ret := m.ctrl.Call(m, "DescribeDBEngineVersionsRequest", arg0) 3104 ret0, _ := ret[0].(*request.Request) 3105 ret1, _ := ret[1].(*rds.DescribeDBEngineVersionsOutput) 3106 return ret0, ret1 3107 } 3108 3109 // DescribeDBEngineVersionsRequest indicates an expected call of DescribeDBEngineVersionsRequest 3110 func (mr *MockRDSAPIMockRecorder) DescribeDBEngineVersionsRequest(arg0 interface{}) *gomock.Call { 3111 mr.mock.ctrl.T.Helper() 3112 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDBEngineVersionsRequest", reflect.TypeOf((*MockRDSAPI)(nil).DescribeDBEngineVersionsRequest), arg0) 3113 } 3114 3115 // DescribeDBEngineVersionsWithContext mocks base method 3116 func (m *MockRDSAPI) DescribeDBEngineVersionsWithContext(arg0 context.Context, arg1 *rds.DescribeDBEngineVersionsInput, arg2 ...request.Option) (*rds.DescribeDBEngineVersionsOutput, error) { 3117 m.ctrl.T.Helper() 3118 varargs := []interface{}{arg0, arg1} 3119 for _, a := range arg2 { 3120 varargs = append(varargs, a) 3121 } 3122 ret := m.ctrl.Call(m, "DescribeDBEngineVersionsWithContext", varargs...) 3123 ret0, _ := ret[0].(*rds.DescribeDBEngineVersionsOutput) 3124 ret1, _ := ret[1].(error) 3125 return ret0, ret1 3126 } 3127 3128 // DescribeDBEngineVersionsWithContext indicates an expected call of DescribeDBEngineVersionsWithContext 3129 func (mr *MockRDSAPIMockRecorder) DescribeDBEngineVersionsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 3130 mr.mock.ctrl.T.Helper() 3131 varargs := append([]interface{}{arg0, arg1}, arg2...) 3132 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDBEngineVersionsWithContext", reflect.TypeOf((*MockRDSAPI)(nil).DescribeDBEngineVersionsWithContext), varargs...) 3133 } 3134 3135 // DescribeDBInstanceAutomatedBackups mocks base method 3136 func (m *MockRDSAPI) DescribeDBInstanceAutomatedBackups(arg0 *rds.DescribeDBInstanceAutomatedBackupsInput) (*rds.DescribeDBInstanceAutomatedBackupsOutput, error) { 3137 m.ctrl.T.Helper() 3138 ret := m.ctrl.Call(m, "DescribeDBInstanceAutomatedBackups", arg0) 3139 ret0, _ := ret[0].(*rds.DescribeDBInstanceAutomatedBackupsOutput) 3140 ret1, _ := ret[1].(error) 3141 return ret0, ret1 3142 } 3143 3144 // DescribeDBInstanceAutomatedBackups indicates an expected call of DescribeDBInstanceAutomatedBackups 3145 func (mr *MockRDSAPIMockRecorder) DescribeDBInstanceAutomatedBackups(arg0 interface{}) *gomock.Call { 3146 mr.mock.ctrl.T.Helper() 3147 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDBInstanceAutomatedBackups", reflect.TypeOf((*MockRDSAPI)(nil).DescribeDBInstanceAutomatedBackups), arg0) 3148 } 3149 3150 // DescribeDBInstanceAutomatedBackupsPages mocks base method 3151 func (m *MockRDSAPI) DescribeDBInstanceAutomatedBackupsPages(arg0 *rds.DescribeDBInstanceAutomatedBackupsInput, arg1 func(*rds.DescribeDBInstanceAutomatedBackupsOutput, bool) bool) error { 3152 m.ctrl.T.Helper() 3153 ret := m.ctrl.Call(m, "DescribeDBInstanceAutomatedBackupsPages", arg0, arg1) 3154 ret0, _ := ret[0].(error) 3155 return ret0 3156 } 3157 3158 // DescribeDBInstanceAutomatedBackupsPages indicates an expected call of DescribeDBInstanceAutomatedBackupsPages 3159 func (mr *MockRDSAPIMockRecorder) DescribeDBInstanceAutomatedBackupsPages(arg0, arg1 interface{}) *gomock.Call { 3160 mr.mock.ctrl.T.Helper() 3161 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDBInstanceAutomatedBackupsPages", reflect.TypeOf((*MockRDSAPI)(nil).DescribeDBInstanceAutomatedBackupsPages), arg0, arg1) 3162 } 3163 3164 // DescribeDBInstanceAutomatedBackupsPagesWithContext mocks base method 3165 func (m *MockRDSAPI) DescribeDBInstanceAutomatedBackupsPagesWithContext(arg0 context.Context, arg1 *rds.DescribeDBInstanceAutomatedBackupsInput, arg2 func(*rds.DescribeDBInstanceAutomatedBackupsOutput, bool) bool, arg3 ...request.Option) error { 3166 m.ctrl.T.Helper() 3167 varargs := []interface{}{arg0, arg1, arg2} 3168 for _, a := range arg3 { 3169 varargs = append(varargs, a) 3170 } 3171 ret := m.ctrl.Call(m, "DescribeDBInstanceAutomatedBackupsPagesWithContext", varargs...) 3172 ret0, _ := ret[0].(error) 3173 return ret0 3174 } 3175 3176 // DescribeDBInstanceAutomatedBackupsPagesWithContext indicates an expected call of DescribeDBInstanceAutomatedBackupsPagesWithContext 3177 func (mr *MockRDSAPIMockRecorder) DescribeDBInstanceAutomatedBackupsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 3178 mr.mock.ctrl.T.Helper() 3179 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 3180 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDBInstanceAutomatedBackupsPagesWithContext", reflect.TypeOf((*MockRDSAPI)(nil).DescribeDBInstanceAutomatedBackupsPagesWithContext), varargs...) 3181 } 3182 3183 // DescribeDBInstanceAutomatedBackupsRequest mocks base method 3184 func (m *MockRDSAPI) DescribeDBInstanceAutomatedBackupsRequest(arg0 *rds.DescribeDBInstanceAutomatedBackupsInput) (*request.Request, *rds.DescribeDBInstanceAutomatedBackupsOutput) { 3185 m.ctrl.T.Helper() 3186 ret := m.ctrl.Call(m, "DescribeDBInstanceAutomatedBackupsRequest", arg0) 3187 ret0, _ := ret[0].(*request.Request) 3188 ret1, _ := ret[1].(*rds.DescribeDBInstanceAutomatedBackupsOutput) 3189 return ret0, ret1 3190 } 3191 3192 // DescribeDBInstanceAutomatedBackupsRequest indicates an expected call of DescribeDBInstanceAutomatedBackupsRequest 3193 func (mr *MockRDSAPIMockRecorder) DescribeDBInstanceAutomatedBackupsRequest(arg0 interface{}) *gomock.Call { 3194 mr.mock.ctrl.T.Helper() 3195 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDBInstanceAutomatedBackupsRequest", reflect.TypeOf((*MockRDSAPI)(nil).DescribeDBInstanceAutomatedBackupsRequest), arg0) 3196 } 3197 3198 // DescribeDBInstanceAutomatedBackupsWithContext mocks base method 3199 func (m *MockRDSAPI) DescribeDBInstanceAutomatedBackupsWithContext(arg0 context.Context, arg1 *rds.DescribeDBInstanceAutomatedBackupsInput, arg2 ...request.Option) (*rds.DescribeDBInstanceAutomatedBackupsOutput, error) { 3200 m.ctrl.T.Helper() 3201 varargs := []interface{}{arg0, arg1} 3202 for _, a := range arg2 { 3203 varargs = append(varargs, a) 3204 } 3205 ret := m.ctrl.Call(m, "DescribeDBInstanceAutomatedBackupsWithContext", varargs...) 3206 ret0, _ := ret[0].(*rds.DescribeDBInstanceAutomatedBackupsOutput) 3207 ret1, _ := ret[1].(error) 3208 return ret0, ret1 3209 } 3210 3211 // DescribeDBInstanceAutomatedBackupsWithContext indicates an expected call of DescribeDBInstanceAutomatedBackupsWithContext 3212 func (mr *MockRDSAPIMockRecorder) DescribeDBInstanceAutomatedBackupsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 3213 mr.mock.ctrl.T.Helper() 3214 varargs := append([]interface{}{arg0, arg1}, arg2...) 3215 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDBInstanceAutomatedBackupsWithContext", reflect.TypeOf((*MockRDSAPI)(nil).DescribeDBInstanceAutomatedBackupsWithContext), varargs...) 3216 } 3217 3218 // DescribeDBInstances mocks base method 3219 func (m *MockRDSAPI) DescribeDBInstances(arg0 *rds.DescribeDBInstancesInput) (*rds.DescribeDBInstancesOutput, error) { 3220 m.ctrl.T.Helper() 3221 ret := m.ctrl.Call(m, "DescribeDBInstances", arg0) 3222 ret0, _ := ret[0].(*rds.DescribeDBInstancesOutput) 3223 ret1, _ := ret[1].(error) 3224 return ret0, ret1 3225 } 3226 3227 // DescribeDBInstances indicates an expected call of DescribeDBInstances 3228 func (mr *MockRDSAPIMockRecorder) DescribeDBInstances(arg0 interface{}) *gomock.Call { 3229 mr.mock.ctrl.T.Helper() 3230 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDBInstances", reflect.TypeOf((*MockRDSAPI)(nil).DescribeDBInstances), arg0) 3231 } 3232 3233 // DescribeDBInstancesPages mocks base method 3234 func (m *MockRDSAPI) DescribeDBInstancesPages(arg0 *rds.DescribeDBInstancesInput, arg1 func(*rds.DescribeDBInstancesOutput, bool) bool) error { 3235 m.ctrl.T.Helper() 3236 ret := m.ctrl.Call(m, "DescribeDBInstancesPages", arg0, arg1) 3237 ret0, _ := ret[0].(error) 3238 return ret0 3239 } 3240 3241 // DescribeDBInstancesPages indicates an expected call of DescribeDBInstancesPages 3242 func (mr *MockRDSAPIMockRecorder) DescribeDBInstancesPages(arg0, arg1 interface{}) *gomock.Call { 3243 mr.mock.ctrl.T.Helper() 3244 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDBInstancesPages", reflect.TypeOf((*MockRDSAPI)(nil).DescribeDBInstancesPages), arg0, arg1) 3245 } 3246 3247 // DescribeDBInstancesPagesWithContext mocks base method 3248 func (m *MockRDSAPI) DescribeDBInstancesPagesWithContext(arg0 context.Context, arg1 *rds.DescribeDBInstancesInput, arg2 func(*rds.DescribeDBInstancesOutput, bool) bool, arg3 ...request.Option) error { 3249 m.ctrl.T.Helper() 3250 varargs := []interface{}{arg0, arg1, arg2} 3251 for _, a := range arg3 { 3252 varargs = append(varargs, a) 3253 } 3254 ret := m.ctrl.Call(m, "DescribeDBInstancesPagesWithContext", varargs...) 3255 ret0, _ := ret[0].(error) 3256 return ret0 3257 } 3258 3259 // DescribeDBInstancesPagesWithContext indicates an expected call of DescribeDBInstancesPagesWithContext 3260 func (mr *MockRDSAPIMockRecorder) DescribeDBInstancesPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 3261 mr.mock.ctrl.T.Helper() 3262 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 3263 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDBInstancesPagesWithContext", reflect.TypeOf((*MockRDSAPI)(nil).DescribeDBInstancesPagesWithContext), varargs...) 3264 } 3265 3266 // DescribeDBInstancesRequest mocks base method 3267 func (m *MockRDSAPI) DescribeDBInstancesRequest(arg0 *rds.DescribeDBInstancesInput) (*request.Request, *rds.DescribeDBInstancesOutput) { 3268 m.ctrl.T.Helper() 3269 ret := m.ctrl.Call(m, "DescribeDBInstancesRequest", arg0) 3270 ret0, _ := ret[0].(*request.Request) 3271 ret1, _ := ret[1].(*rds.DescribeDBInstancesOutput) 3272 return ret0, ret1 3273 } 3274 3275 // DescribeDBInstancesRequest indicates an expected call of DescribeDBInstancesRequest 3276 func (mr *MockRDSAPIMockRecorder) DescribeDBInstancesRequest(arg0 interface{}) *gomock.Call { 3277 mr.mock.ctrl.T.Helper() 3278 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDBInstancesRequest", reflect.TypeOf((*MockRDSAPI)(nil).DescribeDBInstancesRequest), arg0) 3279 } 3280 3281 // DescribeDBInstancesWithContext mocks base method 3282 func (m *MockRDSAPI) DescribeDBInstancesWithContext(arg0 context.Context, arg1 *rds.DescribeDBInstancesInput, arg2 ...request.Option) (*rds.DescribeDBInstancesOutput, error) { 3283 m.ctrl.T.Helper() 3284 varargs := []interface{}{arg0, arg1} 3285 for _, a := range arg2 { 3286 varargs = append(varargs, a) 3287 } 3288 ret := m.ctrl.Call(m, "DescribeDBInstancesWithContext", varargs...) 3289 ret0, _ := ret[0].(*rds.DescribeDBInstancesOutput) 3290 ret1, _ := ret[1].(error) 3291 return ret0, ret1 3292 } 3293 3294 // DescribeDBInstancesWithContext indicates an expected call of DescribeDBInstancesWithContext 3295 func (mr *MockRDSAPIMockRecorder) DescribeDBInstancesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 3296 mr.mock.ctrl.T.Helper() 3297 varargs := append([]interface{}{arg0, arg1}, arg2...) 3298 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDBInstancesWithContext", reflect.TypeOf((*MockRDSAPI)(nil).DescribeDBInstancesWithContext), varargs...) 3299 } 3300 3301 // DescribeDBLogFiles mocks base method 3302 func (m *MockRDSAPI) DescribeDBLogFiles(arg0 *rds.DescribeDBLogFilesInput) (*rds.DescribeDBLogFilesOutput, error) { 3303 m.ctrl.T.Helper() 3304 ret := m.ctrl.Call(m, "DescribeDBLogFiles", arg0) 3305 ret0, _ := ret[0].(*rds.DescribeDBLogFilesOutput) 3306 ret1, _ := ret[1].(error) 3307 return ret0, ret1 3308 } 3309 3310 // DescribeDBLogFiles indicates an expected call of DescribeDBLogFiles 3311 func (mr *MockRDSAPIMockRecorder) DescribeDBLogFiles(arg0 interface{}) *gomock.Call { 3312 mr.mock.ctrl.T.Helper() 3313 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDBLogFiles", reflect.TypeOf((*MockRDSAPI)(nil).DescribeDBLogFiles), arg0) 3314 } 3315 3316 // DescribeDBLogFilesPages mocks base method 3317 func (m *MockRDSAPI) DescribeDBLogFilesPages(arg0 *rds.DescribeDBLogFilesInput, arg1 func(*rds.DescribeDBLogFilesOutput, bool) bool) error { 3318 m.ctrl.T.Helper() 3319 ret := m.ctrl.Call(m, "DescribeDBLogFilesPages", arg0, arg1) 3320 ret0, _ := ret[0].(error) 3321 return ret0 3322 } 3323 3324 // DescribeDBLogFilesPages indicates an expected call of DescribeDBLogFilesPages 3325 func (mr *MockRDSAPIMockRecorder) DescribeDBLogFilesPages(arg0, arg1 interface{}) *gomock.Call { 3326 mr.mock.ctrl.T.Helper() 3327 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDBLogFilesPages", reflect.TypeOf((*MockRDSAPI)(nil).DescribeDBLogFilesPages), arg0, arg1) 3328 } 3329 3330 // DescribeDBLogFilesPagesWithContext mocks base method 3331 func (m *MockRDSAPI) DescribeDBLogFilesPagesWithContext(arg0 context.Context, arg1 *rds.DescribeDBLogFilesInput, arg2 func(*rds.DescribeDBLogFilesOutput, bool) bool, arg3 ...request.Option) error { 3332 m.ctrl.T.Helper() 3333 varargs := []interface{}{arg0, arg1, arg2} 3334 for _, a := range arg3 { 3335 varargs = append(varargs, a) 3336 } 3337 ret := m.ctrl.Call(m, "DescribeDBLogFilesPagesWithContext", varargs...) 3338 ret0, _ := ret[0].(error) 3339 return ret0 3340 } 3341 3342 // DescribeDBLogFilesPagesWithContext indicates an expected call of DescribeDBLogFilesPagesWithContext 3343 func (mr *MockRDSAPIMockRecorder) DescribeDBLogFilesPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 3344 mr.mock.ctrl.T.Helper() 3345 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 3346 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDBLogFilesPagesWithContext", reflect.TypeOf((*MockRDSAPI)(nil).DescribeDBLogFilesPagesWithContext), varargs...) 3347 } 3348 3349 // DescribeDBLogFilesRequest mocks base method 3350 func (m *MockRDSAPI) DescribeDBLogFilesRequest(arg0 *rds.DescribeDBLogFilesInput) (*request.Request, *rds.DescribeDBLogFilesOutput) { 3351 m.ctrl.T.Helper() 3352 ret := m.ctrl.Call(m, "DescribeDBLogFilesRequest", arg0) 3353 ret0, _ := ret[0].(*request.Request) 3354 ret1, _ := ret[1].(*rds.DescribeDBLogFilesOutput) 3355 return ret0, ret1 3356 } 3357 3358 // DescribeDBLogFilesRequest indicates an expected call of DescribeDBLogFilesRequest 3359 func (mr *MockRDSAPIMockRecorder) DescribeDBLogFilesRequest(arg0 interface{}) *gomock.Call { 3360 mr.mock.ctrl.T.Helper() 3361 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDBLogFilesRequest", reflect.TypeOf((*MockRDSAPI)(nil).DescribeDBLogFilesRequest), arg0) 3362 } 3363 3364 // DescribeDBLogFilesWithContext mocks base method 3365 func (m *MockRDSAPI) DescribeDBLogFilesWithContext(arg0 context.Context, arg1 *rds.DescribeDBLogFilesInput, arg2 ...request.Option) (*rds.DescribeDBLogFilesOutput, error) { 3366 m.ctrl.T.Helper() 3367 varargs := []interface{}{arg0, arg1} 3368 for _, a := range arg2 { 3369 varargs = append(varargs, a) 3370 } 3371 ret := m.ctrl.Call(m, "DescribeDBLogFilesWithContext", varargs...) 3372 ret0, _ := ret[0].(*rds.DescribeDBLogFilesOutput) 3373 ret1, _ := ret[1].(error) 3374 return ret0, ret1 3375 } 3376 3377 // DescribeDBLogFilesWithContext indicates an expected call of DescribeDBLogFilesWithContext 3378 func (mr *MockRDSAPIMockRecorder) DescribeDBLogFilesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 3379 mr.mock.ctrl.T.Helper() 3380 varargs := append([]interface{}{arg0, arg1}, arg2...) 3381 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDBLogFilesWithContext", reflect.TypeOf((*MockRDSAPI)(nil).DescribeDBLogFilesWithContext), varargs...) 3382 } 3383 3384 // DescribeDBParameterGroups mocks base method 3385 func (m *MockRDSAPI) DescribeDBParameterGroups(arg0 *rds.DescribeDBParameterGroupsInput) (*rds.DescribeDBParameterGroupsOutput, error) { 3386 m.ctrl.T.Helper() 3387 ret := m.ctrl.Call(m, "DescribeDBParameterGroups", arg0) 3388 ret0, _ := ret[0].(*rds.DescribeDBParameterGroupsOutput) 3389 ret1, _ := ret[1].(error) 3390 return ret0, ret1 3391 } 3392 3393 // DescribeDBParameterGroups indicates an expected call of DescribeDBParameterGroups 3394 func (mr *MockRDSAPIMockRecorder) DescribeDBParameterGroups(arg0 interface{}) *gomock.Call { 3395 mr.mock.ctrl.T.Helper() 3396 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDBParameterGroups", reflect.TypeOf((*MockRDSAPI)(nil).DescribeDBParameterGroups), arg0) 3397 } 3398 3399 // DescribeDBParameterGroupsPages mocks base method 3400 func (m *MockRDSAPI) DescribeDBParameterGroupsPages(arg0 *rds.DescribeDBParameterGroupsInput, arg1 func(*rds.DescribeDBParameterGroupsOutput, bool) bool) error { 3401 m.ctrl.T.Helper() 3402 ret := m.ctrl.Call(m, "DescribeDBParameterGroupsPages", arg0, arg1) 3403 ret0, _ := ret[0].(error) 3404 return ret0 3405 } 3406 3407 // DescribeDBParameterGroupsPages indicates an expected call of DescribeDBParameterGroupsPages 3408 func (mr *MockRDSAPIMockRecorder) DescribeDBParameterGroupsPages(arg0, arg1 interface{}) *gomock.Call { 3409 mr.mock.ctrl.T.Helper() 3410 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDBParameterGroupsPages", reflect.TypeOf((*MockRDSAPI)(nil).DescribeDBParameterGroupsPages), arg0, arg1) 3411 } 3412 3413 // DescribeDBParameterGroupsPagesWithContext mocks base method 3414 func (m *MockRDSAPI) DescribeDBParameterGroupsPagesWithContext(arg0 context.Context, arg1 *rds.DescribeDBParameterGroupsInput, arg2 func(*rds.DescribeDBParameterGroupsOutput, bool) bool, arg3 ...request.Option) error { 3415 m.ctrl.T.Helper() 3416 varargs := []interface{}{arg0, arg1, arg2} 3417 for _, a := range arg3 { 3418 varargs = append(varargs, a) 3419 } 3420 ret := m.ctrl.Call(m, "DescribeDBParameterGroupsPagesWithContext", varargs...) 3421 ret0, _ := ret[0].(error) 3422 return ret0 3423 } 3424 3425 // DescribeDBParameterGroupsPagesWithContext indicates an expected call of DescribeDBParameterGroupsPagesWithContext 3426 func (mr *MockRDSAPIMockRecorder) DescribeDBParameterGroupsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 3427 mr.mock.ctrl.T.Helper() 3428 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 3429 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDBParameterGroupsPagesWithContext", reflect.TypeOf((*MockRDSAPI)(nil).DescribeDBParameterGroupsPagesWithContext), varargs...) 3430 } 3431 3432 // DescribeDBParameterGroupsRequest mocks base method 3433 func (m *MockRDSAPI) DescribeDBParameterGroupsRequest(arg0 *rds.DescribeDBParameterGroupsInput) (*request.Request, *rds.DescribeDBParameterGroupsOutput) { 3434 m.ctrl.T.Helper() 3435 ret := m.ctrl.Call(m, "DescribeDBParameterGroupsRequest", arg0) 3436 ret0, _ := ret[0].(*request.Request) 3437 ret1, _ := ret[1].(*rds.DescribeDBParameterGroupsOutput) 3438 return ret0, ret1 3439 } 3440 3441 // DescribeDBParameterGroupsRequest indicates an expected call of DescribeDBParameterGroupsRequest 3442 func (mr *MockRDSAPIMockRecorder) DescribeDBParameterGroupsRequest(arg0 interface{}) *gomock.Call { 3443 mr.mock.ctrl.T.Helper() 3444 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDBParameterGroupsRequest", reflect.TypeOf((*MockRDSAPI)(nil).DescribeDBParameterGroupsRequest), arg0) 3445 } 3446 3447 // DescribeDBParameterGroupsWithContext mocks base method 3448 func (m *MockRDSAPI) DescribeDBParameterGroupsWithContext(arg0 context.Context, arg1 *rds.DescribeDBParameterGroupsInput, arg2 ...request.Option) (*rds.DescribeDBParameterGroupsOutput, error) { 3449 m.ctrl.T.Helper() 3450 varargs := []interface{}{arg0, arg1} 3451 for _, a := range arg2 { 3452 varargs = append(varargs, a) 3453 } 3454 ret := m.ctrl.Call(m, "DescribeDBParameterGroupsWithContext", varargs...) 3455 ret0, _ := ret[0].(*rds.DescribeDBParameterGroupsOutput) 3456 ret1, _ := ret[1].(error) 3457 return ret0, ret1 3458 } 3459 3460 // DescribeDBParameterGroupsWithContext indicates an expected call of DescribeDBParameterGroupsWithContext 3461 func (mr *MockRDSAPIMockRecorder) DescribeDBParameterGroupsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 3462 mr.mock.ctrl.T.Helper() 3463 varargs := append([]interface{}{arg0, arg1}, arg2...) 3464 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDBParameterGroupsWithContext", reflect.TypeOf((*MockRDSAPI)(nil).DescribeDBParameterGroupsWithContext), varargs...) 3465 } 3466 3467 // DescribeDBParameters mocks base method 3468 func (m *MockRDSAPI) DescribeDBParameters(arg0 *rds.DescribeDBParametersInput) (*rds.DescribeDBParametersOutput, error) { 3469 m.ctrl.T.Helper() 3470 ret := m.ctrl.Call(m, "DescribeDBParameters", arg0) 3471 ret0, _ := ret[0].(*rds.DescribeDBParametersOutput) 3472 ret1, _ := ret[1].(error) 3473 return ret0, ret1 3474 } 3475 3476 // DescribeDBParameters indicates an expected call of DescribeDBParameters 3477 func (mr *MockRDSAPIMockRecorder) DescribeDBParameters(arg0 interface{}) *gomock.Call { 3478 mr.mock.ctrl.T.Helper() 3479 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDBParameters", reflect.TypeOf((*MockRDSAPI)(nil).DescribeDBParameters), arg0) 3480 } 3481 3482 // DescribeDBParametersPages mocks base method 3483 func (m *MockRDSAPI) DescribeDBParametersPages(arg0 *rds.DescribeDBParametersInput, arg1 func(*rds.DescribeDBParametersOutput, bool) bool) error { 3484 m.ctrl.T.Helper() 3485 ret := m.ctrl.Call(m, "DescribeDBParametersPages", arg0, arg1) 3486 ret0, _ := ret[0].(error) 3487 return ret0 3488 } 3489 3490 // DescribeDBParametersPages indicates an expected call of DescribeDBParametersPages 3491 func (mr *MockRDSAPIMockRecorder) DescribeDBParametersPages(arg0, arg1 interface{}) *gomock.Call { 3492 mr.mock.ctrl.T.Helper() 3493 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDBParametersPages", reflect.TypeOf((*MockRDSAPI)(nil).DescribeDBParametersPages), arg0, arg1) 3494 } 3495 3496 // DescribeDBParametersPagesWithContext mocks base method 3497 func (m *MockRDSAPI) DescribeDBParametersPagesWithContext(arg0 context.Context, arg1 *rds.DescribeDBParametersInput, arg2 func(*rds.DescribeDBParametersOutput, bool) bool, arg3 ...request.Option) error { 3498 m.ctrl.T.Helper() 3499 varargs := []interface{}{arg0, arg1, arg2} 3500 for _, a := range arg3 { 3501 varargs = append(varargs, a) 3502 } 3503 ret := m.ctrl.Call(m, "DescribeDBParametersPagesWithContext", varargs...) 3504 ret0, _ := ret[0].(error) 3505 return ret0 3506 } 3507 3508 // DescribeDBParametersPagesWithContext indicates an expected call of DescribeDBParametersPagesWithContext 3509 func (mr *MockRDSAPIMockRecorder) DescribeDBParametersPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 3510 mr.mock.ctrl.T.Helper() 3511 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 3512 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDBParametersPagesWithContext", reflect.TypeOf((*MockRDSAPI)(nil).DescribeDBParametersPagesWithContext), varargs...) 3513 } 3514 3515 // DescribeDBParametersRequest mocks base method 3516 func (m *MockRDSAPI) DescribeDBParametersRequest(arg0 *rds.DescribeDBParametersInput) (*request.Request, *rds.DescribeDBParametersOutput) { 3517 m.ctrl.T.Helper() 3518 ret := m.ctrl.Call(m, "DescribeDBParametersRequest", arg0) 3519 ret0, _ := ret[0].(*request.Request) 3520 ret1, _ := ret[1].(*rds.DescribeDBParametersOutput) 3521 return ret0, ret1 3522 } 3523 3524 // DescribeDBParametersRequest indicates an expected call of DescribeDBParametersRequest 3525 func (mr *MockRDSAPIMockRecorder) DescribeDBParametersRequest(arg0 interface{}) *gomock.Call { 3526 mr.mock.ctrl.T.Helper() 3527 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDBParametersRequest", reflect.TypeOf((*MockRDSAPI)(nil).DescribeDBParametersRequest), arg0) 3528 } 3529 3530 // DescribeDBParametersWithContext mocks base method 3531 func (m *MockRDSAPI) DescribeDBParametersWithContext(arg0 context.Context, arg1 *rds.DescribeDBParametersInput, arg2 ...request.Option) (*rds.DescribeDBParametersOutput, error) { 3532 m.ctrl.T.Helper() 3533 varargs := []interface{}{arg0, arg1} 3534 for _, a := range arg2 { 3535 varargs = append(varargs, a) 3536 } 3537 ret := m.ctrl.Call(m, "DescribeDBParametersWithContext", varargs...) 3538 ret0, _ := ret[0].(*rds.DescribeDBParametersOutput) 3539 ret1, _ := ret[1].(error) 3540 return ret0, ret1 3541 } 3542 3543 // DescribeDBParametersWithContext indicates an expected call of DescribeDBParametersWithContext 3544 func (mr *MockRDSAPIMockRecorder) DescribeDBParametersWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 3545 mr.mock.ctrl.T.Helper() 3546 varargs := append([]interface{}{arg0, arg1}, arg2...) 3547 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDBParametersWithContext", reflect.TypeOf((*MockRDSAPI)(nil).DescribeDBParametersWithContext), varargs...) 3548 } 3549 3550 // DescribeDBProxies mocks base method 3551 func (m *MockRDSAPI) DescribeDBProxies(arg0 *rds.DescribeDBProxiesInput) (*rds.DescribeDBProxiesOutput, error) { 3552 m.ctrl.T.Helper() 3553 ret := m.ctrl.Call(m, "DescribeDBProxies", arg0) 3554 ret0, _ := ret[0].(*rds.DescribeDBProxiesOutput) 3555 ret1, _ := ret[1].(error) 3556 return ret0, ret1 3557 } 3558 3559 // DescribeDBProxies indicates an expected call of DescribeDBProxies 3560 func (mr *MockRDSAPIMockRecorder) DescribeDBProxies(arg0 interface{}) *gomock.Call { 3561 mr.mock.ctrl.T.Helper() 3562 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDBProxies", reflect.TypeOf((*MockRDSAPI)(nil).DescribeDBProxies), arg0) 3563 } 3564 3565 // DescribeDBProxiesPages mocks base method 3566 func (m *MockRDSAPI) DescribeDBProxiesPages(arg0 *rds.DescribeDBProxiesInput, arg1 func(*rds.DescribeDBProxiesOutput, bool) bool) error { 3567 m.ctrl.T.Helper() 3568 ret := m.ctrl.Call(m, "DescribeDBProxiesPages", arg0, arg1) 3569 ret0, _ := ret[0].(error) 3570 return ret0 3571 } 3572 3573 // DescribeDBProxiesPages indicates an expected call of DescribeDBProxiesPages 3574 func (mr *MockRDSAPIMockRecorder) DescribeDBProxiesPages(arg0, arg1 interface{}) *gomock.Call { 3575 mr.mock.ctrl.T.Helper() 3576 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDBProxiesPages", reflect.TypeOf((*MockRDSAPI)(nil).DescribeDBProxiesPages), arg0, arg1) 3577 } 3578 3579 // DescribeDBProxiesPagesWithContext mocks base method 3580 func (m *MockRDSAPI) DescribeDBProxiesPagesWithContext(arg0 context.Context, arg1 *rds.DescribeDBProxiesInput, arg2 func(*rds.DescribeDBProxiesOutput, bool) bool, arg3 ...request.Option) error { 3581 m.ctrl.T.Helper() 3582 varargs := []interface{}{arg0, arg1, arg2} 3583 for _, a := range arg3 { 3584 varargs = append(varargs, a) 3585 } 3586 ret := m.ctrl.Call(m, "DescribeDBProxiesPagesWithContext", varargs...) 3587 ret0, _ := ret[0].(error) 3588 return ret0 3589 } 3590 3591 // DescribeDBProxiesPagesWithContext indicates an expected call of DescribeDBProxiesPagesWithContext 3592 func (mr *MockRDSAPIMockRecorder) DescribeDBProxiesPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 3593 mr.mock.ctrl.T.Helper() 3594 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 3595 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDBProxiesPagesWithContext", reflect.TypeOf((*MockRDSAPI)(nil).DescribeDBProxiesPagesWithContext), varargs...) 3596 } 3597 3598 // DescribeDBProxiesRequest mocks base method 3599 func (m *MockRDSAPI) DescribeDBProxiesRequest(arg0 *rds.DescribeDBProxiesInput) (*request.Request, *rds.DescribeDBProxiesOutput) { 3600 m.ctrl.T.Helper() 3601 ret := m.ctrl.Call(m, "DescribeDBProxiesRequest", arg0) 3602 ret0, _ := ret[0].(*request.Request) 3603 ret1, _ := ret[1].(*rds.DescribeDBProxiesOutput) 3604 return ret0, ret1 3605 } 3606 3607 // DescribeDBProxiesRequest indicates an expected call of DescribeDBProxiesRequest 3608 func (mr *MockRDSAPIMockRecorder) DescribeDBProxiesRequest(arg0 interface{}) *gomock.Call { 3609 mr.mock.ctrl.T.Helper() 3610 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDBProxiesRequest", reflect.TypeOf((*MockRDSAPI)(nil).DescribeDBProxiesRequest), arg0) 3611 } 3612 3613 // DescribeDBProxiesWithContext mocks base method 3614 func (m *MockRDSAPI) DescribeDBProxiesWithContext(arg0 context.Context, arg1 *rds.DescribeDBProxiesInput, arg2 ...request.Option) (*rds.DescribeDBProxiesOutput, error) { 3615 m.ctrl.T.Helper() 3616 varargs := []interface{}{arg0, arg1} 3617 for _, a := range arg2 { 3618 varargs = append(varargs, a) 3619 } 3620 ret := m.ctrl.Call(m, "DescribeDBProxiesWithContext", varargs...) 3621 ret0, _ := ret[0].(*rds.DescribeDBProxiesOutput) 3622 ret1, _ := ret[1].(error) 3623 return ret0, ret1 3624 } 3625 3626 // DescribeDBProxiesWithContext indicates an expected call of DescribeDBProxiesWithContext 3627 func (mr *MockRDSAPIMockRecorder) DescribeDBProxiesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 3628 mr.mock.ctrl.T.Helper() 3629 varargs := append([]interface{}{arg0, arg1}, arg2...) 3630 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDBProxiesWithContext", reflect.TypeOf((*MockRDSAPI)(nil).DescribeDBProxiesWithContext), varargs...) 3631 } 3632 3633 // DescribeDBProxyTargetGroups mocks base method 3634 func (m *MockRDSAPI) DescribeDBProxyTargetGroups(arg0 *rds.DescribeDBProxyTargetGroupsInput) (*rds.DescribeDBProxyTargetGroupsOutput, error) { 3635 m.ctrl.T.Helper() 3636 ret := m.ctrl.Call(m, "DescribeDBProxyTargetGroups", arg0) 3637 ret0, _ := ret[0].(*rds.DescribeDBProxyTargetGroupsOutput) 3638 ret1, _ := ret[1].(error) 3639 return ret0, ret1 3640 } 3641 3642 // DescribeDBProxyTargetGroups indicates an expected call of DescribeDBProxyTargetGroups 3643 func (mr *MockRDSAPIMockRecorder) DescribeDBProxyTargetGroups(arg0 interface{}) *gomock.Call { 3644 mr.mock.ctrl.T.Helper() 3645 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDBProxyTargetGroups", reflect.TypeOf((*MockRDSAPI)(nil).DescribeDBProxyTargetGroups), arg0) 3646 } 3647 3648 // DescribeDBProxyTargetGroupsPages mocks base method 3649 func (m *MockRDSAPI) DescribeDBProxyTargetGroupsPages(arg0 *rds.DescribeDBProxyTargetGroupsInput, arg1 func(*rds.DescribeDBProxyTargetGroupsOutput, bool) bool) error { 3650 m.ctrl.T.Helper() 3651 ret := m.ctrl.Call(m, "DescribeDBProxyTargetGroupsPages", arg0, arg1) 3652 ret0, _ := ret[0].(error) 3653 return ret0 3654 } 3655 3656 // DescribeDBProxyTargetGroupsPages indicates an expected call of DescribeDBProxyTargetGroupsPages 3657 func (mr *MockRDSAPIMockRecorder) DescribeDBProxyTargetGroupsPages(arg0, arg1 interface{}) *gomock.Call { 3658 mr.mock.ctrl.T.Helper() 3659 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDBProxyTargetGroupsPages", reflect.TypeOf((*MockRDSAPI)(nil).DescribeDBProxyTargetGroupsPages), arg0, arg1) 3660 } 3661 3662 // DescribeDBProxyTargetGroupsPagesWithContext mocks base method 3663 func (m *MockRDSAPI) DescribeDBProxyTargetGroupsPagesWithContext(arg0 context.Context, arg1 *rds.DescribeDBProxyTargetGroupsInput, arg2 func(*rds.DescribeDBProxyTargetGroupsOutput, bool) bool, arg3 ...request.Option) error { 3664 m.ctrl.T.Helper() 3665 varargs := []interface{}{arg0, arg1, arg2} 3666 for _, a := range arg3 { 3667 varargs = append(varargs, a) 3668 } 3669 ret := m.ctrl.Call(m, "DescribeDBProxyTargetGroupsPagesWithContext", varargs...) 3670 ret0, _ := ret[0].(error) 3671 return ret0 3672 } 3673 3674 // DescribeDBProxyTargetGroupsPagesWithContext indicates an expected call of DescribeDBProxyTargetGroupsPagesWithContext 3675 func (mr *MockRDSAPIMockRecorder) DescribeDBProxyTargetGroupsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 3676 mr.mock.ctrl.T.Helper() 3677 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 3678 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDBProxyTargetGroupsPagesWithContext", reflect.TypeOf((*MockRDSAPI)(nil).DescribeDBProxyTargetGroupsPagesWithContext), varargs...) 3679 } 3680 3681 // DescribeDBProxyTargetGroupsRequest mocks base method 3682 func (m *MockRDSAPI) DescribeDBProxyTargetGroupsRequest(arg0 *rds.DescribeDBProxyTargetGroupsInput) (*request.Request, *rds.DescribeDBProxyTargetGroupsOutput) { 3683 m.ctrl.T.Helper() 3684 ret := m.ctrl.Call(m, "DescribeDBProxyTargetGroupsRequest", arg0) 3685 ret0, _ := ret[0].(*request.Request) 3686 ret1, _ := ret[1].(*rds.DescribeDBProxyTargetGroupsOutput) 3687 return ret0, ret1 3688 } 3689 3690 // DescribeDBProxyTargetGroupsRequest indicates an expected call of DescribeDBProxyTargetGroupsRequest 3691 func (mr *MockRDSAPIMockRecorder) DescribeDBProxyTargetGroupsRequest(arg0 interface{}) *gomock.Call { 3692 mr.mock.ctrl.T.Helper() 3693 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDBProxyTargetGroupsRequest", reflect.TypeOf((*MockRDSAPI)(nil).DescribeDBProxyTargetGroupsRequest), arg0) 3694 } 3695 3696 // DescribeDBProxyTargetGroupsWithContext mocks base method 3697 func (m *MockRDSAPI) DescribeDBProxyTargetGroupsWithContext(arg0 context.Context, arg1 *rds.DescribeDBProxyTargetGroupsInput, arg2 ...request.Option) (*rds.DescribeDBProxyTargetGroupsOutput, error) { 3698 m.ctrl.T.Helper() 3699 varargs := []interface{}{arg0, arg1} 3700 for _, a := range arg2 { 3701 varargs = append(varargs, a) 3702 } 3703 ret := m.ctrl.Call(m, "DescribeDBProxyTargetGroupsWithContext", varargs...) 3704 ret0, _ := ret[0].(*rds.DescribeDBProxyTargetGroupsOutput) 3705 ret1, _ := ret[1].(error) 3706 return ret0, ret1 3707 } 3708 3709 // DescribeDBProxyTargetGroupsWithContext indicates an expected call of DescribeDBProxyTargetGroupsWithContext 3710 func (mr *MockRDSAPIMockRecorder) DescribeDBProxyTargetGroupsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 3711 mr.mock.ctrl.T.Helper() 3712 varargs := append([]interface{}{arg0, arg1}, arg2...) 3713 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDBProxyTargetGroupsWithContext", reflect.TypeOf((*MockRDSAPI)(nil).DescribeDBProxyTargetGroupsWithContext), varargs...) 3714 } 3715 3716 // DescribeDBProxyTargets mocks base method 3717 func (m *MockRDSAPI) DescribeDBProxyTargets(arg0 *rds.DescribeDBProxyTargetsInput) (*rds.DescribeDBProxyTargetsOutput, error) { 3718 m.ctrl.T.Helper() 3719 ret := m.ctrl.Call(m, "DescribeDBProxyTargets", arg0) 3720 ret0, _ := ret[0].(*rds.DescribeDBProxyTargetsOutput) 3721 ret1, _ := ret[1].(error) 3722 return ret0, ret1 3723 } 3724 3725 // DescribeDBProxyTargets indicates an expected call of DescribeDBProxyTargets 3726 func (mr *MockRDSAPIMockRecorder) DescribeDBProxyTargets(arg0 interface{}) *gomock.Call { 3727 mr.mock.ctrl.T.Helper() 3728 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDBProxyTargets", reflect.TypeOf((*MockRDSAPI)(nil).DescribeDBProxyTargets), arg0) 3729 } 3730 3731 // DescribeDBProxyTargetsPages mocks base method 3732 func (m *MockRDSAPI) DescribeDBProxyTargetsPages(arg0 *rds.DescribeDBProxyTargetsInput, arg1 func(*rds.DescribeDBProxyTargetsOutput, bool) bool) error { 3733 m.ctrl.T.Helper() 3734 ret := m.ctrl.Call(m, "DescribeDBProxyTargetsPages", arg0, arg1) 3735 ret0, _ := ret[0].(error) 3736 return ret0 3737 } 3738 3739 // DescribeDBProxyTargetsPages indicates an expected call of DescribeDBProxyTargetsPages 3740 func (mr *MockRDSAPIMockRecorder) DescribeDBProxyTargetsPages(arg0, arg1 interface{}) *gomock.Call { 3741 mr.mock.ctrl.T.Helper() 3742 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDBProxyTargetsPages", reflect.TypeOf((*MockRDSAPI)(nil).DescribeDBProxyTargetsPages), arg0, arg1) 3743 } 3744 3745 // DescribeDBProxyTargetsPagesWithContext mocks base method 3746 func (m *MockRDSAPI) DescribeDBProxyTargetsPagesWithContext(arg0 context.Context, arg1 *rds.DescribeDBProxyTargetsInput, arg2 func(*rds.DescribeDBProxyTargetsOutput, bool) bool, arg3 ...request.Option) error { 3747 m.ctrl.T.Helper() 3748 varargs := []interface{}{arg0, arg1, arg2} 3749 for _, a := range arg3 { 3750 varargs = append(varargs, a) 3751 } 3752 ret := m.ctrl.Call(m, "DescribeDBProxyTargetsPagesWithContext", varargs...) 3753 ret0, _ := ret[0].(error) 3754 return ret0 3755 } 3756 3757 // DescribeDBProxyTargetsPagesWithContext indicates an expected call of DescribeDBProxyTargetsPagesWithContext 3758 func (mr *MockRDSAPIMockRecorder) DescribeDBProxyTargetsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 3759 mr.mock.ctrl.T.Helper() 3760 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 3761 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDBProxyTargetsPagesWithContext", reflect.TypeOf((*MockRDSAPI)(nil).DescribeDBProxyTargetsPagesWithContext), varargs...) 3762 } 3763 3764 // DescribeDBProxyTargetsRequest mocks base method 3765 func (m *MockRDSAPI) DescribeDBProxyTargetsRequest(arg0 *rds.DescribeDBProxyTargetsInput) (*request.Request, *rds.DescribeDBProxyTargetsOutput) { 3766 m.ctrl.T.Helper() 3767 ret := m.ctrl.Call(m, "DescribeDBProxyTargetsRequest", arg0) 3768 ret0, _ := ret[0].(*request.Request) 3769 ret1, _ := ret[1].(*rds.DescribeDBProxyTargetsOutput) 3770 return ret0, ret1 3771 } 3772 3773 // DescribeDBProxyTargetsRequest indicates an expected call of DescribeDBProxyTargetsRequest 3774 func (mr *MockRDSAPIMockRecorder) DescribeDBProxyTargetsRequest(arg0 interface{}) *gomock.Call { 3775 mr.mock.ctrl.T.Helper() 3776 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDBProxyTargetsRequest", reflect.TypeOf((*MockRDSAPI)(nil).DescribeDBProxyTargetsRequest), arg0) 3777 } 3778 3779 // DescribeDBProxyTargetsWithContext mocks base method 3780 func (m *MockRDSAPI) DescribeDBProxyTargetsWithContext(arg0 context.Context, arg1 *rds.DescribeDBProxyTargetsInput, arg2 ...request.Option) (*rds.DescribeDBProxyTargetsOutput, error) { 3781 m.ctrl.T.Helper() 3782 varargs := []interface{}{arg0, arg1} 3783 for _, a := range arg2 { 3784 varargs = append(varargs, a) 3785 } 3786 ret := m.ctrl.Call(m, "DescribeDBProxyTargetsWithContext", varargs...) 3787 ret0, _ := ret[0].(*rds.DescribeDBProxyTargetsOutput) 3788 ret1, _ := ret[1].(error) 3789 return ret0, ret1 3790 } 3791 3792 // DescribeDBProxyTargetsWithContext indicates an expected call of DescribeDBProxyTargetsWithContext 3793 func (mr *MockRDSAPIMockRecorder) DescribeDBProxyTargetsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 3794 mr.mock.ctrl.T.Helper() 3795 varargs := append([]interface{}{arg0, arg1}, arg2...) 3796 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDBProxyTargetsWithContext", reflect.TypeOf((*MockRDSAPI)(nil).DescribeDBProxyTargetsWithContext), varargs...) 3797 } 3798 3799 // DescribeDBSecurityGroups mocks base method 3800 func (m *MockRDSAPI) DescribeDBSecurityGroups(arg0 *rds.DescribeDBSecurityGroupsInput) (*rds.DescribeDBSecurityGroupsOutput, error) { 3801 m.ctrl.T.Helper() 3802 ret := m.ctrl.Call(m, "DescribeDBSecurityGroups", arg0) 3803 ret0, _ := ret[0].(*rds.DescribeDBSecurityGroupsOutput) 3804 ret1, _ := ret[1].(error) 3805 return ret0, ret1 3806 } 3807 3808 // DescribeDBSecurityGroups indicates an expected call of DescribeDBSecurityGroups 3809 func (mr *MockRDSAPIMockRecorder) DescribeDBSecurityGroups(arg0 interface{}) *gomock.Call { 3810 mr.mock.ctrl.T.Helper() 3811 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDBSecurityGroups", reflect.TypeOf((*MockRDSAPI)(nil).DescribeDBSecurityGroups), arg0) 3812 } 3813 3814 // DescribeDBSecurityGroupsPages mocks base method 3815 func (m *MockRDSAPI) DescribeDBSecurityGroupsPages(arg0 *rds.DescribeDBSecurityGroupsInput, arg1 func(*rds.DescribeDBSecurityGroupsOutput, bool) bool) error { 3816 m.ctrl.T.Helper() 3817 ret := m.ctrl.Call(m, "DescribeDBSecurityGroupsPages", arg0, arg1) 3818 ret0, _ := ret[0].(error) 3819 return ret0 3820 } 3821 3822 // DescribeDBSecurityGroupsPages indicates an expected call of DescribeDBSecurityGroupsPages 3823 func (mr *MockRDSAPIMockRecorder) DescribeDBSecurityGroupsPages(arg0, arg1 interface{}) *gomock.Call { 3824 mr.mock.ctrl.T.Helper() 3825 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDBSecurityGroupsPages", reflect.TypeOf((*MockRDSAPI)(nil).DescribeDBSecurityGroupsPages), arg0, arg1) 3826 } 3827 3828 // DescribeDBSecurityGroupsPagesWithContext mocks base method 3829 func (m *MockRDSAPI) DescribeDBSecurityGroupsPagesWithContext(arg0 context.Context, arg1 *rds.DescribeDBSecurityGroupsInput, arg2 func(*rds.DescribeDBSecurityGroupsOutput, bool) bool, arg3 ...request.Option) error { 3830 m.ctrl.T.Helper() 3831 varargs := []interface{}{arg0, arg1, arg2} 3832 for _, a := range arg3 { 3833 varargs = append(varargs, a) 3834 } 3835 ret := m.ctrl.Call(m, "DescribeDBSecurityGroupsPagesWithContext", varargs...) 3836 ret0, _ := ret[0].(error) 3837 return ret0 3838 } 3839 3840 // DescribeDBSecurityGroupsPagesWithContext indicates an expected call of DescribeDBSecurityGroupsPagesWithContext 3841 func (mr *MockRDSAPIMockRecorder) DescribeDBSecurityGroupsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 3842 mr.mock.ctrl.T.Helper() 3843 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 3844 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDBSecurityGroupsPagesWithContext", reflect.TypeOf((*MockRDSAPI)(nil).DescribeDBSecurityGroupsPagesWithContext), varargs...) 3845 } 3846 3847 // DescribeDBSecurityGroupsRequest mocks base method 3848 func (m *MockRDSAPI) DescribeDBSecurityGroupsRequest(arg0 *rds.DescribeDBSecurityGroupsInput) (*request.Request, *rds.DescribeDBSecurityGroupsOutput) { 3849 m.ctrl.T.Helper() 3850 ret := m.ctrl.Call(m, "DescribeDBSecurityGroupsRequest", arg0) 3851 ret0, _ := ret[0].(*request.Request) 3852 ret1, _ := ret[1].(*rds.DescribeDBSecurityGroupsOutput) 3853 return ret0, ret1 3854 } 3855 3856 // DescribeDBSecurityGroupsRequest indicates an expected call of DescribeDBSecurityGroupsRequest 3857 func (mr *MockRDSAPIMockRecorder) DescribeDBSecurityGroupsRequest(arg0 interface{}) *gomock.Call { 3858 mr.mock.ctrl.T.Helper() 3859 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDBSecurityGroupsRequest", reflect.TypeOf((*MockRDSAPI)(nil).DescribeDBSecurityGroupsRequest), arg0) 3860 } 3861 3862 // DescribeDBSecurityGroupsWithContext mocks base method 3863 func (m *MockRDSAPI) DescribeDBSecurityGroupsWithContext(arg0 context.Context, arg1 *rds.DescribeDBSecurityGroupsInput, arg2 ...request.Option) (*rds.DescribeDBSecurityGroupsOutput, error) { 3864 m.ctrl.T.Helper() 3865 varargs := []interface{}{arg0, arg1} 3866 for _, a := range arg2 { 3867 varargs = append(varargs, a) 3868 } 3869 ret := m.ctrl.Call(m, "DescribeDBSecurityGroupsWithContext", varargs...) 3870 ret0, _ := ret[0].(*rds.DescribeDBSecurityGroupsOutput) 3871 ret1, _ := ret[1].(error) 3872 return ret0, ret1 3873 } 3874 3875 // DescribeDBSecurityGroupsWithContext indicates an expected call of DescribeDBSecurityGroupsWithContext 3876 func (mr *MockRDSAPIMockRecorder) DescribeDBSecurityGroupsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 3877 mr.mock.ctrl.T.Helper() 3878 varargs := append([]interface{}{arg0, arg1}, arg2...) 3879 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDBSecurityGroupsWithContext", reflect.TypeOf((*MockRDSAPI)(nil).DescribeDBSecurityGroupsWithContext), varargs...) 3880 } 3881 3882 // DescribeDBSnapshotAttributes mocks base method 3883 func (m *MockRDSAPI) DescribeDBSnapshotAttributes(arg0 *rds.DescribeDBSnapshotAttributesInput) (*rds.DescribeDBSnapshotAttributesOutput, error) { 3884 m.ctrl.T.Helper() 3885 ret := m.ctrl.Call(m, "DescribeDBSnapshotAttributes", arg0) 3886 ret0, _ := ret[0].(*rds.DescribeDBSnapshotAttributesOutput) 3887 ret1, _ := ret[1].(error) 3888 return ret0, ret1 3889 } 3890 3891 // DescribeDBSnapshotAttributes indicates an expected call of DescribeDBSnapshotAttributes 3892 func (mr *MockRDSAPIMockRecorder) DescribeDBSnapshotAttributes(arg0 interface{}) *gomock.Call { 3893 mr.mock.ctrl.T.Helper() 3894 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDBSnapshotAttributes", reflect.TypeOf((*MockRDSAPI)(nil).DescribeDBSnapshotAttributes), arg0) 3895 } 3896 3897 // DescribeDBSnapshotAttributesRequest mocks base method 3898 func (m *MockRDSAPI) DescribeDBSnapshotAttributesRequest(arg0 *rds.DescribeDBSnapshotAttributesInput) (*request.Request, *rds.DescribeDBSnapshotAttributesOutput) { 3899 m.ctrl.T.Helper() 3900 ret := m.ctrl.Call(m, "DescribeDBSnapshotAttributesRequest", arg0) 3901 ret0, _ := ret[0].(*request.Request) 3902 ret1, _ := ret[1].(*rds.DescribeDBSnapshotAttributesOutput) 3903 return ret0, ret1 3904 } 3905 3906 // DescribeDBSnapshotAttributesRequest indicates an expected call of DescribeDBSnapshotAttributesRequest 3907 func (mr *MockRDSAPIMockRecorder) DescribeDBSnapshotAttributesRequest(arg0 interface{}) *gomock.Call { 3908 mr.mock.ctrl.T.Helper() 3909 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDBSnapshotAttributesRequest", reflect.TypeOf((*MockRDSAPI)(nil).DescribeDBSnapshotAttributesRequest), arg0) 3910 } 3911 3912 // DescribeDBSnapshotAttributesWithContext mocks base method 3913 func (m *MockRDSAPI) DescribeDBSnapshotAttributesWithContext(arg0 context.Context, arg1 *rds.DescribeDBSnapshotAttributesInput, arg2 ...request.Option) (*rds.DescribeDBSnapshotAttributesOutput, error) { 3914 m.ctrl.T.Helper() 3915 varargs := []interface{}{arg0, arg1} 3916 for _, a := range arg2 { 3917 varargs = append(varargs, a) 3918 } 3919 ret := m.ctrl.Call(m, "DescribeDBSnapshotAttributesWithContext", varargs...) 3920 ret0, _ := ret[0].(*rds.DescribeDBSnapshotAttributesOutput) 3921 ret1, _ := ret[1].(error) 3922 return ret0, ret1 3923 } 3924 3925 // DescribeDBSnapshotAttributesWithContext indicates an expected call of DescribeDBSnapshotAttributesWithContext 3926 func (mr *MockRDSAPIMockRecorder) DescribeDBSnapshotAttributesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 3927 mr.mock.ctrl.T.Helper() 3928 varargs := append([]interface{}{arg0, arg1}, arg2...) 3929 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDBSnapshotAttributesWithContext", reflect.TypeOf((*MockRDSAPI)(nil).DescribeDBSnapshotAttributesWithContext), varargs...) 3930 } 3931 3932 // DescribeDBSnapshots mocks base method 3933 func (m *MockRDSAPI) DescribeDBSnapshots(arg0 *rds.DescribeDBSnapshotsInput) (*rds.DescribeDBSnapshotsOutput, error) { 3934 m.ctrl.T.Helper() 3935 ret := m.ctrl.Call(m, "DescribeDBSnapshots", arg0) 3936 ret0, _ := ret[0].(*rds.DescribeDBSnapshotsOutput) 3937 ret1, _ := ret[1].(error) 3938 return ret0, ret1 3939 } 3940 3941 // DescribeDBSnapshots indicates an expected call of DescribeDBSnapshots 3942 func (mr *MockRDSAPIMockRecorder) DescribeDBSnapshots(arg0 interface{}) *gomock.Call { 3943 mr.mock.ctrl.T.Helper() 3944 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDBSnapshots", reflect.TypeOf((*MockRDSAPI)(nil).DescribeDBSnapshots), arg0) 3945 } 3946 3947 // DescribeDBSnapshotsPages mocks base method 3948 func (m *MockRDSAPI) DescribeDBSnapshotsPages(arg0 *rds.DescribeDBSnapshotsInput, arg1 func(*rds.DescribeDBSnapshotsOutput, bool) bool) error { 3949 m.ctrl.T.Helper() 3950 ret := m.ctrl.Call(m, "DescribeDBSnapshotsPages", arg0, arg1) 3951 ret0, _ := ret[0].(error) 3952 return ret0 3953 } 3954 3955 // DescribeDBSnapshotsPages indicates an expected call of DescribeDBSnapshotsPages 3956 func (mr *MockRDSAPIMockRecorder) DescribeDBSnapshotsPages(arg0, arg1 interface{}) *gomock.Call { 3957 mr.mock.ctrl.T.Helper() 3958 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDBSnapshotsPages", reflect.TypeOf((*MockRDSAPI)(nil).DescribeDBSnapshotsPages), arg0, arg1) 3959 } 3960 3961 // DescribeDBSnapshotsPagesWithContext mocks base method 3962 func (m *MockRDSAPI) DescribeDBSnapshotsPagesWithContext(arg0 context.Context, arg1 *rds.DescribeDBSnapshotsInput, arg2 func(*rds.DescribeDBSnapshotsOutput, bool) bool, arg3 ...request.Option) error { 3963 m.ctrl.T.Helper() 3964 varargs := []interface{}{arg0, arg1, arg2} 3965 for _, a := range arg3 { 3966 varargs = append(varargs, a) 3967 } 3968 ret := m.ctrl.Call(m, "DescribeDBSnapshotsPagesWithContext", varargs...) 3969 ret0, _ := ret[0].(error) 3970 return ret0 3971 } 3972 3973 // DescribeDBSnapshotsPagesWithContext indicates an expected call of DescribeDBSnapshotsPagesWithContext 3974 func (mr *MockRDSAPIMockRecorder) DescribeDBSnapshotsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 3975 mr.mock.ctrl.T.Helper() 3976 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 3977 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDBSnapshotsPagesWithContext", reflect.TypeOf((*MockRDSAPI)(nil).DescribeDBSnapshotsPagesWithContext), varargs...) 3978 } 3979 3980 // DescribeDBSnapshotsRequest mocks base method 3981 func (m *MockRDSAPI) DescribeDBSnapshotsRequest(arg0 *rds.DescribeDBSnapshotsInput) (*request.Request, *rds.DescribeDBSnapshotsOutput) { 3982 m.ctrl.T.Helper() 3983 ret := m.ctrl.Call(m, "DescribeDBSnapshotsRequest", arg0) 3984 ret0, _ := ret[0].(*request.Request) 3985 ret1, _ := ret[1].(*rds.DescribeDBSnapshotsOutput) 3986 return ret0, ret1 3987 } 3988 3989 // DescribeDBSnapshotsRequest indicates an expected call of DescribeDBSnapshotsRequest 3990 func (mr *MockRDSAPIMockRecorder) DescribeDBSnapshotsRequest(arg0 interface{}) *gomock.Call { 3991 mr.mock.ctrl.T.Helper() 3992 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDBSnapshotsRequest", reflect.TypeOf((*MockRDSAPI)(nil).DescribeDBSnapshotsRequest), arg0) 3993 } 3994 3995 // DescribeDBSnapshotsWithContext mocks base method 3996 func (m *MockRDSAPI) DescribeDBSnapshotsWithContext(arg0 context.Context, arg1 *rds.DescribeDBSnapshotsInput, arg2 ...request.Option) (*rds.DescribeDBSnapshotsOutput, error) { 3997 m.ctrl.T.Helper() 3998 varargs := []interface{}{arg0, arg1} 3999 for _, a := range arg2 { 4000 varargs = append(varargs, a) 4001 } 4002 ret := m.ctrl.Call(m, "DescribeDBSnapshotsWithContext", varargs...) 4003 ret0, _ := ret[0].(*rds.DescribeDBSnapshotsOutput) 4004 ret1, _ := ret[1].(error) 4005 return ret0, ret1 4006 } 4007 4008 // DescribeDBSnapshotsWithContext indicates an expected call of DescribeDBSnapshotsWithContext 4009 func (mr *MockRDSAPIMockRecorder) DescribeDBSnapshotsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 4010 mr.mock.ctrl.T.Helper() 4011 varargs := append([]interface{}{arg0, arg1}, arg2...) 4012 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDBSnapshotsWithContext", reflect.TypeOf((*MockRDSAPI)(nil).DescribeDBSnapshotsWithContext), varargs...) 4013 } 4014 4015 // DescribeDBSubnetGroups mocks base method 4016 func (m *MockRDSAPI) DescribeDBSubnetGroups(arg0 *rds.DescribeDBSubnetGroupsInput) (*rds.DescribeDBSubnetGroupsOutput, error) { 4017 m.ctrl.T.Helper() 4018 ret := m.ctrl.Call(m, "DescribeDBSubnetGroups", arg0) 4019 ret0, _ := ret[0].(*rds.DescribeDBSubnetGroupsOutput) 4020 ret1, _ := ret[1].(error) 4021 return ret0, ret1 4022 } 4023 4024 // DescribeDBSubnetGroups indicates an expected call of DescribeDBSubnetGroups 4025 func (mr *MockRDSAPIMockRecorder) DescribeDBSubnetGroups(arg0 interface{}) *gomock.Call { 4026 mr.mock.ctrl.T.Helper() 4027 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDBSubnetGroups", reflect.TypeOf((*MockRDSAPI)(nil).DescribeDBSubnetGroups), arg0) 4028 } 4029 4030 // DescribeDBSubnetGroupsPages mocks base method 4031 func (m *MockRDSAPI) DescribeDBSubnetGroupsPages(arg0 *rds.DescribeDBSubnetGroupsInput, arg1 func(*rds.DescribeDBSubnetGroupsOutput, bool) bool) error { 4032 m.ctrl.T.Helper() 4033 ret := m.ctrl.Call(m, "DescribeDBSubnetGroupsPages", arg0, arg1) 4034 ret0, _ := ret[0].(error) 4035 return ret0 4036 } 4037 4038 // DescribeDBSubnetGroupsPages indicates an expected call of DescribeDBSubnetGroupsPages 4039 func (mr *MockRDSAPIMockRecorder) DescribeDBSubnetGroupsPages(arg0, arg1 interface{}) *gomock.Call { 4040 mr.mock.ctrl.T.Helper() 4041 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDBSubnetGroupsPages", reflect.TypeOf((*MockRDSAPI)(nil).DescribeDBSubnetGroupsPages), arg0, arg1) 4042 } 4043 4044 // DescribeDBSubnetGroupsPagesWithContext mocks base method 4045 func (m *MockRDSAPI) DescribeDBSubnetGroupsPagesWithContext(arg0 context.Context, arg1 *rds.DescribeDBSubnetGroupsInput, arg2 func(*rds.DescribeDBSubnetGroupsOutput, bool) bool, arg3 ...request.Option) error { 4046 m.ctrl.T.Helper() 4047 varargs := []interface{}{arg0, arg1, arg2} 4048 for _, a := range arg3 { 4049 varargs = append(varargs, a) 4050 } 4051 ret := m.ctrl.Call(m, "DescribeDBSubnetGroupsPagesWithContext", varargs...) 4052 ret0, _ := ret[0].(error) 4053 return ret0 4054 } 4055 4056 // DescribeDBSubnetGroupsPagesWithContext indicates an expected call of DescribeDBSubnetGroupsPagesWithContext 4057 func (mr *MockRDSAPIMockRecorder) DescribeDBSubnetGroupsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 4058 mr.mock.ctrl.T.Helper() 4059 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 4060 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDBSubnetGroupsPagesWithContext", reflect.TypeOf((*MockRDSAPI)(nil).DescribeDBSubnetGroupsPagesWithContext), varargs...) 4061 } 4062 4063 // DescribeDBSubnetGroupsRequest mocks base method 4064 func (m *MockRDSAPI) DescribeDBSubnetGroupsRequest(arg0 *rds.DescribeDBSubnetGroupsInput) (*request.Request, *rds.DescribeDBSubnetGroupsOutput) { 4065 m.ctrl.T.Helper() 4066 ret := m.ctrl.Call(m, "DescribeDBSubnetGroupsRequest", arg0) 4067 ret0, _ := ret[0].(*request.Request) 4068 ret1, _ := ret[1].(*rds.DescribeDBSubnetGroupsOutput) 4069 return ret0, ret1 4070 } 4071 4072 // DescribeDBSubnetGroupsRequest indicates an expected call of DescribeDBSubnetGroupsRequest 4073 func (mr *MockRDSAPIMockRecorder) DescribeDBSubnetGroupsRequest(arg0 interface{}) *gomock.Call { 4074 mr.mock.ctrl.T.Helper() 4075 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDBSubnetGroupsRequest", reflect.TypeOf((*MockRDSAPI)(nil).DescribeDBSubnetGroupsRequest), arg0) 4076 } 4077 4078 // DescribeDBSubnetGroupsWithContext mocks base method 4079 func (m *MockRDSAPI) DescribeDBSubnetGroupsWithContext(arg0 context.Context, arg1 *rds.DescribeDBSubnetGroupsInput, arg2 ...request.Option) (*rds.DescribeDBSubnetGroupsOutput, error) { 4080 m.ctrl.T.Helper() 4081 varargs := []interface{}{arg0, arg1} 4082 for _, a := range arg2 { 4083 varargs = append(varargs, a) 4084 } 4085 ret := m.ctrl.Call(m, "DescribeDBSubnetGroupsWithContext", varargs...) 4086 ret0, _ := ret[0].(*rds.DescribeDBSubnetGroupsOutput) 4087 ret1, _ := ret[1].(error) 4088 return ret0, ret1 4089 } 4090 4091 // DescribeDBSubnetGroupsWithContext indicates an expected call of DescribeDBSubnetGroupsWithContext 4092 func (mr *MockRDSAPIMockRecorder) DescribeDBSubnetGroupsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 4093 mr.mock.ctrl.T.Helper() 4094 varargs := append([]interface{}{arg0, arg1}, arg2...) 4095 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDBSubnetGroupsWithContext", reflect.TypeOf((*MockRDSAPI)(nil).DescribeDBSubnetGroupsWithContext), varargs...) 4096 } 4097 4098 // DescribeEngineDefaultClusterParameters mocks base method 4099 func (m *MockRDSAPI) DescribeEngineDefaultClusterParameters(arg0 *rds.DescribeEngineDefaultClusterParametersInput) (*rds.DescribeEngineDefaultClusterParametersOutput, error) { 4100 m.ctrl.T.Helper() 4101 ret := m.ctrl.Call(m, "DescribeEngineDefaultClusterParameters", arg0) 4102 ret0, _ := ret[0].(*rds.DescribeEngineDefaultClusterParametersOutput) 4103 ret1, _ := ret[1].(error) 4104 return ret0, ret1 4105 } 4106 4107 // DescribeEngineDefaultClusterParameters indicates an expected call of DescribeEngineDefaultClusterParameters 4108 func (mr *MockRDSAPIMockRecorder) DescribeEngineDefaultClusterParameters(arg0 interface{}) *gomock.Call { 4109 mr.mock.ctrl.T.Helper() 4110 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEngineDefaultClusterParameters", reflect.TypeOf((*MockRDSAPI)(nil).DescribeEngineDefaultClusterParameters), arg0) 4111 } 4112 4113 // DescribeEngineDefaultClusterParametersRequest mocks base method 4114 func (m *MockRDSAPI) DescribeEngineDefaultClusterParametersRequest(arg0 *rds.DescribeEngineDefaultClusterParametersInput) (*request.Request, *rds.DescribeEngineDefaultClusterParametersOutput) { 4115 m.ctrl.T.Helper() 4116 ret := m.ctrl.Call(m, "DescribeEngineDefaultClusterParametersRequest", arg0) 4117 ret0, _ := ret[0].(*request.Request) 4118 ret1, _ := ret[1].(*rds.DescribeEngineDefaultClusterParametersOutput) 4119 return ret0, ret1 4120 } 4121 4122 // DescribeEngineDefaultClusterParametersRequest indicates an expected call of DescribeEngineDefaultClusterParametersRequest 4123 func (mr *MockRDSAPIMockRecorder) DescribeEngineDefaultClusterParametersRequest(arg0 interface{}) *gomock.Call { 4124 mr.mock.ctrl.T.Helper() 4125 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEngineDefaultClusterParametersRequest", reflect.TypeOf((*MockRDSAPI)(nil).DescribeEngineDefaultClusterParametersRequest), arg0) 4126 } 4127 4128 // DescribeEngineDefaultClusterParametersWithContext mocks base method 4129 func (m *MockRDSAPI) DescribeEngineDefaultClusterParametersWithContext(arg0 context.Context, arg1 *rds.DescribeEngineDefaultClusterParametersInput, arg2 ...request.Option) (*rds.DescribeEngineDefaultClusterParametersOutput, error) { 4130 m.ctrl.T.Helper() 4131 varargs := []interface{}{arg0, arg1} 4132 for _, a := range arg2 { 4133 varargs = append(varargs, a) 4134 } 4135 ret := m.ctrl.Call(m, "DescribeEngineDefaultClusterParametersWithContext", varargs...) 4136 ret0, _ := ret[0].(*rds.DescribeEngineDefaultClusterParametersOutput) 4137 ret1, _ := ret[1].(error) 4138 return ret0, ret1 4139 } 4140 4141 // DescribeEngineDefaultClusterParametersWithContext indicates an expected call of DescribeEngineDefaultClusterParametersWithContext 4142 func (mr *MockRDSAPIMockRecorder) DescribeEngineDefaultClusterParametersWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 4143 mr.mock.ctrl.T.Helper() 4144 varargs := append([]interface{}{arg0, arg1}, arg2...) 4145 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEngineDefaultClusterParametersWithContext", reflect.TypeOf((*MockRDSAPI)(nil).DescribeEngineDefaultClusterParametersWithContext), varargs...) 4146 } 4147 4148 // DescribeEngineDefaultParameters mocks base method 4149 func (m *MockRDSAPI) DescribeEngineDefaultParameters(arg0 *rds.DescribeEngineDefaultParametersInput) (*rds.DescribeEngineDefaultParametersOutput, error) { 4150 m.ctrl.T.Helper() 4151 ret := m.ctrl.Call(m, "DescribeEngineDefaultParameters", arg0) 4152 ret0, _ := ret[0].(*rds.DescribeEngineDefaultParametersOutput) 4153 ret1, _ := ret[1].(error) 4154 return ret0, ret1 4155 } 4156 4157 // DescribeEngineDefaultParameters indicates an expected call of DescribeEngineDefaultParameters 4158 func (mr *MockRDSAPIMockRecorder) DescribeEngineDefaultParameters(arg0 interface{}) *gomock.Call { 4159 mr.mock.ctrl.T.Helper() 4160 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEngineDefaultParameters", reflect.TypeOf((*MockRDSAPI)(nil).DescribeEngineDefaultParameters), arg0) 4161 } 4162 4163 // DescribeEngineDefaultParametersPages mocks base method 4164 func (m *MockRDSAPI) DescribeEngineDefaultParametersPages(arg0 *rds.DescribeEngineDefaultParametersInput, arg1 func(*rds.DescribeEngineDefaultParametersOutput, bool) bool) error { 4165 m.ctrl.T.Helper() 4166 ret := m.ctrl.Call(m, "DescribeEngineDefaultParametersPages", arg0, arg1) 4167 ret0, _ := ret[0].(error) 4168 return ret0 4169 } 4170 4171 // DescribeEngineDefaultParametersPages indicates an expected call of DescribeEngineDefaultParametersPages 4172 func (mr *MockRDSAPIMockRecorder) DescribeEngineDefaultParametersPages(arg0, arg1 interface{}) *gomock.Call { 4173 mr.mock.ctrl.T.Helper() 4174 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEngineDefaultParametersPages", reflect.TypeOf((*MockRDSAPI)(nil).DescribeEngineDefaultParametersPages), arg0, arg1) 4175 } 4176 4177 // DescribeEngineDefaultParametersPagesWithContext mocks base method 4178 func (m *MockRDSAPI) DescribeEngineDefaultParametersPagesWithContext(arg0 context.Context, arg1 *rds.DescribeEngineDefaultParametersInput, arg2 func(*rds.DescribeEngineDefaultParametersOutput, bool) bool, arg3 ...request.Option) error { 4179 m.ctrl.T.Helper() 4180 varargs := []interface{}{arg0, arg1, arg2} 4181 for _, a := range arg3 { 4182 varargs = append(varargs, a) 4183 } 4184 ret := m.ctrl.Call(m, "DescribeEngineDefaultParametersPagesWithContext", varargs...) 4185 ret0, _ := ret[0].(error) 4186 return ret0 4187 } 4188 4189 // DescribeEngineDefaultParametersPagesWithContext indicates an expected call of DescribeEngineDefaultParametersPagesWithContext 4190 func (mr *MockRDSAPIMockRecorder) DescribeEngineDefaultParametersPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 4191 mr.mock.ctrl.T.Helper() 4192 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 4193 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEngineDefaultParametersPagesWithContext", reflect.TypeOf((*MockRDSAPI)(nil).DescribeEngineDefaultParametersPagesWithContext), varargs...) 4194 } 4195 4196 // DescribeEngineDefaultParametersRequest mocks base method 4197 func (m *MockRDSAPI) DescribeEngineDefaultParametersRequest(arg0 *rds.DescribeEngineDefaultParametersInput) (*request.Request, *rds.DescribeEngineDefaultParametersOutput) { 4198 m.ctrl.T.Helper() 4199 ret := m.ctrl.Call(m, "DescribeEngineDefaultParametersRequest", arg0) 4200 ret0, _ := ret[0].(*request.Request) 4201 ret1, _ := ret[1].(*rds.DescribeEngineDefaultParametersOutput) 4202 return ret0, ret1 4203 } 4204 4205 // DescribeEngineDefaultParametersRequest indicates an expected call of DescribeEngineDefaultParametersRequest 4206 func (mr *MockRDSAPIMockRecorder) DescribeEngineDefaultParametersRequest(arg0 interface{}) *gomock.Call { 4207 mr.mock.ctrl.T.Helper() 4208 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEngineDefaultParametersRequest", reflect.TypeOf((*MockRDSAPI)(nil).DescribeEngineDefaultParametersRequest), arg0) 4209 } 4210 4211 // DescribeEngineDefaultParametersWithContext mocks base method 4212 func (m *MockRDSAPI) DescribeEngineDefaultParametersWithContext(arg0 context.Context, arg1 *rds.DescribeEngineDefaultParametersInput, arg2 ...request.Option) (*rds.DescribeEngineDefaultParametersOutput, error) { 4213 m.ctrl.T.Helper() 4214 varargs := []interface{}{arg0, arg1} 4215 for _, a := range arg2 { 4216 varargs = append(varargs, a) 4217 } 4218 ret := m.ctrl.Call(m, "DescribeEngineDefaultParametersWithContext", varargs...) 4219 ret0, _ := ret[0].(*rds.DescribeEngineDefaultParametersOutput) 4220 ret1, _ := ret[1].(error) 4221 return ret0, ret1 4222 } 4223 4224 // DescribeEngineDefaultParametersWithContext indicates an expected call of DescribeEngineDefaultParametersWithContext 4225 func (mr *MockRDSAPIMockRecorder) DescribeEngineDefaultParametersWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 4226 mr.mock.ctrl.T.Helper() 4227 varargs := append([]interface{}{arg0, arg1}, arg2...) 4228 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEngineDefaultParametersWithContext", reflect.TypeOf((*MockRDSAPI)(nil).DescribeEngineDefaultParametersWithContext), varargs...) 4229 } 4230 4231 // DescribeEventCategories mocks base method 4232 func (m *MockRDSAPI) DescribeEventCategories(arg0 *rds.DescribeEventCategoriesInput) (*rds.DescribeEventCategoriesOutput, error) { 4233 m.ctrl.T.Helper() 4234 ret := m.ctrl.Call(m, "DescribeEventCategories", arg0) 4235 ret0, _ := ret[0].(*rds.DescribeEventCategoriesOutput) 4236 ret1, _ := ret[1].(error) 4237 return ret0, ret1 4238 } 4239 4240 // DescribeEventCategories indicates an expected call of DescribeEventCategories 4241 func (mr *MockRDSAPIMockRecorder) DescribeEventCategories(arg0 interface{}) *gomock.Call { 4242 mr.mock.ctrl.T.Helper() 4243 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEventCategories", reflect.TypeOf((*MockRDSAPI)(nil).DescribeEventCategories), arg0) 4244 } 4245 4246 // DescribeEventCategoriesRequest mocks base method 4247 func (m *MockRDSAPI) DescribeEventCategoriesRequest(arg0 *rds.DescribeEventCategoriesInput) (*request.Request, *rds.DescribeEventCategoriesOutput) { 4248 m.ctrl.T.Helper() 4249 ret := m.ctrl.Call(m, "DescribeEventCategoriesRequest", arg0) 4250 ret0, _ := ret[0].(*request.Request) 4251 ret1, _ := ret[1].(*rds.DescribeEventCategoriesOutput) 4252 return ret0, ret1 4253 } 4254 4255 // DescribeEventCategoriesRequest indicates an expected call of DescribeEventCategoriesRequest 4256 func (mr *MockRDSAPIMockRecorder) DescribeEventCategoriesRequest(arg0 interface{}) *gomock.Call { 4257 mr.mock.ctrl.T.Helper() 4258 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEventCategoriesRequest", reflect.TypeOf((*MockRDSAPI)(nil).DescribeEventCategoriesRequest), arg0) 4259 } 4260 4261 // DescribeEventCategoriesWithContext mocks base method 4262 func (m *MockRDSAPI) DescribeEventCategoriesWithContext(arg0 context.Context, arg1 *rds.DescribeEventCategoriesInput, arg2 ...request.Option) (*rds.DescribeEventCategoriesOutput, error) { 4263 m.ctrl.T.Helper() 4264 varargs := []interface{}{arg0, arg1} 4265 for _, a := range arg2 { 4266 varargs = append(varargs, a) 4267 } 4268 ret := m.ctrl.Call(m, "DescribeEventCategoriesWithContext", varargs...) 4269 ret0, _ := ret[0].(*rds.DescribeEventCategoriesOutput) 4270 ret1, _ := ret[1].(error) 4271 return ret0, ret1 4272 } 4273 4274 // DescribeEventCategoriesWithContext indicates an expected call of DescribeEventCategoriesWithContext 4275 func (mr *MockRDSAPIMockRecorder) DescribeEventCategoriesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 4276 mr.mock.ctrl.T.Helper() 4277 varargs := append([]interface{}{arg0, arg1}, arg2...) 4278 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEventCategoriesWithContext", reflect.TypeOf((*MockRDSAPI)(nil).DescribeEventCategoriesWithContext), varargs...) 4279 } 4280 4281 // DescribeEventSubscriptions mocks base method 4282 func (m *MockRDSAPI) DescribeEventSubscriptions(arg0 *rds.DescribeEventSubscriptionsInput) (*rds.DescribeEventSubscriptionsOutput, error) { 4283 m.ctrl.T.Helper() 4284 ret := m.ctrl.Call(m, "DescribeEventSubscriptions", arg0) 4285 ret0, _ := ret[0].(*rds.DescribeEventSubscriptionsOutput) 4286 ret1, _ := ret[1].(error) 4287 return ret0, ret1 4288 } 4289 4290 // DescribeEventSubscriptions indicates an expected call of DescribeEventSubscriptions 4291 func (mr *MockRDSAPIMockRecorder) DescribeEventSubscriptions(arg0 interface{}) *gomock.Call { 4292 mr.mock.ctrl.T.Helper() 4293 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEventSubscriptions", reflect.TypeOf((*MockRDSAPI)(nil).DescribeEventSubscriptions), arg0) 4294 } 4295 4296 // DescribeEventSubscriptionsPages mocks base method 4297 func (m *MockRDSAPI) DescribeEventSubscriptionsPages(arg0 *rds.DescribeEventSubscriptionsInput, arg1 func(*rds.DescribeEventSubscriptionsOutput, bool) bool) error { 4298 m.ctrl.T.Helper() 4299 ret := m.ctrl.Call(m, "DescribeEventSubscriptionsPages", arg0, arg1) 4300 ret0, _ := ret[0].(error) 4301 return ret0 4302 } 4303 4304 // DescribeEventSubscriptionsPages indicates an expected call of DescribeEventSubscriptionsPages 4305 func (mr *MockRDSAPIMockRecorder) DescribeEventSubscriptionsPages(arg0, arg1 interface{}) *gomock.Call { 4306 mr.mock.ctrl.T.Helper() 4307 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEventSubscriptionsPages", reflect.TypeOf((*MockRDSAPI)(nil).DescribeEventSubscriptionsPages), arg0, arg1) 4308 } 4309 4310 // DescribeEventSubscriptionsPagesWithContext mocks base method 4311 func (m *MockRDSAPI) DescribeEventSubscriptionsPagesWithContext(arg0 context.Context, arg1 *rds.DescribeEventSubscriptionsInput, arg2 func(*rds.DescribeEventSubscriptionsOutput, bool) bool, arg3 ...request.Option) error { 4312 m.ctrl.T.Helper() 4313 varargs := []interface{}{arg0, arg1, arg2} 4314 for _, a := range arg3 { 4315 varargs = append(varargs, a) 4316 } 4317 ret := m.ctrl.Call(m, "DescribeEventSubscriptionsPagesWithContext", varargs...) 4318 ret0, _ := ret[0].(error) 4319 return ret0 4320 } 4321 4322 // DescribeEventSubscriptionsPagesWithContext indicates an expected call of DescribeEventSubscriptionsPagesWithContext 4323 func (mr *MockRDSAPIMockRecorder) DescribeEventSubscriptionsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 4324 mr.mock.ctrl.T.Helper() 4325 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 4326 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEventSubscriptionsPagesWithContext", reflect.TypeOf((*MockRDSAPI)(nil).DescribeEventSubscriptionsPagesWithContext), varargs...) 4327 } 4328 4329 // DescribeEventSubscriptionsRequest mocks base method 4330 func (m *MockRDSAPI) DescribeEventSubscriptionsRequest(arg0 *rds.DescribeEventSubscriptionsInput) (*request.Request, *rds.DescribeEventSubscriptionsOutput) { 4331 m.ctrl.T.Helper() 4332 ret := m.ctrl.Call(m, "DescribeEventSubscriptionsRequest", arg0) 4333 ret0, _ := ret[0].(*request.Request) 4334 ret1, _ := ret[1].(*rds.DescribeEventSubscriptionsOutput) 4335 return ret0, ret1 4336 } 4337 4338 // DescribeEventSubscriptionsRequest indicates an expected call of DescribeEventSubscriptionsRequest 4339 func (mr *MockRDSAPIMockRecorder) DescribeEventSubscriptionsRequest(arg0 interface{}) *gomock.Call { 4340 mr.mock.ctrl.T.Helper() 4341 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEventSubscriptionsRequest", reflect.TypeOf((*MockRDSAPI)(nil).DescribeEventSubscriptionsRequest), arg0) 4342 } 4343 4344 // DescribeEventSubscriptionsWithContext mocks base method 4345 func (m *MockRDSAPI) DescribeEventSubscriptionsWithContext(arg0 context.Context, arg1 *rds.DescribeEventSubscriptionsInput, arg2 ...request.Option) (*rds.DescribeEventSubscriptionsOutput, error) { 4346 m.ctrl.T.Helper() 4347 varargs := []interface{}{arg0, arg1} 4348 for _, a := range arg2 { 4349 varargs = append(varargs, a) 4350 } 4351 ret := m.ctrl.Call(m, "DescribeEventSubscriptionsWithContext", varargs...) 4352 ret0, _ := ret[0].(*rds.DescribeEventSubscriptionsOutput) 4353 ret1, _ := ret[1].(error) 4354 return ret0, ret1 4355 } 4356 4357 // DescribeEventSubscriptionsWithContext indicates an expected call of DescribeEventSubscriptionsWithContext 4358 func (mr *MockRDSAPIMockRecorder) DescribeEventSubscriptionsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 4359 mr.mock.ctrl.T.Helper() 4360 varargs := append([]interface{}{arg0, arg1}, arg2...) 4361 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEventSubscriptionsWithContext", reflect.TypeOf((*MockRDSAPI)(nil).DescribeEventSubscriptionsWithContext), varargs...) 4362 } 4363 4364 // DescribeEvents mocks base method 4365 func (m *MockRDSAPI) DescribeEvents(arg0 *rds.DescribeEventsInput) (*rds.DescribeEventsOutput, error) { 4366 m.ctrl.T.Helper() 4367 ret := m.ctrl.Call(m, "DescribeEvents", arg0) 4368 ret0, _ := ret[0].(*rds.DescribeEventsOutput) 4369 ret1, _ := ret[1].(error) 4370 return ret0, ret1 4371 } 4372 4373 // DescribeEvents indicates an expected call of DescribeEvents 4374 func (mr *MockRDSAPIMockRecorder) DescribeEvents(arg0 interface{}) *gomock.Call { 4375 mr.mock.ctrl.T.Helper() 4376 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEvents", reflect.TypeOf((*MockRDSAPI)(nil).DescribeEvents), arg0) 4377 } 4378 4379 // DescribeEventsPages mocks base method 4380 func (m *MockRDSAPI) DescribeEventsPages(arg0 *rds.DescribeEventsInput, arg1 func(*rds.DescribeEventsOutput, bool) bool) error { 4381 m.ctrl.T.Helper() 4382 ret := m.ctrl.Call(m, "DescribeEventsPages", arg0, arg1) 4383 ret0, _ := ret[0].(error) 4384 return ret0 4385 } 4386 4387 // DescribeEventsPages indicates an expected call of DescribeEventsPages 4388 func (mr *MockRDSAPIMockRecorder) DescribeEventsPages(arg0, arg1 interface{}) *gomock.Call { 4389 mr.mock.ctrl.T.Helper() 4390 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEventsPages", reflect.TypeOf((*MockRDSAPI)(nil).DescribeEventsPages), arg0, arg1) 4391 } 4392 4393 // DescribeEventsPagesWithContext mocks base method 4394 func (m *MockRDSAPI) DescribeEventsPagesWithContext(arg0 context.Context, arg1 *rds.DescribeEventsInput, arg2 func(*rds.DescribeEventsOutput, bool) bool, arg3 ...request.Option) error { 4395 m.ctrl.T.Helper() 4396 varargs := []interface{}{arg0, arg1, arg2} 4397 for _, a := range arg3 { 4398 varargs = append(varargs, a) 4399 } 4400 ret := m.ctrl.Call(m, "DescribeEventsPagesWithContext", varargs...) 4401 ret0, _ := ret[0].(error) 4402 return ret0 4403 } 4404 4405 // DescribeEventsPagesWithContext indicates an expected call of DescribeEventsPagesWithContext 4406 func (mr *MockRDSAPIMockRecorder) DescribeEventsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 4407 mr.mock.ctrl.T.Helper() 4408 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 4409 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEventsPagesWithContext", reflect.TypeOf((*MockRDSAPI)(nil).DescribeEventsPagesWithContext), varargs...) 4410 } 4411 4412 // DescribeEventsRequest mocks base method 4413 func (m *MockRDSAPI) DescribeEventsRequest(arg0 *rds.DescribeEventsInput) (*request.Request, *rds.DescribeEventsOutput) { 4414 m.ctrl.T.Helper() 4415 ret := m.ctrl.Call(m, "DescribeEventsRequest", arg0) 4416 ret0, _ := ret[0].(*request.Request) 4417 ret1, _ := ret[1].(*rds.DescribeEventsOutput) 4418 return ret0, ret1 4419 } 4420 4421 // DescribeEventsRequest indicates an expected call of DescribeEventsRequest 4422 func (mr *MockRDSAPIMockRecorder) DescribeEventsRequest(arg0 interface{}) *gomock.Call { 4423 mr.mock.ctrl.T.Helper() 4424 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEventsRequest", reflect.TypeOf((*MockRDSAPI)(nil).DescribeEventsRequest), arg0) 4425 } 4426 4427 // DescribeEventsWithContext mocks base method 4428 func (m *MockRDSAPI) DescribeEventsWithContext(arg0 context.Context, arg1 *rds.DescribeEventsInput, arg2 ...request.Option) (*rds.DescribeEventsOutput, error) { 4429 m.ctrl.T.Helper() 4430 varargs := []interface{}{arg0, arg1} 4431 for _, a := range arg2 { 4432 varargs = append(varargs, a) 4433 } 4434 ret := m.ctrl.Call(m, "DescribeEventsWithContext", varargs...) 4435 ret0, _ := ret[0].(*rds.DescribeEventsOutput) 4436 ret1, _ := ret[1].(error) 4437 return ret0, ret1 4438 } 4439 4440 // DescribeEventsWithContext indicates an expected call of DescribeEventsWithContext 4441 func (mr *MockRDSAPIMockRecorder) DescribeEventsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 4442 mr.mock.ctrl.T.Helper() 4443 varargs := append([]interface{}{arg0, arg1}, arg2...) 4444 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEventsWithContext", reflect.TypeOf((*MockRDSAPI)(nil).DescribeEventsWithContext), varargs...) 4445 } 4446 4447 // DescribeExportTasks mocks base method 4448 func (m *MockRDSAPI) DescribeExportTasks(arg0 *rds.DescribeExportTasksInput) (*rds.DescribeExportTasksOutput, error) { 4449 m.ctrl.T.Helper() 4450 ret := m.ctrl.Call(m, "DescribeExportTasks", arg0) 4451 ret0, _ := ret[0].(*rds.DescribeExportTasksOutput) 4452 ret1, _ := ret[1].(error) 4453 return ret0, ret1 4454 } 4455 4456 // DescribeExportTasks indicates an expected call of DescribeExportTasks 4457 func (mr *MockRDSAPIMockRecorder) DescribeExportTasks(arg0 interface{}) *gomock.Call { 4458 mr.mock.ctrl.T.Helper() 4459 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeExportTasks", reflect.TypeOf((*MockRDSAPI)(nil).DescribeExportTasks), arg0) 4460 } 4461 4462 // DescribeExportTasksPages mocks base method 4463 func (m *MockRDSAPI) DescribeExportTasksPages(arg0 *rds.DescribeExportTasksInput, arg1 func(*rds.DescribeExportTasksOutput, bool) bool) error { 4464 m.ctrl.T.Helper() 4465 ret := m.ctrl.Call(m, "DescribeExportTasksPages", arg0, arg1) 4466 ret0, _ := ret[0].(error) 4467 return ret0 4468 } 4469 4470 // DescribeExportTasksPages indicates an expected call of DescribeExportTasksPages 4471 func (mr *MockRDSAPIMockRecorder) DescribeExportTasksPages(arg0, arg1 interface{}) *gomock.Call { 4472 mr.mock.ctrl.T.Helper() 4473 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeExportTasksPages", reflect.TypeOf((*MockRDSAPI)(nil).DescribeExportTasksPages), arg0, arg1) 4474 } 4475 4476 // DescribeExportTasksPagesWithContext mocks base method 4477 func (m *MockRDSAPI) DescribeExportTasksPagesWithContext(arg0 context.Context, arg1 *rds.DescribeExportTasksInput, arg2 func(*rds.DescribeExportTasksOutput, bool) bool, arg3 ...request.Option) error { 4478 m.ctrl.T.Helper() 4479 varargs := []interface{}{arg0, arg1, arg2} 4480 for _, a := range arg3 { 4481 varargs = append(varargs, a) 4482 } 4483 ret := m.ctrl.Call(m, "DescribeExportTasksPagesWithContext", varargs...) 4484 ret0, _ := ret[0].(error) 4485 return ret0 4486 } 4487 4488 // DescribeExportTasksPagesWithContext indicates an expected call of DescribeExportTasksPagesWithContext 4489 func (mr *MockRDSAPIMockRecorder) DescribeExportTasksPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 4490 mr.mock.ctrl.T.Helper() 4491 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 4492 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeExportTasksPagesWithContext", reflect.TypeOf((*MockRDSAPI)(nil).DescribeExportTasksPagesWithContext), varargs...) 4493 } 4494 4495 // DescribeExportTasksRequest mocks base method 4496 func (m *MockRDSAPI) DescribeExportTasksRequest(arg0 *rds.DescribeExportTasksInput) (*request.Request, *rds.DescribeExportTasksOutput) { 4497 m.ctrl.T.Helper() 4498 ret := m.ctrl.Call(m, "DescribeExportTasksRequest", arg0) 4499 ret0, _ := ret[0].(*request.Request) 4500 ret1, _ := ret[1].(*rds.DescribeExportTasksOutput) 4501 return ret0, ret1 4502 } 4503 4504 // DescribeExportTasksRequest indicates an expected call of DescribeExportTasksRequest 4505 func (mr *MockRDSAPIMockRecorder) DescribeExportTasksRequest(arg0 interface{}) *gomock.Call { 4506 mr.mock.ctrl.T.Helper() 4507 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeExportTasksRequest", reflect.TypeOf((*MockRDSAPI)(nil).DescribeExportTasksRequest), arg0) 4508 } 4509 4510 // DescribeExportTasksWithContext mocks base method 4511 func (m *MockRDSAPI) DescribeExportTasksWithContext(arg0 context.Context, arg1 *rds.DescribeExportTasksInput, arg2 ...request.Option) (*rds.DescribeExportTasksOutput, error) { 4512 m.ctrl.T.Helper() 4513 varargs := []interface{}{arg0, arg1} 4514 for _, a := range arg2 { 4515 varargs = append(varargs, a) 4516 } 4517 ret := m.ctrl.Call(m, "DescribeExportTasksWithContext", varargs...) 4518 ret0, _ := ret[0].(*rds.DescribeExportTasksOutput) 4519 ret1, _ := ret[1].(error) 4520 return ret0, ret1 4521 } 4522 4523 // DescribeExportTasksWithContext indicates an expected call of DescribeExportTasksWithContext 4524 func (mr *MockRDSAPIMockRecorder) DescribeExportTasksWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 4525 mr.mock.ctrl.T.Helper() 4526 varargs := append([]interface{}{arg0, arg1}, arg2...) 4527 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeExportTasksWithContext", reflect.TypeOf((*MockRDSAPI)(nil).DescribeExportTasksWithContext), varargs...) 4528 } 4529 4530 // DescribeGlobalClusters mocks base method 4531 func (m *MockRDSAPI) DescribeGlobalClusters(arg0 *rds.DescribeGlobalClustersInput) (*rds.DescribeGlobalClustersOutput, error) { 4532 m.ctrl.T.Helper() 4533 ret := m.ctrl.Call(m, "DescribeGlobalClusters", arg0) 4534 ret0, _ := ret[0].(*rds.DescribeGlobalClustersOutput) 4535 ret1, _ := ret[1].(error) 4536 return ret0, ret1 4537 } 4538 4539 // DescribeGlobalClusters indicates an expected call of DescribeGlobalClusters 4540 func (mr *MockRDSAPIMockRecorder) DescribeGlobalClusters(arg0 interface{}) *gomock.Call { 4541 mr.mock.ctrl.T.Helper() 4542 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeGlobalClusters", reflect.TypeOf((*MockRDSAPI)(nil).DescribeGlobalClusters), arg0) 4543 } 4544 4545 // DescribeGlobalClustersPages mocks base method 4546 func (m *MockRDSAPI) DescribeGlobalClustersPages(arg0 *rds.DescribeGlobalClustersInput, arg1 func(*rds.DescribeGlobalClustersOutput, bool) bool) error { 4547 m.ctrl.T.Helper() 4548 ret := m.ctrl.Call(m, "DescribeGlobalClustersPages", arg0, arg1) 4549 ret0, _ := ret[0].(error) 4550 return ret0 4551 } 4552 4553 // DescribeGlobalClustersPages indicates an expected call of DescribeGlobalClustersPages 4554 func (mr *MockRDSAPIMockRecorder) DescribeGlobalClustersPages(arg0, arg1 interface{}) *gomock.Call { 4555 mr.mock.ctrl.T.Helper() 4556 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeGlobalClustersPages", reflect.TypeOf((*MockRDSAPI)(nil).DescribeGlobalClustersPages), arg0, arg1) 4557 } 4558 4559 // DescribeGlobalClustersPagesWithContext mocks base method 4560 func (m *MockRDSAPI) DescribeGlobalClustersPagesWithContext(arg0 context.Context, arg1 *rds.DescribeGlobalClustersInput, arg2 func(*rds.DescribeGlobalClustersOutput, bool) bool, arg3 ...request.Option) error { 4561 m.ctrl.T.Helper() 4562 varargs := []interface{}{arg0, arg1, arg2} 4563 for _, a := range arg3 { 4564 varargs = append(varargs, a) 4565 } 4566 ret := m.ctrl.Call(m, "DescribeGlobalClustersPagesWithContext", varargs...) 4567 ret0, _ := ret[0].(error) 4568 return ret0 4569 } 4570 4571 // DescribeGlobalClustersPagesWithContext indicates an expected call of DescribeGlobalClustersPagesWithContext 4572 func (mr *MockRDSAPIMockRecorder) DescribeGlobalClustersPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 4573 mr.mock.ctrl.T.Helper() 4574 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 4575 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeGlobalClustersPagesWithContext", reflect.TypeOf((*MockRDSAPI)(nil).DescribeGlobalClustersPagesWithContext), varargs...) 4576 } 4577 4578 // DescribeGlobalClustersRequest mocks base method 4579 func (m *MockRDSAPI) DescribeGlobalClustersRequest(arg0 *rds.DescribeGlobalClustersInput) (*request.Request, *rds.DescribeGlobalClustersOutput) { 4580 m.ctrl.T.Helper() 4581 ret := m.ctrl.Call(m, "DescribeGlobalClustersRequest", arg0) 4582 ret0, _ := ret[0].(*request.Request) 4583 ret1, _ := ret[1].(*rds.DescribeGlobalClustersOutput) 4584 return ret0, ret1 4585 } 4586 4587 // DescribeGlobalClustersRequest indicates an expected call of DescribeGlobalClustersRequest 4588 func (mr *MockRDSAPIMockRecorder) DescribeGlobalClustersRequest(arg0 interface{}) *gomock.Call { 4589 mr.mock.ctrl.T.Helper() 4590 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeGlobalClustersRequest", reflect.TypeOf((*MockRDSAPI)(nil).DescribeGlobalClustersRequest), arg0) 4591 } 4592 4593 // DescribeGlobalClustersWithContext mocks base method 4594 func (m *MockRDSAPI) DescribeGlobalClustersWithContext(arg0 context.Context, arg1 *rds.DescribeGlobalClustersInput, arg2 ...request.Option) (*rds.DescribeGlobalClustersOutput, error) { 4595 m.ctrl.T.Helper() 4596 varargs := []interface{}{arg0, arg1} 4597 for _, a := range arg2 { 4598 varargs = append(varargs, a) 4599 } 4600 ret := m.ctrl.Call(m, "DescribeGlobalClustersWithContext", varargs...) 4601 ret0, _ := ret[0].(*rds.DescribeGlobalClustersOutput) 4602 ret1, _ := ret[1].(error) 4603 return ret0, ret1 4604 } 4605 4606 // DescribeGlobalClustersWithContext indicates an expected call of DescribeGlobalClustersWithContext 4607 func (mr *MockRDSAPIMockRecorder) DescribeGlobalClustersWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 4608 mr.mock.ctrl.T.Helper() 4609 varargs := append([]interface{}{arg0, arg1}, arg2...) 4610 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeGlobalClustersWithContext", reflect.TypeOf((*MockRDSAPI)(nil).DescribeGlobalClustersWithContext), varargs...) 4611 } 4612 4613 // DescribeInstallationMedia mocks base method 4614 func (m *MockRDSAPI) DescribeInstallationMedia(arg0 *rds.DescribeInstallationMediaInput) (*rds.DescribeInstallationMediaOutput, error) { 4615 m.ctrl.T.Helper() 4616 ret := m.ctrl.Call(m, "DescribeInstallationMedia", arg0) 4617 ret0, _ := ret[0].(*rds.DescribeInstallationMediaOutput) 4618 ret1, _ := ret[1].(error) 4619 return ret0, ret1 4620 } 4621 4622 // DescribeInstallationMedia indicates an expected call of DescribeInstallationMedia 4623 func (mr *MockRDSAPIMockRecorder) DescribeInstallationMedia(arg0 interface{}) *gomock.Call { 4624 mr.mock.ctrl.T.Helper() 4625 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstallationMedia", reflect.TypeOf((*MockRDSAPI)(nil).DescribeInstallationMedia), arg0) 4626 } 4627 4628 // DescribeInstallationMediaPages mocks base method 4629 func (m *MockRDSAPI) DescribeInstallationMediaPages(arg0 *rds.DescribeInstallationMediaInput, arg1 func(*rds.DescribeInstallationMediaOutput, bool) bool) error { 4630 m.ctrl.T.Helper() 4631 ret := m.ctrl.Call(m, "DescribeInstallationMediaPages", arg0, arg1) 4632 ret0, _ := ret[0].(error) 4633 return ret0 4634 } 4635 4636 // DescribeInstallationMediaPages indicates an expected call of DescribeInstallationMediaPages 4637 func (mr *MockRDSAPIMockRecorder) DescribeInstallationMediaPages(arg0, arg1 interface{}) *gomock.Call { 4638 mr.mock.ctrl.T.Helper() 4639 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstallationMediaPages", reflect.TypeOf((*MockRDSAPI)(nil).DescribeInstallationMediaPages), arg0, arg1) 4640 } 4641 4642 // DescribeInstallationMediaPagesWithContext mocks base method 4643 func (m *MockRDSAPI) DescribeInstallationMediaPagesWithContext(arg0 context.Context, arg1 *rds.DescribeInstallationMediaInput, arg2 func(*rds.DescribeInstallationMediaOutput, bool) bool, arg3 ...request.Option) error { 4644 m.ctrl.T.Helper() 4645 varargs := []interface{}{arg0, arg1, arg2} 4646 for _, a := range arg3 { 4647 varargs = append(varargs, a) 4648 } 4649 ret := m.ctrl.Call(m, "DescribeInstallationMediaPagesWithContext", varargs...) 4650 ret0, _ := ret[0].(error) 4651 return ret0 4652 } 4653 4654 // DescribeInstallationMediaPagesWithContext indicates an expected call of DescribeInstallationMediaPagesWithContext 4655 func (mr *MockRDSAPIMockRecorder) DescribeInstallationMediaPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 4656 mr.mock.ctrl.T.Helper() 4657 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 4658 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstallationMediaPagesWithContext", reflect.TypeOf((*MockRDSAPI)(nil).DescribeInstallationMediaPagesWithContext), varargs...) 4659 } 4660 4661 // DescribeInstallationMediaRequest mocks base method 4662 func (m *MockRDSAPI) DescribeInstallationMediaRequest(arg0 *rds.DescribeInstallationMediaInput) (*request.Request, *rds.DescribeInstallationMediaOutput) { 4663 m.ctrl.T.Helper() 4664 ret := m.ctrl.Call(m, "DescribeInstallationMediaRequest", arg0) 4665 ret0, _ := ret[0].(*request.Request) 4666 ret1, _ := ret[1].(*rds.DescribeInstallationMediaOutput) 4667 return ret0, ret1 4668 } 4669 4670 // DescribeInstallationMediaRequest indicates an expected call of DescribeInstallationMediaRequest 4671 func (mr *MockRDSAPIMockRecorder) DescribeInstallationMediaRequest(arg0 interface{}) *gomock.Call { 4672 mr.mock.ctrl.T.Helper() 4673 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstallationMediaRequest", reflect.TypeOf((*MockRDSAPI)(nil).DescribeInstallationMediaRequest), arg0) 4674 } 4675 4676 // DescribeInstallationMediaWithContext mocks base method 4677 func (m *MockRDSAPI) DescribeInstallationMediaWithContext(arg0 context.Context, arg1 *rds.DescribeInstallationMediaInput, arg2 ...request.Option) (*rds.DescribeInstallationMediaOutput, error) { 4678 m.ctrl.T.Helper() 4679 varargs := []interface{}{arg0, arg1} 4680 for _, a := range arg2 { 4681 varargs = append(varargs, a) 4682 } 4683 ret := m.ctrl.Call(m, "DescribeInstallationMediaWithContext", varargs...) 4684 ret0, _ := ret[0].(*rds.DescribeInstallationMediaOutput) 4685 ret1, _ := ret[1].(error) 4686 return ret0, ret1 4687 } 4688 4689 // DescribeInstallationMediaWithContext indicates an expected call of DescribeInstallationMediaWithContext 4690 func (mr *MockRDSAPIMockRecorder) DescribeInstallationMediaWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 4691 mr.mock.ctrl.T.Helper() 4692 varargs := append([]interface{}{arg0, arg1}, arg2...) 4693 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstallationMediaWithContext", reflect.TypeOf((*MockRDSAPI)(nil).DescribeInstallationMediaWithContext), varargs...) 4694 } 4695 4696 // DescribeOptionGroupOptions mocks base method 4697 func (m *MockRDSAPI) DescribeOptionGroupOptions(arg0 *rds.DescribeOptionGroupOptionsInput) (*rds.DescribeOptionGroupOptionsOutput, error) { 4698 m.ctrl.T.Helper() 4699 ret := m.ctrl.Call(m, "DescribeOptionGroupOptions", arg0) 4700 ret0, _ := ret[0].(*rds.DescribeOptionGroupOptionsOutput) 4701 ret1, _ := ret[1].(error) 4702 return ret0, ret1 4703 } 4704 4705 // DescribeOptionGroupOptions indicates an expected call of DescribeOptionGroupOptions 4706 func (mr *MockRDSAPIMockRecorder) DescribeOptionGroupOptions(arg0 interface{}) *gomock.Call { 4707 mr.mock.ctrl.T.Helper() 4708 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeOptionGroupOptions", reflect.TypeOf((*MockRDSAPI)(nil).DescribeOptionGroupOptions), arg0) 4709 } 4710 4711 // DescribeOptionGroupOptionsPages mocks base method 4712 func (m *MockRDSAPI) DescribeOptionGroupOptionsPages(arg0 *rds.DescribeOptionGroupOptionsInput, arg1 func(*rds.DescribeOptionGroupOptionsOutput, bool) bool) error { 4713 m.ctrl.T.Helper() 4714 ret := m.ctrl.Call(m, "DescribeOptionGroupOptionsPages", arg0, arg1) 4715 ret0, _ := ret[0].(error) 4716 return ret0 4717 } 4718 4719 // DescribeOptionGroupOptionsPages indicates an expected call of DescribeOptionGroupOptionsPages 4720 func (mr *MockRDSAPIMockRecorder) DescribeOptionGroupOptionsPages(arg0, arg1 interface{}) *gomock.Call { 4721 mr.mock.ctrl.T.Helper() 4722 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeOptionGroupOptionsPages", reflect.TypeOf((*MockRDSAPI)(nil).DescribeOptionGroupOptionsPages), arg0, arg1) 4723 } 4724 4725 // DescribeOptionGroupOptionsPagesWithContext mocks base method 4726 func (m *MockRDSAPI) DescribeOptionGroupOptionsPagesWithContext(arg0 context.Context, arg1 *rds.DescribeOptionGroupOptionsInput, arg2 func(*rds.DescribeOptionGroupOptionsOutput, bool) bool, arg3 ...request.Option) error { 4727 m.ctrl.T.Helper() 4728 varargs := []interface{}{arg0, arg1, arg2} 4729 for _, a := range arg3 { 4730 varargs = append(varargs, a) 4731 } 4732 ret := m.ctrl.Call(m, "DescribeOptionGroupOptionsPagesWithContext", varargs...) 4733 ret0, _ := ret[0].(error) 4734 return ret0 4735 } 4736 4737 // DescribeOptionGroupOptionsPagesWithContext indicates an expected call of DescribeOptionGroupOptionsPagesWithContext 4738 func (mr *MockRDSAPIMockRecorder) DescribeOptionGroupOptionsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 4739 mr.mock.ctrl.T.Helper() 4740 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 4741 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeOptionGroupOptionsPagesWithContext", reflect.TypeOf((*MockRDSAPI)(nil).DescribeOptionGroupOptionsPagesWithContext), varargs...) 4742 } 4743 4744 // DescribeOptionGroupOptionsRequest mocks base method 4745 func (m *MockRDSAPI) DescribeOptionGroupOptionsRequest(arg0 *rds.DescribeOptionGroupOptionsInput) (*request.Request, *rds.DescribeOptionGroupOptionsOutput) { 4746 m.ctrl.T.Helper() 4747 ret := m.ctrl.Call(m, "DescribeOptionGroupOptionsRequest", arg0) 4748 ret0, _ := ret[0].(*request.Request) 4749 ret1, _ := ret[1].(*rds.DescribeOptionGroupOptionsOutput) 4750 return ret0, ret1 4751 } 4752 4753 // DescribeOptionGroupOptionsRequest indicates an expected call of DescribeOptionGroupOptionsRequest 4754 func (mr *MockRDSAPIMockRecorder) DescribeOptionGroupOptionsRequest(arg0 interface{}) *gomock.Call { 4755 mr.mock.ctrl.T.Helper() 4756 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeOptionGroupOptionsRequest", reflect.TypeOf((*MockRDSAPI)(nil).DescribeOptionGroupOptionsRequest), arg0) 4757 } 4758 4759 // DescribeOptionGroupOptionsWithContext mocks base method 4760 func (m *MockRDSAPI) DescribeOptionGroupOptionsWithContext(arg0 context.Context, arg1 *rds.DescribeOptionGroupOptionsInput, arg2 ...request.Option) (*rds.DescribeOptionGroupOptionsOutput, error) { 4761 m.ctrl.T.Helper() 4762 varargs := []interface{}{arg0, arg1} 4763 for _, a := range arg2 { 4764 varargs = append(varargs, a) 4765 } 4766 ret := m.ctrl.Call(m, "DescribeOptionGroupOptionsWithContext", varargs...) 4767 ret0, _ := ret[0].(*rds.DescribeOptionGroupOptionsOutput) 4768 ret1, _ := ret[1].(error) 4769 return ret0, ret1 4770 } 4771 4772 // DescribeOptionGroupOptionsWithContext indicates an expected call of DescribeOptionGroupOptionsWithContext 4773 func (mr *MockRDSAPIMockRecorder) DescribeOptionGroupOptionsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 4774 mr.mock.ctrl.T.Helper() 4775 varargs := append([]interface{}{arg0, arg1}, arg2...) 4776 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeOptionGroupOptionsWithContext", reflect.TypeOf((*MockRDSAPI)(nil).DescribeOptionGroupOptionsWithContext), varargs...) 4777 } 4778 4779 // DescribeOptionGroups mocks base method 4780 func (m *MockRDSAPI) DescribeOptionGroups(arg0 *rds.DescribeOptionGroupsInput) (*rds.DescribeOptionGroupsOutput, error) { 4781 m.ctrl.T.Helper() 4782 ret := m.ctrl.Call(m, "DescribeOptionGroups", arg0) 4783 ret0, _ := ret[0].(*rds.DescribeOptionGroupsOutput) 4784 ret1, _ := ret[1].(error) 4785 return ret0, ret1 4786 } 4787 4788 // DescribeOptionGroups indicates an expected call of DescribeOptionGroups 4789 func (mr *MockRDSAPIMockRecorder) DescribeOptionGroups(arg0 interface{}) *gomock.Call { 4790 mr.mock.ctrl.T.Helper() 4791 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeOptionGroups", reflect.TypeOf((*MockRDSAPI)(nil).DescribeOptionGroups), arg0) 4792 } 4793 4794 // DescribeOptionGroupsPages mocks base method 4795 func (m *MockRDSAPI) DescribeOptionGroupsPages(arg0 *rds.DescribeOptionGroupsInput, arg1 func(*rds.DescribeOptionGroupsOutput, bool) bool) error { 4796 m.ctrl.T.Helper() 4797 ret := m.ctrl.Call(m, "DescribeOptionGroupsPages", arg0, arg1) 4798 ret0, _ := ret[0].(error) 4799 return ret0 4800 } 4801 4802 // DescribeOptionGroupsPages indicates an expected call of DescribeOptionGroupsPages 4803 func (mr *MockRDSAPIMockRecorder) DescribeOptionGroupsPages(arg0, arg1 interface{}) *gomock.Call { 4804 mr.mock.ctrl.T.Helper() 4805 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeOptionGroupsPages", reflect.TypeOf((*MockRDSAPI)(nil).DescribeOptionGroupsPages), arg0, arg1) 4806 } 4807 4808 // DescribeOptionGroupsPagesWithContext mocks base method 4809 func (m *MockRDSAPI) DescribeOptionGroupsPagesWithContext(arg0 context.Context, arg1 *rds.DescribeOptionGroupsInput, arg2 func(*rds.DescribeOptionGroupsOutput, bool) bool, arg3 ...request.Option) error { 4810 m.ctrl.T.Helper() 4811 varargs := []interface{}{arg0, arg1, arg2} 4812 for _, a := range arg3 { 4813 varargs = append(varargs, a) 4814 } 4815 ret := m.ctrl.Call(m, "DescribeOptionGroupsPagesWithContext", varargs...) 4816 ret0, _ := ret[0].(error) 4817 return ret0 4818 } 4819 4820 // DescribeOptionGroupsPagesWithContext indicates an expected call of DescribeOptionGroupsPagesWithContext 4821 func (mr *MockRDSAPIMockRecorder) DescribeOptionGroupsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 4822 mr.mock.ctrl.T.Helper() 4823 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 4824 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeOptionGroupsPagesWithContext", reflect.TypeOf((*MockRDSAPI)(nil).DescribeOptionGroupsPagesWithContext), varargs...) 4825 } 4826 4827 // DescribeOptionGroupsRequest mocks base method 4828 func (m *MockRDSAPI) DescribeOptionGroupsRequest(arg0 *rds.DescribeOptionGroupsInput) (*request.Request, *rds.DescribeOptionGroupsOutput) { 4829 m.ctrl.T.Helper() 4830 ret := m.ctrl.Call(m, "DescribeOptionGroupsRequest", arg0) 4831 ret0, _ := ret[0].(*request.Request) 4832 ret1, _ := ret[1].(*rds.DescribeOptionGroupsOutput) 4833 return ret0, ret1 4834 } 4835 4836 // DescribeOptionGroupsRequest indicates an expected call of DescribeOptionGroupsRequest 4837 func (mr *MockRDSAPIMockRecorder) DescribeOptionGroupsRequest(arg0 interface{}) *gomock.Call { 4838 mr.mock.ctrl.T.Helper() 4839 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeOptionGroupsRequest", reflect.TypeOf((*MockRDSAPI)(nil).DescribeOptionGroupsRequest), arg0) 4840 } 4841 4842 // DescribeOptionGroupsWithContext mocks base method 4843 func (m *MockRDSAPI) DescribeOptionGroupsWithContext(arg0 context.Context, arg1 *rds.DescribeOptionGroupsInput, arg2 ...request.Option) (*rds.DescribeOptionGroupsOutput, error) { 4844 m.ctrl.T.Helper() 4845 varargs := []interface{}{arg0, arg1} 4846 for _, a := range arg2 { 4847 varargs = append(varargs, a) 4848 } 4849 ret := m.ctrl.Call(m, "DescribeOptionGroupsWithContext", varargs...) 4850 ret0, _ := ret[0].(*rds.DescribeOptionGroupsOutput) 4851 ret1, _ := ret[1].(error) 4852 return ret0, ret1 4853 } 4854 4855 // DescribeOptionGroupsWithContext indicates an expected call of DescribeOptionGroupsWithContext 4856 func (mr *MockRDSAPIMockRecorder) DescribeOptionGroupsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 4857 mr.mock.ctrl.T.Helper() 4858 varargs := append([]interface{}{arg0, arg1}, arg2...) 4859 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeOptionGroupsWithContext", reflect.TypeOf((*MockRDSAPI)(nil).DescribeOptionGroupsWithContext), varargs...) 4860 } 4861 4862 // DescribeOrderableDBInstanceOptions mocks base method 4863 func (m *MockRDSAPI) DescribeOrderableDBInstanceOptions(arg0 *rds.DescribeOrderableDBInstanceOptionsInput) (*rds.DescribeOrderableDBInstanceOptionsOutput, error) { 4864 m.ctrl.T.Helper() 4865 ret := m.ctrl.Call(m, "DescribeOrderableDBInstanceOptions", arg0) 4866 ret0, _ := ret[0].(*rds.DescribeOrderableDBInstanceOptionsOutput) 4867 ret1, _ := ret[1].(error) 4868 return ret0, ret1 4869 } 4870 4871 // DescribeOrderableDBInstanceOptions indicates an expected call of DescribeOrderableDBInstanceOptions 4872 func (mr *MockRDSAPIMockRecorder) DescribeOrderableDBInstanceOptions(arg0 interface{}) *gomock.Call { 4873 mr.mock.ctrl.T.Helper() 4874 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeOrderableDBInstanceOptions", reflect.TypeOf((*MockRDSAPI)(nil).DescribeOrderableDBInstanceOptions), arg0) 4875 } 4876 4877 // DescribeOrderableDBInstanceOptionsPages mocks base method 4878 func (m *MockRDSAPI) DescribeOrderableDBInstanceOptionsPages(arg0 *rds.DescribeOrderableDBInstanceOptionsInput, arg1 func(*rds.DescribeOrderableDBInstanceOptionsOutput, bool) bool) error { 4879 m.ctrl.T.Helper() 4880 ret := m.ctrl.Call(m, "DescribeOrderableDBInstanceOptionsPages", arg0, arg1) 4881 ret0, _ := ret[0].(error) 4882 return ret0 4883 } 4884 4885 // DescribeOrderableDBInstanceOptionsPages indicates an expected call of DescribeOrderableDBInstanceOptionsPages 4886 func (mr *MockRDSAPIMockRecorder) DescribeOrderableDBInstanceOptionsPages(arg0, arg1 interface{}) *gomock.Call { 4887 mr.mock.ctrl.T.Helper() 4888 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeOrderableDBInstanceOptionsPages", reflect.TypeOf((*MockRDSAPI)(nil).DescribeOrderableDBInstanceOptionsPages), arg0, arg1) 4889 } 4890 4891 // DescribeOrderableDBInstanceOptionsPagesWithContext mocks base method 4892 func (m *MockRDSAPI) DescribeOrderableDBInstanceOptionsPagesWithContext(arg0 context.Context, arg1 *rds.DescribeOrderableDBInstanceOptionsInput, arg2 func(*rds.DescribeOrderableDBInstanceOptionsOutput, bool) bool, arg3 ...request.Option) error { 4893 m.ctrl.T.Helper() 4894 varargs := []interface{}{arg0, arg1, arg2} 4895 for _, a := range arg3 { 4896 varargs = append(varargs, a) 4897 } 4898 ret := m.ctrl.Call(m, "DescribeOrderableDBInstanceOptionsPagesWithContext", varargs...) 4899 ret0, _ := ret[0].(error) 4900 return ret0 4901 } 4902 4903 // DescribeOrderableDBInstanceOptionsPagesWithContext indicates an expected call of DescribeOrderableDBInstanceOptionsPagesWithContext 4904 func (mr *MockRDSAPIMockRecorder) DescribeOrderableDBInstanceOptionsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 4905 mr.mock.ctrl.T.Helper() 4906 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 4907 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeOrderableDBInstanceOptionsPagesWithContext", reflect.TypeOf((*MockRDSAPI)(nil).DescribeOrderableDBInstanceOptionsPagesWithContext), varargs...) 4908 } 4909 4910 // DescribeOrderableDBInstanceOptionsRequest mocks base method 4911 func (m *MockRDSAPI) DescribeOrderableDBInstanceOptionsRequest(arg0 *rds.DescribeOrderableDBInstanceOptionsInput) (*request.Request, *rds.DescribeOrderableDBInstanceOptionsOutput) { 4912 m.ctrl.T.Helper() 4913 ret := m.ctrl.Call(m, "DescribeOrderableDBInstanceOptionsRequest", arg0) 4914 ret0, _ := ret[0].(*request.Request) 4915 ret1, _ := ret[1].(*rds.DescribeOrderableDBInstanceOptionsOutput) 4916 return ret0, ret1 4917 } 4918 4919 // DescribeOrderableDBInstanceOptionsRequest indicates an expected call of DescribeOrderableDBInstanceOptionsRequest 4920 func (mr *MockRDSAPIMockRecorder) DescribeOrderableDBInstanceOptionsRequest(arg0 interface{}) *gomock.Call { 4921 mr.mock.ctrl.T.Helper() 4922 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeOrderableDBInstanceOptionsRequest", reflect.TypeOf((*MockRDSAPI)(nil).DescribeOrderableDBInstanceOptionsRequest), arg0) 4923 } 4924 4925 // DescribeOrderableDBInstanceOptionsWithContext mocks base method 4926 func (m *MockRDSAPI) DescribeOrderableDBInstanceOptionsWithContext(arg0 context.Context, arg1 *rds.DescribeOrderableDBInstanceOptionsInput, arg2 ...request.Option) (*rds.DescribeOrderableDBInstanceOptionsOutput, error) { 4927 m.ctrl.T.Helper() 4928 varargs := []interface{}{arg0, arg1} 4929 for _, a := range arg2 { 4930 varargs = append(varargs, a) 4931 } 4932 ret := m.ctrl.Call(m, "DescribeOrderableDBInstanceOptionsWithContext", varargs...) 4933 ret0, _ := ret[0].(*rds.DescribeOrderableDBInstanceOptionsOutput) 4934 ret1, _ := ret[1].(error) 4935 return ret0, ret1 4936 } 4937 4938 // DescribeOrderableDBInstanceOptionsWithContext indicates an expected call of DescribeOrderableDBInstanceOptionsWithContext 4939 func (mr *MockRDSAPIMockRecorder) DescribeOrderableDBInstanceOptionsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 4940 mr.mock.ctrl.T.Helper() 4941 varargs := append([]interface{}{arg0, arg1}, arg2...) 4942 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeOrderableDBInstanceOptionsWithContext", reflect.TypeOf((*MockRDSAPI)(nil).DescribeOrderableDBInstanceOptionsWithContext), varargs...) 4943 } 4944 4945 // DescribePendingMaintenanceActions mocks base method 4946 func (m *MockRDSAPI) DescribePendingMaintenanceActions(arg0 *rds.DescribePendingMaintenanceActionsInput) (*rds.DescribePendingMaintenanceActionsOutput, error) { 4947 m.ctrl.T.Helper() 4948 ret := m.ctrl.Call(m, "DescribePendingMaintenanceActions", arg0) 4949 ret0, _ := ret[0].(*rds.DescribePendingMaintenanceActionsOutput) 4950 ret1, _ := ret[1].(error) 4951 return ret0, ret1 4952 } 4953 4954 // DescribePendingMaintenanceActions indicates an expected call of DescribePendingMaintenanceActions 4955 func (mr *MockRDSAPIMockRecorder) DescribePendingMaintenanceActions(arg0 interface{}) *gomock.Call { 4956 mr.mock.ctrl.T.Helper() 4957 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePendingMaintenanceActions", reflect.TypeOf((*MockRDSAPI)(nil).DescribePendingMaintenanceActions), arg0) 4958 } 4959 4960 // DescribePendingMaintenanceActionsPages mocks base method 4961 func (m *MockRDSAPI) DescribePendingMaintenanceActionsPages(arg0 *rds.DescribePendingMaintenanceActionsInput, arg1 func(*rds.DescribePendingMaintenanceActionsOutput, bool) bool) error { 4962 m.ctrl.T.Helper() 4963 ret := m.ctrl.Call(m, "DescribePendingMaintenanceActionsPages", arg0, arg1) 4964 ret0, _ := ret[0].(error) 4965 return ret0 4966 } 4967 4968 // DescribePendingMaintenanceActionsPages indicates an expected call of DescribePendingMaintenanceActionsPages 4969 func (mr *MockRDSAPIMockRecorder) DescribePendingMaintenanceActionsPages(arg0, arg1 interface{}) *gomock.Call { 4970 mr.mock.ctrl.T.Helper() 4971 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePendingMaintenanceActionsPages", reflect.TypeOf((*MockRDSAPI)(nil).DescribePendingMaintenanceActionsPages), arg0, arg1) 4972 } 4973 4974 // DescribePendingMaintenanceActionsPagesWithContext mocks base method 4975 func (m *MockRDSAPI) DescribePendingMaintenanceActionsPagesWithContext(arg0 context.Context, arg1 *rds.DescribePendingMaintenanceActionsInput, arg2 func(*rds.DescribePendingMaintenanceActionsOutput, bool) bool, arg3 ...request.Option) error { 4976 m.ctrl.T.Helper() 4977 varargs := []interface{}{arg0, arg1, arg2} 4978 for _, a := range arg3 { 4979 varargs = append(varargs, a) 4980 } 4981 ret := m.ctrl.Call(m, "DescribePendingMaintenanceActionsPagesWithContext", varargs...) 4982 ret0, _ := ret[0].(error) 4983 return ret0 4984 } 4985 4986 // DescribePendingMaintenanceActionsPagesWithContext indicates an expected call of DescribePendingMaintenanceActionsPagesWithContext 4987 func (mr *MockRDSAPIMockRecorder) DescribePendingMaintenanceActionsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 4988 mr.mock.ctrl.T.Helper() 4989 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 4990 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePendingMaintenanceActionsPagesWithContext", reflect.TypeOf((*MockRDSAPI)(nil).DescribePendingMaintenanceActionsPagesWithContext), varargs...) 4991 } 4992 4993 // DescribePendingMaintenanceActionsRequest mocks base method 4994 func (m *MockRDSAPI) DescribePendingMaintenanceActionsRequest(arg0 *rds.DescribePendingMaintenanceActionsInput) (*request.Request, *rds.DescribePendingMaintenanceActionsOutput) { 4995 m.ctrl.T.Helper() 4996 ret := m.ctrl.Call(m, "DescribePendingMaintenanceActionsRequest", arg0) 4997 ret0, _ := ret[0].(*request.Request) 4998 ret1, _ := ret[1].(*rds.DescribePendingMaintenanceActionsOutput) 4999 return ret0, ret1 5000 } 5001 5002 // DescribePendingMaintenanceActionsRequest indicates an expected call of DescribePendingMaintenanceActionsRequest 5003 func (mr *MockRDSAPIMockRecorder) DescribePendingMaintenanceActionsRequest(arg0 interface{}) *gomock.Call { 5004 mr.mock.ctrl.T.Helper() 5005 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePendingMaintenanceActionsRequest", reflect.TypeOf((*MockRDSAPI)(nil).DescribePendingMaintenanceActionsRequest), arg0) 5006 } 5007 5008 // DescribePendingMaintenanceActionsWithContext mocks base method 5009 func (m *MockRDSAPI) DescribePendingMaintenanceActionsWithContext(arg0 context.Context, arg1 *rds.DescribePendingMaintenanceActionsInput, arg2 ...request.Option) (*rds.DescribePendingMaintenanceActionsOutput, error) { 5010 m.ctrl.T.Helper() 5011 varargs := []interface{}{arg0, arg1} 5012 for _, a := range arg2 { 5013 varargs = append(varargs, a) 5014 } 5015 ret := m.ctrl.Call(m, "DescribePendingMaintenanceActionsWithContext", varargs...) 5016 ret0, _ := ret[0].(*rds.DescribePendingMaintenanceActionsOutput) 5017 ret1, _ := ret[1].(error) 5018 return ret0, ret1 5019 } 5020 5021 // DescribePendingMaintenanceActionsWithContext indicates an expected call of DescribePendingMaintenanceActionsWithContext 5022 func (mr *MockRDSAPIMockRecorder) DescribePendingMaintenanceActionsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 5023 mr.mock.ctrl.T.Helper() 5024 varargs := append([]interface{}{arg0, arg1}, arg2...) 5025 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePendingMaintenanceActionsWithContext", reflect.TypeOf((*MockRDSAPI)(nil).DescribePendingMaintenanceActionsWithContext), varargs...) 5026 } 5027 5028 // DescribeReservedDBInstances mocks base method 5029 func (m *MockRDSAPI) DescribeReservedDBInstances(arg0 *rds.DescribeReservedDBInstancesInput) (*rds.DescribeReservedDBInstancesOutput, error) { 5030 m.ctrl.T.Helper() 5031 ret := m.ctrl.Call(m, "DescribeReservedDBInstances", arg0) 5032 ret0, _ := ret[0].(*rds.DescribeReservedDBInstancesOutput) 5033 ret1, _ := ret[1].(error) 5034 return ret0, ret1 5035 } 5036 5037 // DescribeReservedDBInstances indicates an expected call of DescribeReservedDBInstances 5038 func (mr *MockRDSAPIMockRecorder) DescribeReservedDBInstances(arg0 interface{}) *gomock.Call { 5039 mr.mock.ctrl.T.Helper() 5040 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReservedDBInstances", reflect.TypeOf((*MockRDSAPI)(nil).DescribeReservedDBInstances), arg0) 5041 } 5042 5043 // DescribeReservedDBInstancesOfferings mocks base method 5044 func (m *MockRDSAPI) DescribeReservedDBInstancesOfferings(arg0 *rds.DescribeReservedDBInstancesOfferingsInput) (*rds.DescribeReservedDBInstancesOfferingsOutput, error) { 5045 m.ctrl.T.Helper() 5046 ret := m.ctrl.Call(m, "DescribeReservedDBInstancesOfferings", arg0) 5047 ret0, _ := ret[0].(*rds.DescribeReservedDBInstancesOfferingsOutput) 5048 ret1, _ := ret[1].(error) 5049 return ret0, ret1 5050 } 5051 5052 // DescribeReservedDBInstancesOfferings indicates an expected call of DescribeReservedDBInstancesOfferings 5053 func (mr *MockRDSAPIMockRecorder) DescribeReservedDBInstancesOfferings(arg0 interface{}) *gomock.Call { 5054 mr.mock.ctrl.T.Helper() 5055 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReservedDBInstancesOfferings", reflect.TypeOf((*MockRDSAPI)(nil).DescribeReservedDBInstancesOfferings), arg0) 5056 } 5057 5058 // DescribeReservedDBInstancesOfferingsPages mocks base method 5059 func (m *MockRDSAPI) DescribeReservedDBInstancesOfferingsPages(arg0 *rds.DescribeReservedDBInstancesOfferingsInput, arg1 func(*rds.DescribeReservedDBInstancesOfferingsOutput, bool) bool) error { 5060 m.ctrl.T.Helper() 5061 ret := m.ctrl.Call(m, "DescribeReservedDBInstancesOfferingsPages", arg0, arg1) 5062 ret0, _ := ret[0].(error) 5063 return ret0 5064 } 5065 5066 // DescribeReservedDBInstancesOfferingsPages indicates an expected call of DescribeReservedDBInstancesOfferingsPages 5067 func (mr *MockRDSAPIMockRecorder) DescribeReservedDBInstancesOfferingsPages(arg0, arg1 interface{}) *gomock.Call { 5068 mr.mock.ctrl.T.Helper() 5069 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReservedDBInstancesOfferingsPages", reflect.TypeOf((*MockRDSAPI)(nil).DescribeReservedDBInstancesOfferingsPages), arg0, arg1) 5070 } 5071 5072 // DescribeReservedDBInstancesOfferingsPagesWithContext mocks base method 5073 func (m *MockRDSAPI) DescribeReservedDBInstancesOfferingsPagesWithContext(arg0 context.Context, arg1 *rds.DescribeReservedDBInstancesOfferingsInput, arg2 func(*rds.DescribeReservedDBInstancesOfferingsOutput, bool) bool, arg3 ...request.Option) error { 5074 m.ctrl.T.Helper() 5075 varargs := []interface{}{arg0, arg1, arg2} 5076 for _, a := range arg3 { 5077 varargs = append(varargs, a) 5078 } 5079 ret := m.ctrl.Call(m, "DescribeReservedDBInstancesOfferingsPagesWithContext", varargs...) 5080 ret0, _ := ret[0].(error) 5081 return ret0 5082 } 5083 5084 // DescribeReservedDBInstancesOfferingsPagesWithContext indicates an expected call of DescribeReservedDBInstancesOfferingsPagesWithContext 5085 func (mr *MockRDSAPIMockRecorder) DescribeReservedDBInstancesOfferingsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 5086 mr.mock.ctrl.T.Helper() 5087 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 5088 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReservedDBInstancesOfferingsPagesWithContext", reflect.TypeOf((*MockRDSAPI)(nil).DescribeReservedDBInstancesOfferingsPagesWithContext), varargs...) 5089 } 5090 5091 // DescribeReservedDBInstancesOfferingsRequest mocks base method 5092 func (m *MockRDSAPI) DescribeReservedDBInstancesOfferingsRequest(arg0 *rds.DescribeReservedDBInstancesOfferingsInput) (*request.Request, *rds.DescribeReservedDBInstancesOfferingsOutput) { 5093 m.ctrl.T.Helper() 5094 ret := m.ctrl.Call(m, "DescribeReservedDBInstancesOfferingsRequest", arg0) 5095 ret0, _ := ret[0].(*request.Request) 5096 ret1, _ := ret[1].(*rds.DescribeReservedDBInstancesOfferingsOutput) 5097 return ret0, ret1 5098 } 5099 5100 // DescribeReservedDBInstancesOfferingsRequest indicates an expected call of DescribeReservedDBInstancesOfferingsRequest 5101 func (mr *MockRDSAPIMockRecorder) DescribeReservedDBInstancesOfferingsRequest(arg0 interface{}) *gomock.Call { 5102 mr.mock.ctrl.T.Helper() 5103 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReservedDBInstancesOfferingsRequest", reflect.TypeOf((*MockRDSAPI)(nil).DescribeReservedDBInstancesOfferingsRequest), arg0) 5104 } 5105 5106 // DescribeReservedDBInstancesOfferingsWithContext mocks base method 5107 func (m *MockRDSAPI) DescribeReservedDBInstancesOfferingsWithContext(arg0 context.Context, arg1 *rds.DescribeReservedDBInstancesOfferingsInput, arg2 ...request.Option) (*rds.DescribeReservedDBInstancesOfferingsOutput, error) { 5108 m.ctrl.T.Helper() 5109 varargs := []interface{}{arg0, arg1} 5110 for _, a := range arg2 { 5111 varargs = append(varargs, a) 5112 } 5113 ret := m.ctrl.Call(m, "DescribeReservedDBInstancesOfferingsWithContext", varargs...) 5114 ret0, _ := ret[0].(*rds.DescribeReservedDBInstancesOfferingsOutput) 5115 ret1, _ := ret[1].(error) 5116 return ret0, ret1 5117 } 5118 5119 // DescribeReservedDBInstancesOfferingsWithContext indicates an expected call of DescribeReservedDBInstancesOfferingsWithContext 5120 func (mr *MockRDSAPIMockRecorder) DescribeReservedDBInstancesOfferingsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 5121 mr.mock.ctrl.T.Helper() 5122 varargs := append([]interface{}{arg0, arg1}, arg2...) 5123 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReservedDBInstancesOfferingsWithContext", reflect.TypeOf((*MockRDSAPI)(nil).DescribeReservedDBInstancesOfferingsWithContext), varargs...) 5124 } 5125 5126 // DescribeReservedDBInstancesPages mocks base method 5127 func (m *MockRDSAPI) DescribeReservedDBInstancesPages(arg0 *rds.DescribeReservedDBInstancesInput, arg1 func(*rds.DescribeReservedDBInstancesOutput, bool) bool) error { 5128 m.ctrl.T.Helper() 5129 ret := m.ctrl.Call(m, "DescribeReservedDBInstancesPages", arg0, arg1) 5130 ret0, _ := ret[0].(error) 5131 return ret0 5132 } 5133 5134 // DescribeReservedDBInstancesPages indicates an expected call of DescribeReservedDBInstancesPages 5135 func (mr *MockRDSAPIMockRecorder) DescribeReservedDBInstancesPages(arg0, arg1 interface{}) *gomock.Call { 5136 mr.mock.ctrl.T.Helper() 5137 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReservedDBInstancesPages", reflect.TypeOf((*MockRDSAPI)(nil).DescribeReservedDBInstancesPages), arg0, arg1) 5138 } 5139 5140 // DescribeReservedDBInstancesPagesWithContext mocks base method 5141 func (m *MockRDSAPI) DescribeReservedDBInstancesPagesWithContext(arg0 context.Context, arg1 *rds.DescribeReservedDBInstancesInput, arg2 func(*rds.DescribeReservedDBInstancesOutput, bool) bool, arg3 ...request.Option) error { 5142 m.ctrl.T.Helper() 5143 varargs := []interface{}{arg0, arg1, arg2} 5144 for _, a := range arg3 { 5145 varargs = append(varargs, a) 5146 } 5147 ret := m.ctrl.Call(m, "DescribeReservedDBInstancesPagesWithContext", varargs...) 5148 ret0, _ := ret[0].(error) 5149 return ret0 5150 } 5151 5152 // DescribeReservedDBInstancesPagesWithContext indicates an expected call of DescribeReservedDBInstancesPagesWithContext 5153 func (mr *MockRDSAPIMockRecorder) DescribeReservedDBInstancesPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 5154 mr.mock.ctrl.T.Helper() 5155 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 5156 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReservedDBInstancesPagesWithContext", reflect.TypeOf((*MockRDSAPI)(nil).DescribeReservedDBInstancesPagesWithContext), varargs...) 5157 } 5158 5159 // DescribeReservedDBInstancesRequest mocks base method 5160 func (m *MockRDSAPI) DescribeReservedDBInstancesRequest(arg0 *rds.DescribeReservedDBInstancesInput) (*request.Request, *rds.DescribeReservedDBInstancesOutput) { 5161 m.ctrl.T.Helper() 5162 ret := m.ctrl.Call(m, "DescribeReservedDBInstancesRequest", arg0) 5163 ret0, _ := ret[0].(*request.Request) 5164 ret1, _ := ret[1].(*rds.DescribeReservedDBInstancesOutput) 5165 return ret0, ret1 5166 } 5167 5168 // DescribeReservedDBInstancesRequest indicates an expected call of DescribeReservedDBInstancesRequest 5169 func (mr *MockRDSAPIMockRecorder) DescribeReservedDBInstancesRequest(arg0 interface{}) *gomock.Call { 5170 mr.mock.ctrl.T.Helper() 5171 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReservedDBInstancesRequest", reflect.TypeOf((*MockRDSAPI)(nil).DescribeReservedDBInstancesRequest), arg0) 5172 } 5173 5174 // DescribeReservedDBInstancesWithContext mocks base method 5175 func (m *MockRDSAPI) DescribeReservedDBInstancesWithContext(arg0 context.Context, arg1 *rds.DescribeReservedDBInstancesInput, arg2 ...request.Option) (*rds.DescribeReservedDBInstancesOutput, error) { 5176 m.ctrl.T.Helper() 5177 varargs := []interface{}{arg0, arg1} 5178 for _, a := range arg2 { 5179 varargs = append(varargs, a) 5180 } 5181 ret := m.ctrl.Call(m, "DescribeReservedDBInstancesWithContext", varargs...) 5182 ret0, _ := ret[0].(*rds.DescribeReservedDBInstancesOutput) 5183 ret1, _ := ret[1].(error) 5184 return ret0, ret1 5185 } 5186 5187 // DescribeReservedDBInstancesWithContext indicates an expected call of DescribeReservedDBInstancesWithContext 5188 func (mr *MockRDSAPIMockRecorder) DescribeReservedDBInstancesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 5189 mr.mock.ctrl.T.Helper() 5190 varargs := append([]interface{}{arg0, arg1}, arg2...) 5191 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReservedDBInstancesWithContext", reflect.TypeOf((*MockRDSAPI)(nil).DescribeReservedDBInstancesWithContext), varargs...) 5192 } 5193 5194 // DescribeSourceRegions mocks base method 5195 func (m *MockRDSAPI) DescribeSourceRegions(arg0 *rds.DescribeSourceRegionsInput) (*rds.DescribeSourceRegionsOutput, error) { 5196 m.ctrl.T.Helper() 5197 ret := m.ctrl.Call(m, "DescribeSourceRegions", arg0) 5198 ret0, _ := ret[0].(*rds.DescribeSourceRegionsOutput) 5199 ret1, _ := ret[1].(error) 5200 return ret0, ret1 5201 } 5202 5203 // DescribeSourceRegions indicates an expected call of DescribeSourceRegions 5204 func (mr *MockRDSAPIMockRecorder) DescribeSourceRegions(arg0 interface{}) *gomock.Call { 5205 mr.mock.ctrl.T.Helper() 5206 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSourceRegions", reflect.TypeOf((*MockRDSAPI)(nil).DescribeSourceRegions), arg0) 5207 } 5208 5209 // DescribeSourceRegionsPages mocks base method 5210 func (m *MockRDSAPI) DescribeSourceRegionsPages(arg0 *rds.DescribeSourceRegionsInput, arg1 func(*rds.DescribeSourceRegionsOutput, bool) bool) error { 5211 m.ctrl.T.Helper() 5212 ret := m.ctrl.Call(m, "DescribeSourceRegionsPages", arg0, arg1) 5213 ret0, _ := ret[0].(error) 5214 return ret0 5215 } 5216 5217 // DescribeSourceRegionsPages indicates an expected call of DescribeSourceRegionsPages 5218 func (mr *MockRDSAPIMockRecorder) DescribeSourceRegionsPages(arg0, arg1 interface{}) *gomock.Call { 5219 mr.mock.ctrl.T.Helper() 5220 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSourceRegionsPages", reflect.TypeOf((*MockRDSAPI)(nil).DescribeSourceRegionsPages), arg0, arg1) 5221 } 5222 5223 // DescribeSourceRegionsPagesWithContext mocks base method 5224 func (m *MockRDSAPI) DescribeSourceRegionsPagesWithContext(arg0 context.Context, arg1 *rds.DescribeSourceRegionsInput, arg2 func(*rds.DescribeSourceRegionsOutput, bool) bool, arg3 ...request.Option) error { 5225 m.ctrl.T.Helper() 5226 varargs := []interface{}{arg0, arg1, arg2} 5227 for _, a := range arg3 { 5228 varargs = append(varargs, a) 5229 } 5230 ret := m.ctrl.Call(m, "DescribeSourceRegionsPagesWithContext", varargs...) 5231 ret0, _ := ret[0].(error) 5232 return ret0 5233 } 5234 5235 // DescribeSourceRegionsPagesWithContext indicates an expected call of DescribeSourceRegionsPagesWithContext 5236 func (mr *MockRDSAPIMockRecorder) DescribeSourceRegionsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 5237 mr.mock.ctrl.T.Helper() 5238 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 5239 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSourceRegionsPagesWithContext", reflect.TypeOf((*MockRDSAPI)(nil).DescribeSourceRegionsPagesWithContext), varargs...) 5240 } 5241 5242 // DescribeSourceRegionsRequest mocks base method 5243 func (m *MockRDSAPI) DescribeSourceRegionsRequest(arg0 *rds.DescribeSourceRegionsInput) (*request.Request, *rds.DescribeSourceRegionsOutput) { 5244 m.ctrl.T.Helper() 5245 ret := m.ctrl.Call(m, "DescribeSourceRegionsRequest", arg0) 5246 ret0, _ := ret[0].(*request.Request) 5247 ret1, _ := ret[1].(*rds.DescribeSourceRegionsOutput) 5248 return ret0, ret1 5249 } 5250 5251 // DescribeSourceRegionsRequest indicates an expected call of DescribeSourceRegionsRequest 5252 func (mr *MockRDSAPIMockRecorder) DescribeSourceRegionsRequest(arg0 interface{}) *gomock.Call { 5253 mr.mock.ctrl.T.Helper() 5254 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSourceRegionsRequest", reflect.TypeOf((*MockRDSAPI)(nil).DescribeSourceRegionsRequest), arg0) 5255 } 5256 5257 // DescribeSourceRegionsWithContext mocks base method 5258 func (m *MockRDSAPI) DescribeSourceRegionsWithContext(arg0 context.Context, arg1 *rds.DescribeSourceRegionsInput, arg2 ...request.Option) (*rds.DescribeSourceRegionsOutput, error) { 5259 m.ctrl.T.Helper() 5260 varargs := []interface{}{arg0, arg1} 5261 for _, a := range arg2 { 5262 varargs = append(varargs, a) 5263 } 5264 ret := m.ctrl.Call(m, "DescribeSourceRegionsWithContext", varargs...) 5265 ret0, _ := ret[0].(*rds.DescribeSourceRegionsOutput) 5266 ret1, _ := ret[1].(error) 5267 return ret0, ret1 5268 } 5269 5270 // DescribeSourceRegionsWithContext indicates an expected call of DescribeSourceRegionsWithContext 5271 func (mr *MockRDSAPIMockRecorder) DescribeSourceRegionsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 5272 mr.mock.ctrl.T.Helper() 5273 varargs := append([]interface{}{arg0, arg1}, arg2...) 5274 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSourceRegionsWithContext", reflect.TypeOf((*MockRDSAPI)(nil).DescribeSourceRegionsWithContext), varargs...) 5275 } 5276 5277 // DescribeValidDBInstanceModifications mocks base method 5278 func (m *MockRDSAPI) DescribeValidDBInstanceModifications(arg0 *rds.DescribeValidDBInstanceModificationsInput) (*rds.DescribeValidDBInstanceModificationsOutput, error) { 5279 m.ctrl.T.Helper() 5280 ret := m.ctrl.Call(m, "DescribeValidDBInstanceModifications", arg0) 5281 ret0, _ := ret[0].(*rds.DescribeValidDBInstanceModificationsOutput) 5282 ret1, _ := ret[1].(error) 5283 return ret0, ret1 5284 } 5285 5286 // DescribeValidDBInstanceModifications indicates an expected call of DescribeValidDBInstanceModifications 5287 func (mr *MockRDSAPIMockRecorder) DescribeValidDBInstanceModifications(arg0 interface{}) *gomock.Call { 5288 mr.mock.ctrl.T.Helper() 5289 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeValidDBInstanceModifications", reflect.TypeOf((*MockRDSAPI)(nil).DescribeValidDBInstanceModifications), arg0) 5290 } 5291 5292 // DescribeValidDBInstanceModificationsRequest mocks base method 5293 func (m *MockRDSAPI) DescribeValidDBInstanceModificationsRequest(arg0 *rds.DescribeValidDBInstanceModificationsInput) (*request.Request, *rds.DescribeValidDBInstanceModificationsOutput) { 5294 m.ctrl.T.Helper() 5295 ret := m.ctrl.Call(m, "DescribeValidDBInstanceModificationsRequest", arg0) 5296 ret0, _ := ret[0].(*request.Request) 5297 ret1, _ := ret[1].(*rds.DescribeValidDBInstanceModificationsOutput) 5298 return ret0, ret1 5299 } 5300 5301 // DescribeValidDBInstanceModificationsRequest indicates an expected call of DescribeValidDBInstanceModificationsRequest 5302 func (mr *MockRDSAPIMockRecorder) DescribeValidDBInstanceModificationsRequest(arg0 interface{}) *gomock.Call { 5303 mr.mock.ctrl.T.Helper() 5304 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeValidDBInstanceModificationsRequest", reflect.TypeOf((*MockRDSAPI)(nil).DescribeValidDBInstanceModificationsRequest), arg0) 5305 } 5306 5307 // DescribeValidDBInstanceModificationsWithContext mocks base method 5308 func (m *MockRDSAPI) DescribeValidDBInstanceModificationsWithContext(arg0 context.Context, arg1 *rds.DescribeValidDBInstanceModificationsInput, arg2 ...request.Option) (*rds.DescribeValidDBInstanceModificationsOutput, error) { 5309 m.ctrl.T.Helper() 5310 varargs := []interface{}{arg0, arg1} 5311 for _, a := range arg2 { 5312 varargs = append(varargs, a) 5313 } 5314 ret := m.ctrl.Call(m, "DescribeValidDBInstanceModificationsWithContext", varargs...) 5315 ret0, _ := ret[0].(*rds.DescribeValidDBInstanceModificationsOutput) 5316 ret1, _ := ret[1].(error) 5317 return ret0, ret1 5318 } 5319 5320 // DescribeValidDBInstanceModificationsWithContext indicates an expected call of DescribeValidDBInstanceModificationsWithContext 5321 func (mr *MockRDSAPIMockRecorder) DescribeValidDBInstanceModificationsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 5322 mr.mock.ctrl.T.Helper() 5323 varargs := append([]interface{}{arg0, arg1}, arg2...) 5324 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeValidDBInstanceModificationsWithContext", reflect.TypeOf((*MockRDSAPI)(nil).DescribeValidDBInstanceModificationsWithContext), varargs...) 5325 } 5326 5327 // DownloadDBLogFilePortion mocks base method 5328 func (m *MockRDSAPI) DownloadDBLogFilePortion(arg0 *rds.DownloadDBLogFilePortionInput) (*rds.DownloadDBLogFilePortionOutput, error) { 5329 m.ctrl.T.Helper() 5330 ret := m.ctrl.Call(m, "DownloadDBLogFilePortion", arg0) 5331 ret0, _ := ret[0].(*rds.DownloadDBLogFilePortionOutput) 5332 ret1, _ := ret[1].(error) 5333 return ret0, ret1 5334 } 5335 5336 // DownloadDBLogFilePortion indicates an expected call of DownloadDBLogFilePortion 5337 func (mr *MockRDSAPIMockRecorder) DownloadDBLogFilePortion(arg0 interface{}) *gomock.Call { 5338 mr.mock.ctrl.T.Helper() 5339 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DownloadDBLogFilePortion", reflect.TypeOf((*MockRDSAPI)(nil).DownloadDBLogFilePortion), arg0) 5340 } 5341 5342 // DownloadDBLogFilePortionPages mocks base method 5343 func (m *MockRDSAPI) DownloadDBLogFilePortionPages(arg0 *rds.DownloadDBLogFilePortionInput, arg1 func(*rds.DownloadDBLogFilePortionOutput, bool) bool) error { 5344 m.ctrl.T.Helper() 5345 ret := m.ctrl.Call(m, "DownloadDBLogFilePortionPages", arg0, arg1) 5346 ret0, _ := ret[0].(error) 5347 return ret0 5348 } 5349 5350 // DownloadDBLogFilePortionPages indicates an expected call of DownloadDBLogFilePortionPages 5351 func (mr *MockRDSAPIMockRecorder) DownloadDBLogFilePortionPages(arg0, arg1 interface{}) *gomock.Call { 5352 mr.mock.ctrl.T.Helper() 5353 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DownloadDBLogFilePortionPages", reflect.TypeOf((*MockRDSAPI)(nil).DownloadDBLogFilePortionPages), arg0, arg1) 5354 } 5355 5356 // DownloadDBLogFilePortionPagesWithContext mocks base method 5357 func (m *MockRDSAPI) DownloadDBLogFilePortionPagesWithContext(arg0 context.Context, arg1 *rds.DownloadDBLogFilePortionInput, arg2 func(*rds.DownloadDBLogFilePortionOutput, bool) bool, arg3 ...request.Option) error { 5358 m.ctrl.T.Helper() 5359 varargs := []interface{}{arg0, arg1, arg2} 5360 for _, a := range arg3 { 5361 varargs = append(varargs, a) 5362 } 5363 ret := m.ctrl.Call(m, "DownloadDBLogFilePortionPagesWithContext", varargs...) 5364 ret0, _ := ret[0].(error) 5365 return ret0 5366 } 5367 5368 // DownloadDBLogFilePortionPagesWithContext indicates an expected call of DownloadDBLogFilePortionPagesWithContext 5369 func (mr *MockRDSAPIMockRecorder) DownloadDBLogFilePortionPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 5370 mr.mock.ctrl.T.Helper() 5371 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 5372 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DownloadDBLogFilePortionPagesWithContext", reflect.TypeOf((*MockRDSAPI)(nil).DownloadDBLogFilePortionPagesWithContext), varargs...) 5373 } 5374 5375 // DownloadDBLogFilePortionRequest mocks base method 5376 func (m *MockRDSAPI) DownloadDBLogFilePortionRequest(arg0 *rds.DownloadDBLogFilePortionInput) (*request.Request, *rds.DownloadDBLogFilePortionOutput) { 5377 m.ctrl.T.Helper() 5378 ret := m.ctrl.Call(m, "DownloadDBLogFilePortionRequest", arg0) 5379 ret0, _ := ret[0].(*request.Request) 5380 ret1, _ := ret[1].(*rds.DownloadDBLogFilePortionOutput) 5381 return ret0, ret1 5382 } 5383 5384 // DownloadDBLogFilePortionRequest indicates an expected call of DownloadDBLogFilePortionRequest 5385 func (mr *MockRDSAPIMockRecorder) DownloadDBLogFilePortionRequest(arg0 interface{}) *gomock.Call { 5386 mr.mock.ctrl.T.Helper() 5387 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DownloadDBLogFilePortionRequest", reflect.TypeOf((*MockRDSAPI)(nil).DownloadDBLogFilePortionRequest), arg0) 5388 } 5389 5390 // DownloadDBLogFilePortionWithContext mocks base method 5391 func (m *MockRDSAPI) DownloadDBLogFilePortionWithContext(arg0 context.Context, arg1 *rds.DownloadDBLogFilePortionInput, arg2 ...request.Option) (*rds.DownloadDBLogFilePortionOutput, error) { 5392 m.ctrl.T.Helper() 5393 varargs := []interface{}{arg0, arg1} 5394 for _, a := range arg2 { 5395 varargs = append(varargs, a) 5396 } 5397 ret := m.ctrl.Call(m, "DownloadDBLogFilePortionWithContext", varargs...) 5398 ret0, _ := ret[0].(*rds.DownloadDBLogFilePortionOutput) 5399 ret1, _ := ret[1].(error) 5400 return ret0, ret1 5401 } 5402 5403 // DownloadDBLogFilePortionWithContext indicates an expected call of DownloadDBLogFilePortionWithContext 5404 func (mr *MockRDSAPIMockRecorder) DownloadDBLogFilePortionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 5405 mr.mock.ctrl.T.Helper() 5406 varargs := append([]interface{}{arg0, arg1}, arg2...) 5407 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DownloadDBLogFilePortionWithContext", reflect.TypeOf((*MockRDSAPI)(nil).DownloadDBLogFilePortionWithContext), varargs...) 5408 } 5409 5410 // FailoverDBCluster mocks base method 5411 func (m *MockRDSAPI) FailoverDBCluster(arg0 *rds.FailoverDBClusterInput) (*rds.FailoverDBClusterOutput, error) { 5412 m.ctrl.T.Helper() 5413 ret := m.ctrl.Call(m, "FailoverDBCluster", arg0) 5414 ret0, _ := ret[0].(*rds.FailoverDBClusterOutput) 5415 ret1, _ := ret[1].(error) 5416 return ret0, ret1 5417 } 5418 5419 // FailoverDBCluster indicates an expected call of FailoverDBCluster 5420 func (mr *MockRDSAPIMockRecorder) FailoverDBCluster(arg0 interface{}) *gomock.Call { 5421 mr.mock.ctrl.T.Helper() 5422 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FailoverDBCluster", reflect.TypeOf((*MockRDSAPI)(nil).FailoverDBCluster), arg0) 5423 } 5424 5425 // FailoverDBClusterRequest mocks base method 5426 func (m *MockRDSAPI) FailoverDBClusterRequest(arg0 *rds.FailoverDBClusterInput) (*request.Request, *rds.FailoverDBClusterOutput) { 5427 m.ctrl.T.Helper() 5428 ret := m.ctrl.Call(m, "FailoverDBClusterRequest", arg0) 5429 ret0, _ := ret[0].(*request.Request) 5430 ret1, _ := ret[1].(*rds.FailoverDBClusterOutput) 5431 return ret0, ret1 5432 } 5433 5434 // FailoverDBClusterRequest indicates an expected call of FailoverDBClusterRequest 5435 func (mr *MockRDSAPIMockRecorder) FailoverDBClusterRequest(arg0 interface{}) *gomock.Call { 5436 mr.mock.ctrl.T.Helper() 5437 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FailoverDBClusterRequest", reflect.TypeOf((*MockRDSAPI)(nil).FailoverDBClusterRequest), arg0) 5438 } 5439 5440 // FailoverDBClusterWithContext mocks base method 5441 func (m *MockRDSAPI) FailoverDBClusterWithContext(arg0 context.Context, arg1 *rds.FailoverDBClusterInput, arg2 ...request.Option) (*rds.FailoverDBClusterOutput, error) { 5442 m.ctrl.T.Helper() 5443 varargs := []interface{}{arg0, arg1} 5444 for _, a := range arg2 { 5445 varargs = append(varargs, a) 5446 } 5447 ret := m.ctrl.Call(m, "FailoverDBClusterWithContext", varargs...) 5448 ret0, _ := ret[0].(*rds.FailoverDBClusterOutput) 5449 ret1, _ := ret[1].(error) 5450 return ret0, ret1 5451 } 5452 5453 // FailoverDBClusterWithContext indicates an expected call of FailoverDBClusterWithContext 5454 func (mr *MockRDSAPIMockRecorder) FailoverDBClusterWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 5455 mr.mock.ctrl.T.Helper() 5456 varargs := append([]interface{}{arg0, arg1}, arg2...) 5457 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FailoverDBClusterWithContext", reflect.TypeOf((*MockRDSAPI)(nil).FailoverDBClusterWithContext), varargs...) 5458 } 5459 5460 // ImportInstallationMedia mocks base method 5461 func (m *MockRDSAPI) ImportInstallationMedia(arg0 *rds.ImportInstallationMediaInput) (*rds.ImportInstallationMediaOutput, error) { 5462 m.ctrl.T.Helper() 5463 ret := m.ctrl.Call(m, "ImportInstallationMedia", arg0) 5464 ret0, _ := ret[0].(*rds.ImportInstallationMediaOutput) 5465 ret1, _ := ret[1].(error) 5466 return ret0, ret1 5467 } 5468 5469 // ImportInstallationMedia indicates an expected call of ImportInstallationMedia 5470 func (mr *MockRDSAPIMockRecorder) ImportInstallationMedia(arg0 interface{}) *gomock.Call { 5471 mr.mock.ctrl.T.Helper() 5472 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportInstallationMedia", reflect.TypeOf((*MockRDSAPI)(nil).ImportInstallationMedia), arg0) 5473 } 5474 5475 // ImportInstallationMediaRequest mocks base method 5476 func (m *MockRDSAPI) ImportInstallationMediaRequest(arg0 *rds.ImportInstallationMediaInput) (*request.Request, *rds.ImportInstallationMediaOutput) { 5477 m.ctrl.T.Helper() 5478 ret := m.ctrl.Call(m, "ImportInstallationMediaRequest", arg0) 5479 ret0, _ := ret[0].(*request.Request) 5480 ret1, _ := ret[1].(*rds.ImportInstallationMediaOutput) 5481 return ret0, ret1 5482 } 5483 5484 // ImportInstallationMediaRequest indicates an expected call of ImportInstallationMediaRequest 5485 func (mr *MockRDSAPIMockRecorder) ImportInstallationMediaRequest(arg0 interface{}) *gomock.Call { 5486 mr.mock.ctrl.T.Helper() 5487 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportInstallationMediaRequest", reflect.TypeOf((*MockRDSAPI)(nil).ImportInstallationMediaRequest), arg0) 5488 } 5489 5490 // ImportInstallationMediaWithContext mocks base method 5491 func (m *MockRDSAPI) ImportInstallationMediaWithContext(arg0 context.Context, arg1 *rds.ImportInstallationMediaInput, arg2 ...request.Option) (*rds.ImportInstallationMediaOutput, error) { 5492 m.ctrl.T.Helper() 5493 varargs := []interface{}{arg0, arg1} 5494 for _, a := range arg2 { 5495 varargs = append(varargs, a) 5496 } 5497 ret := m.ctrl.Call(m, "ImportInstallationMediaWithContext", varargs...) 5498 ret0, _ := ret[0].(*rds.ImportInstallationMediaOutput) 5499 ret1, _ := ret[1].(error) 5500 return ret0, ret1 5501 } 5502 5503 // ImportInstallationMediaWithContext indicates an expected call of ImportInstallationMediaWithContext 5504 func (mr *MockRDSAPIMockRecorder) ImportInstallationMediaWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 5505 mr.mock.ctrl.T.Helper() 5506 varargs := append([]interface{}{arg0, arg1}, arg2...) 5507 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportInstallationMediaWithContext", reflect.TypeOf((*MockRDSAPI)(nil).ImportInstallationMediaWithContext), varargs...) 5508 } 5509 5510 // ListTagsForResource mocks base method 5511 func (m *MockRDSAPI) ListTagsForResource(arg0 *rds.ListTagsForResourceInput) (*rds.ListTagsForResourceOutput, error) { 5512 m.ctrl.T.Helper() 5513 ret := m.ctrl.Call(m, "ListTagsForResource", arg0) 5514 ret0, _ := ret[0].(*rds.ListTagsForResourceOutput) 5515 ret1, _ := ret[1].(error) 5516 return ret0, ret1 5517 } 5518 5519 // ListTagsForResource indicates an expected call of ListTagsForResource 5520 func (mr *MockRDSAPIMockRecorder) ListTagsForResource(arg0 interface{}) *gomock.Call { 5521 mr.mock.ctrl.T.Helper() 5522 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTagsForResource", reflect.TypeOf((*MockRDSAPI)(nil).ListTagsForResource), arg0) 5523 } 5524 5525 // ListTagsForResourceRequest mocks base method 5526 func (m *MockRDSAPI) ListTagsForResourceRequest(arg0 *rds.ListTagsForResourceInput) (*request.Request, *rds.ListTagsForResourceOutput) { 5527 m.ctrl.T.Helper() 5528 ret := m.ctrl.Call(m, "ListTagsForResourceRequest", arg0) 5529 ret0, _ := ret[0].(*request.Request) 5530 ret1, _ := ret[1].(*rds.ListTagsForResourceOutput) 5531 return ret0, ret1 5532 } 5533 5534 // ListTagsForResourceRequest indicates an expected call of ListTagsForResourceRequest 5535 func (mr *MockRDSAPIMockRecorder) ListTagsForResourceRequest(arg0 interface{}) *gomock.Call { 5536 mr.mock.ctrl.T.Helper() 5537 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTagsForResourceRequest", reflect.TypeOf((*MockRDSAPI)(nil).ListTagsForResourceRequest), arg0) 5538 } 5539 5540 // ListTagsForResourceWithContext mocks base method 5541 func (m *MockRDSAPI) ListTagsForResourceWithContext(arg0 context.Context, arg1 *rds.ListTagsForResourceInput, arg2 ...request.Option) (*rds.ListTagsForResourceOutput, error) { 5542 m.ctrl.T.Helper() 5543 varargs := []interface{}{arg0, arg1} 5544 for _, a := range arg2 { 5545 varargs = append(varargs, a) 5546 } 5547 ret := m.ctrl.Call(m, "ListTagsForResourceWithContext", varargs...) 5548 ret0, _ := ret[0].(*rds.ListTagsForResourceOutput) 5549 ret1, _ := ret[1].(error) 5550 return ret0, ret1 5551 } 5552 5553 // ListTagsForResourceWithContext indicates an expected call of ListTagsForResourceWithContext 5554 func (mr *MockRDSAPIMockRecorder) ListTagsForResourceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 5555 mr.mock.ctrl.T.Helper() 5556 varargs := append([]interface{}{arg0, arg1}, arg2...) 5557 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTagsForResourceWithContext", reflect.TypeOf((*MockRDSAPI)(nil).ListTagsForResourceWithContext), varargs...) 5558 } 5559 5560 // ModifyCertificates mocks base method 5561 func (m *MockRDSAPI) ModifyCertificates(arg0 *rds.ModifyCertificatesInput) (*rds.ModifyCertificatesOutput, error) { 5562 m.ctrl.T.Helper() 5563 ret := m.ctrl.Call(m, "ModifyCertificates", arg0) 5564 ret0, _ := ret[0].(*rds.ModifyCertificatesOutput) 5565 ret1, _ := ret[1].(error) 5566 return ret0, ret1 5567 } 5568 5569 // ModifyCertificates indicates an expected call of ModifyCertificates 5570 func (mr *MockRDSAPIMockRecorder) ModifyCertificates(arg0 interface{}) *gomock.Call { 5571 mr.mock.ctrl.T.Helper() 5572 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyCertificates", reflect.TypeOf((*MockRDSAPI)(nil).ModifyCertificates), arg0) 5573 } 5574 5575 // ModifyCertificatesRequest mocks base method 5576 func (m *MockRDSAPI) ModifyCertificatesRequest(arg0 *rds.ModifyCertificatesInput) (*request.Request, *rds.ModifyCertificatesOutput) { 5577 m.ctrl.T.Helper() 5578 ret := m.ctrl.Call(m, "ModifyCertificatesRequest", arg0) 5579 ret0, _ := ret[0].(*request.Request) 5580 ret1, _ := ret[1].(*rds.ModifyCertificatesOutput) 5581 return ret0, ret1 5582 } 5583 5584 // ModifyCertificatesRequest indicates an expected call of ModifyCertificatesRequest 5585 func (mr *MockRDSAPIMockRecorder) ModifyCertificatesRequest(arg0 interface{}) *gomock.Call { 5586 mr.mock.ctrl.T.Helper() 5587 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyCertificatesRequest", reflect.TypeOf((*MockRDSAPI)(nil).ModifyCertificatesRequest), arg0) 5588 } 5589 5590 // ModifyCertificatesWithContext mocks base method 5591 func (m *MockRDSAPI) ModifyCertificatesWithContext(arg0 context.Context, arg1 *rds.ModifyCertificatesInput, arg2 ...request.Option) (*rds.ModifyCertificatesOutput, error) { 5592 m.ctrl.T.Helper() 5593 varargs := []interface{}{arg0, arg1} 5594 for _, a := range arg2 { 5595 varargs = append(varargs, a) 5596 } 5597 ret := m.ctrl.Call(m, "ModifyCertificatesWithContext", varargs...) 5598 ret0, _ := ret[0].(*rds.ModifyCertificatesOutput) 5599 ret1, _ := ret[1].(error) 5600 return ret0, ret1 5601 } 5602 5603 // ModifyCertificatesWithContext indicates an expected call of ModifyCertificatesWithContext 5604 func (mr *MockRDSAPIMockRecorder) ModifyCertificatesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 5605 mr.mock.ctrl.T.Helper() 5606 varargs := append([]interface{}{arg0, arg1}, arg2...) 5607 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyCertificatesWithContext", reflect.TypeOf((*MockRDSAPI)(nil).ModifyCertificatesWithContext), varargs...) 5608 } 5609 5610 // ModifyCurrentDBClusterCapacity mocks base method 5611 func (m *MockRDSAPI) ModifyCurrentDBClusterCapacity(arg0 *rds.ModifyCurrentDBClusterCapacityInput) (*rds.ModifyCurrentDBClusterCapacityOutput, error) { 5612 m.ctrl.T.Helper() 5613 ret := m.ctrl.Call(m, "ModifyCurrentDBClusterCapacity", arg0) 5614 ret0, _ := ret[0].(*rds.ModifyCurrentDBClusterCapacityOutput) 5615 ret1, _ := ret[1].(error) 5616 return ret0, ret1 5617 } 5618 5619 // ModifyCurrentDBClusterCapacity indicates an expected call of ModifyCurrentDBClusterCapacity 5620 func (mr *MockRDSAPIMockRecorder) ModifyCurrentDBClusterCapacity(arg0 interface{}) *gomock.Call { 5621 mr.mock.ctrl.T.Helper() 5622 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyCurrentDBClusterCapacity", reflect.TypeOf((*MockRDSAPI)(nil).ModifyCurrentDBClusterCapacity), arg0) 5623 } 5624 5625 // ModifyCurrentDBClusterCapacityRequest mocks base method 5626 func (m *MockRDSAPI) ModifyCurrentDBClusterCapacityRequest(arg0 *rds.ModifyCurrentDBClusterCapacityInput) (*request.Request, *rds.ModifyCurrentDBClusterCapacityOutput) { 5627 m.ctrl.T.Helper() 5628 ret := m.ctrl.Call(m, "ModifyCurrentDBClusterCapacityRequest", arg0) 5629 ret0, _ := ret[0].(*request.Request) 5630 ret1, _ := ret[1].(*rds.ModifyCurrentDBClusterCapacityOutput) 5631 return ret0, ret1 5632 } 5633 5634 // ModifyCurrentDBClusterCapacityRequest indicates an expected call of ModifyCurrentDBClusterCapacityRequest 5635 func (mr *MockRDSAPIMockRecorder) ModifyCurrentDBClusterCapacityRequest(arg0 interface{}) *gomock.Call { 5636 mr.mock.ctrl.T.Helper() 5637 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyCurrentDBClusterCapacityRequest", reflect.TypeOf((*MockRDSAPI)(nil).ModifyCurrentDBClusterCapacityRequest), arg0) 5638 } 5639 5640 // ModifyCurrentDBClusterCapacityWithContext mocks base method 5641 func (m *MockRDSAPI) ModifyCurrentDBClusterCapacityWithContext(arg0 context.Context, arg1 *rds.ModifyCurrentDBClusterCapacityInput, arg2 ...request.Option) (*rds.ModifyCurrentDBClusterCapacityOutput, error) { 5642 m.ctrl.T.Helper() 5643 varargs := []interface{}{arg0, arg1} 5644 for _, a := range arg2 { 5645 varargs = append(varargs, a) 5646 } 5647 ret := m.ctrl.Call(m, "ModifyCurrentDBClusterCapacityWithContext", varargs...) 5648 ret0, _ := ret[0].(*rds.ModifyCurrentDBClusterCapacityOutput) 5649 ret1, _ := ret[1].(error) 5650 return ret0, ret1 5651 } 5652 5653 // ModifyCurrentDBClusterCapacityWithContext indicates an expected call of ModifyCurrentDBClusterCapacityWithContext 5654 func (mr *MockRDSAPIMockRecorder) ModifyCurrentDBClusterCapacityWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 5655 mr.mock.ctrl.T.Helper() 5656 varargs := append([]interface{}{arg0, arg1}, arg2...) 5657 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyCurrentDBClusterCapacityWithContext", reflect.TypeOf((*MockRDSAPI)(nil).ModifyCurrentDBClusterCapacityWithContext), varargs...) 5658 } 5659 5660 // ModifyDBCluster mocks base method 5661 func (m *MockRDSAPI) ModifyDBCluster(arg0 *rds.ModifyDBClusterInput) (*rds.ModifyDBClusterOutput, error) { 5662 m.ctrl.T.Helper() 5663 ret := m.ctrl.Call(m, "ModifyDBCluster", arg0) 5664 ret0, _ := ret[0].(*rds.ModifyDBClusterOutput) 5665 ret1, _ := ret[1].(error) 5666 return ret0, ret1 5667 } 5668 5669 // ModifyDBCluster indicates an expected call of ModifyDBCluster 5670 func (mr *MockRDSAPIMockRecorder) ModifyDBCluster(arg0 interface{}) *gomock.Call { 5671 mr.mock.ctrl.T.Helper() 5672 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyDBCluster", reflect.TypeOf((*MockRDSAPI)(nil).ModifyDBCluster), arg0) 5673 } 5674 5675 // ModifyDBClusterEndpoint mocks base method 5676 func (m *MockRDSAPI) ModifyDBClusterEndpoint(arg0 *rds.ModifyDBClusterEndpointInput) (*rds.ModifyDBClusterEndpointOutput, error) { 5677 m.ctrl.T.Helper() 5678 ret := m.ctrl.Call(m, "ModifyDBClusterEndpoint", arg0) 5679 ret0, _ := ret[0].(*rds.ModifyDBClusterEndpointOutput) 5680 ret1, _ := ret[1].(error) 5681 return ret0, ret1 5682 } 5683 5684 // ModifyDBClusterEndpoint indicates an expected call of ModifyDBClusterEndpoint 5685 func (mr *MockRDSAPIMockRecorder) ModifyDBClusterEndpoint(arg0 interface{}) *gomock.Call { 5686 mr.mock.ctrl.T.Helper() 5687 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyDBClusterEndpoint", reflect.TypeOf((*MockRDSAPI)(nil).ModifyDBClusterEndpoint), arg0) 5688 } 5689 5690 // ModifyDBClusterEndpointRequest mocks base method 5691 func (m *MockRDSAPI) ModifyDBClusterEndpointRequest(arg0 *rds.ModifyDBClusterEndpointInput) (*request.Request, *rds.ModifyDBClusterEndpointOutput) { 5692 m.ctrl.T.Helper() 5693 ret := m.ctrl.Call(m, "ModifyDBClusterEndpointRequest", arg0) 5694 ret0, _ := ret[0].(*request.Request) 5695 ret1, _ := ret[1].(*rds.ModifyDBClusterEndpointOutput) 5696 return ret0, ret1 5697 } 5698 5699 // ModifyDBClusterEndpointRequest indicates an expected call of ModifyDBClusterEndpointRequest 5700 func (mr *MockRDSAPIMockRecorder) ModifyDBClusterEndpointRequest(arg0 interface{}) *gomock.Call { 5701 mr.mock.ctrl.T.Helper() 5702 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyDBClusterEndpointRequest", reflect.TypeOf((*MockRDSAPI)(nil).ModifyDBClusterEndpointRequest), arg0) 5703 } 5704 5705 // ModifyDBClusterEndpointWithContext mocks base method 5706 func (m *MockRDSAPI) ModifyDBClusterEndpointWithContext(arg0 context.Context, arg1 *rds.ModifyDBClusterEndpointInput, arg2 ...request.Option) (*rds.ModifyDBClusterEndpointOutput, error) { 5707 m.ctrl.T.Helper() 5708 varargs := []interface{}{arg0, arg1} 5709 for _, a := range arg2 { 5710 varargs = append(varargs, a) 5711 } 5712 ret := m.ctrl.Call(m, "ModifyDBClusterEndpointWithContext", varargs...) 5713 ret0, _ := ret[0].(*rds.ModifyDBClusterEndpointOutput) 5714 ret1, _ := ret[1].(error) 5715 return ret0, ret1 5716 } 5717 5718 // ModifyDBClusterEndpointWithContext indicates an expected call of ModifyDBClusterEndpointWithContext 5719 func (mr *MockRDSAPIMockRecorder) ModifyDBClusterEndpointWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 5720 mr.mock.ctrl.T.Helper() 5721 varargs := append([]interface{}{arg0, arg1}, arg2...) 5722 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyDBClusterEndpointWithContext", reflect.TypeOf((*MockRDSAPI)(nil).ModifyDBClusterEndpointWithContext), varargs...) 5723 } 5724 5725 // ModifyDBClusterParameterGroup mocks base method 5726 func (m *MockRDSAPI) ModifyDBClusterParameterGroup(arg0 *rds.ModifyDBClusterParameterGroupInput) (*rds.DBClusterParameterGroupNameMessage, error) { 5727 m.ctrl.T.Helper() 5728 ret := m.ctrl.Call(m, "ModifyDBClusterParameterGroup", arg0) 5729 ret0, _ := ret[0].(*rds.DBClusterParameterGroupNameMessage) 5730 ret1, _ := ret[1].(error) 5731 return ret0, ret1 5732 } 5733 5734 // ModifyDBClusterParameterGroup indicates an expected call of ModifyDBClusterParameterGroup 5735 func (mr *MockRDSAPIMockRecorder) ModifyDBClusterParameterGroup(arg0 interface{}) *gomock.Call { 5736 mr.mock.ctrl.T.Helper() 5737 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyDBClusterParameterGroup", reflect.TypeOf((*MockRDSAPI)(nil).ModifyDBClusterParameterGroup), arg0) 5738 } 5739 5740 // ModifyDBClusterParameterGroupRequest mocks base method 5741 func (m *MockRDSAPI) ModifyDBClusterParameterGroupRequest(arg0 *rds.ModifyDBClusterParameterGroupInput) (*request.Request, *rds.DBClusterParameterGroupNameMessage) { 5742 m.ctrl.T.Helper() 5743 ret := m.ctrl.Call(m, "ModifyDBClusterParameterGroupRequest", arg0) 5744 ret0, _ := ret[0].(*request.Request) 5745 ret1, _ := ret[1].(*rds.DBClusterParameterGroupNameMessage) 5746 return ret0, ret1 5747 } 5748 5749 // ModifyDBClusterParameterGroupRequest indicates an expected call of ModifyDBClusterParameterGroupRequest 5750 func (mr *MockRDSAPIMockRecorder) ModifyDBClusterParameterGroupRequest(arg0 interface{}) *gomock.Call { 5751 mr.mock.ctrl.T.Helper() 5752 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyDBClusterParameterGroupRequest", reflect.TypeOf((*MockRDSAPI)(nil).ModifyDBClusterParameterGroupRequest), arg0) 5753 } 5754 5755 // ModifyDBClusterParameterGroupWithContext mocks base method 5756 func (m *MockRDSAPI) ModifyDBClusterParameterGroupWithContext(arg0 context.Context, arg1 *rds.ModifyDBClusterParameterGroupInput, arg2 ...request.Option) (*rds.DBClusterParameterGroupNameMessage, error) { 5757 m.ctrl.T.Helper() 5758 varargs := []interface{}{arg0, arg1} 5759 for _, a := range arg2 { 5760 varargs = append(varargs, a) 5761 } 5762 ret := m.ctrl.Call(m, "ModifyDBClusterParameterGroupWithContext", varargs...) 5763 ret0, _ := ret[0].(*rds.DBClusterParameterGroupNameMessage) 5764 ret1, _ := ret[1].(error) 5765 return ret0, ret1 5766 } 5767 5768 // ModifyDBClusterParameterGroupWithContext indicates an expected call of ModifyDBClusterParameterGroupWithContext 5769 func (mr *MockRDSAPIMockRecorder) ModifyDBClusterParameterGroupWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 5770 mr.mock.ctrl.T.Helper() 5771 varargs := append([]interface{}{arg0, arg1}, arg2...) 5772 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyDBClusterParameterGroupWithContext", reflect.TypeOf((*MockRDSAPI)(nil).ModifyDBClusterParameterGroupWithContext), varargs...) 5773 } 5774 5775 // ModifyDBClusterRequest mocks base method 5776 func (m *MockRDSAPI) ModifyDBClusterRequest(arg0 *rds.ModifyDBClusterInput) (*request.Request, *rds.ModifyDBClusterOutput) { 5777 m.ctrl.T.Helper() 5778 ret := m.ctrl.Call(m, "ModifyDBClusterRequest", arg0) 5779 ret0, _ := ret[0].(*request.Request) 5780 ret1, _ := ret[1].(*rds.ModifyDBClusterOutput) 5781 return ret0, ret1 5782 } 5783 5784 // ModifyDBClusterRequest indicates an expected call of ModifyDBClusterRequest 5785 func (mr *MockRDSAPIMockRecorder) ModifyDBClusterRequest(arg0 interface{}) *gomock.Call { 5786 mr.mock.ctrl.T.Helper() 5787 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyDBClusterRequest", reflect.TypeOf((*MockRDSAPI)(nil).ModifyDBClusterRequest), arg0) 5788 } 5789 5790 // ModifyDBClusterSnapshotAttribute mocks base method 5791 func (m *MockRDSAPI) ModifyDBClusterSnapshotAttribute(arg0 *rds.ModifyDBClusterSnapshotAttributeInput) (*rds.ModifyDBClusterSnapshotAttributeOutput, error) { 5792 m.ctrl.T.Helper() 5793 ret := m.ctrl.Call(m, "ModifyDBClusterSnapshotAttribute", arg0) 5794 ret0, _ := ret[0].(*rds.ModifyDBClusterSnapshotAttributeOutput) 5795 ret1, _ := ret[1].(error) 5796 return ret0, ret1 5797 } 5798 5799 // ModifyDBClusterSnapshotAttribute indicates an expected call of ModifyDBClusterSnapshotAttribute 5800 func (mr *MockRDSAPIMockRecorder) ModifyDBClusterSnapshotAttribute(arg0 interface{}) *gomock.Call { 5801 mr.mock.ctrl.T.Helper() 5802 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyDBClusterSnapshotAttribute", reflect.TypeOf((*MockRDSAPI)(nil).ModifyDBClusterSnapshotAttribute), arg0) 5803 } 5804 5805 // ModifyDBClusterSnapshotAttributeRequest mocks base method 5806 func (m *MockRDSAPI) ModifyDBClusterSnapshotAttributeRequest(arg0 *rds.ModifyDBClusterSnapshotAttributeInput) (*request.Request, *rds.ModifyDBClusterSnapshotAttributeOutput) { 5807 m.ctrl.T.Helper() 5808 ret := m.ctrl.Call(m, "ModifyDBClusterSnapshotAttributeRequest", arg0) 5809 ret0, _ := ret[0].(*request.Request) 5810 ret1, _ := ret[1].(*rds.ModifyDBClusterSnapshotAttributeOutput) 5811 return ret0, ret1 5812 } 5813 5814 // ModifyDBClusterSnapshotAttributeRequest indicates an expected call of ModifyDBClusterSnapshotAttributeRequest 5815 func (mr *MockRDSAPIMockRecorder) ModifyDBClusterSnapshotAttributeRequest(arg0 interface{}) *gomock.Call { 5816 mr.mock.ctrl.T.Helper() 5817 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyDBClusterSnapshotAttributeRequest", reflect.TypeOf((*MockRDSAPI)(nil).ModifyDBClusterSnapshotAttributeRequest), arg0) 5818 } 5819 5820 // ModifyDBClusterSnapshotAttributeWithContext mocks base method 5821 func (m *MockRDSAPI) ModifyDBClusterSnapshotAttributeWithContext(arg0 context.Context, arg1 *rds.ModifyDBClusterSnapshotAttributeInput, arg2 ...request.Option) (*rds.ModifyDBClusterSnapshotAttributeOutput, error) { 5822 m.ctrl.T.Helper() 5823 varargs := []interface{}{arg0, arg1} 5824 for _, a := range arg2 { 5825 varargs = append(varargs, a) 5826 } 5827 ret := m.ctrl.Call(m, "ModifyDBClusterSnapshotAttributeWithContext", varargs...) 5828 ret0, _ := ret[0].(*rds.ModifyDBClusterSnapshotAttributeOutput) 5829 ret1, _ := ret[1].(error) 5830 return ret0, ret1 5831 } 5832 5833 // ModifyDBClusterSnapshotAttributeWithContext indicates an expected call of ModifyDBClusterSnapshotAttributeWithContext 5834 func (mr *MockRDSAPIMockRecorder) ModifyDBClusterSnapshotAttributeWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 5835 mr.mock.ctrl.T.Helper() 5836 varargs := append([]interface{}{arg0, arg1}, arg2...) 5837 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyDBClusterSnapshotAttributeWithContext", reflect.TypeOf((*MockRDSAPI)(nil).ModifyDBClusterSnapshotAttributeWithContext), varargs...) 5838 } 5839 5840 // ModifyDBClusterWithContext mocks base method 5841 func (m *MockRDSAPI) ModifyDBClusterWithContext(arg0 context.Context, arg1 *rds.ModifyDBClusterInput, arg2 ...request.Option) (*rds.ModifyDBClusterOutput, error) { 5842 m.ctrl.T.Helper() 5843 varargs := []interface{}{arg0, arg1} 5844 for _, a := range arg2 { 5845 varargs = append(varargs, a) 5846 } 5847 ret := m.ctrl.Call(m, "ModifyDBClusterWithContext", varargs...) 5848 ret0, _ := ret[0].(*rds.ModifyDBClusterOutput) 5849 ret1, _ := ret[1].(error) 5850 return ret0, ret1 5851 } 5852 5853 // ModifyDBClusterWithContext indicates an expected call of ModifyDBClusterWithContext 5854 func (mr *MockRDSAPIMockRecorder) ModifyDBClusterWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 5855 mr.mock.ctrl.T.Helper() 5856 varargs := append([]interface{}{arg0, arg1}, arg2...) 5857 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyDBClusterWithContext", reflect.TypeOf((*MockRDSAPI)(nil).ModifyDBClusterWithContext), varargs...) 5858 } 5859 5860 // ModifyDBInstance mocks base method 5861 func (m *MockRDSAPI) ModifyDBInstance(arg0 *rds.ModifyDBInstanceInput) (*rds.ModifyDBInstanceOutput, error) { 5862 m.ctrl.T.Helper() 5863 ret := m.ctrl.Call(m, "ModifyDBInstance", arg0) 5864 ret0, _ := ret[0].(*rds.ModifyDBInstanceOutput) 5865 ret1, _ := ret[1].(error) 5866 return ret0, ret1 5867 } 5868 5869 // ModifyDBInstance indicates an expected call of ModifyDBInstance 5870 func (mr *MockRDSAPIMockRecorder) ModifyDBInstance(arg0 interface{}) *gomock.Call { 5871 mr.mock.ctrl.T.Helper() 5872 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyDBInstance", reflect.TypeOf((*MockRDSAPI)(nil).ModifyDBInstance), arg0) 5873 } 5874 5875 // ModifyDBInstanceRequest mocks base method 5876 func (m *MockRDSAPI) ModifyDBInstanceRequest(arg0 *rds.ModifyDBInstanceInput) (*request.Request, *rds.ModifyDBInstanceOutput) { 5877 m.ctrl.T.Helper() 5878 ret := m.ctrl.Call(m, "ModifyDBInstanceRequest", arg0) 5879 ret0, _ := ret[0].(*request.Request) 5880 ret1, _ := ret[1].(*rds.ModifyDBInstanceOutput) 5881 return ret0, ret1 5882 } 5883 5884 // ModifyDBInstanceRequest indicates an expected call of ModifyDBInstanceRequest 5885 func (mr *MockRDSAPIMockRecorder) ModifyDBInstanceRequest(arg0 interface{}) *gomock.Call { 5886 mr.mock.ctrl.T.Helper() 5887 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyDBInstanceRequest", reflect.TypeOf((*MockRDSAPI)(nil).ModifyDBInstanceRequest), arg0) 5888 } 5889 5890 // ModifyDBInstanceWithContext mocks base method 5891 func (m *MockRDSAPI) ModifyDBInstanceWithContext(arg0 context.Context, arg1 *rds.ModifyDBInstanceInput, arg2 ...request.Option) (*rds.ModifyDBInstanceOutput, error) { 5892 m.ctrl.T.Helper() 5893 varargs := []interface{}{arg0, arg1} 5894 for _, a := range arg2 { 5895 varargs = append(varargs, a) 5896 } 5897 ret := m.ctrl.Call(m, "ModifyDBInstanceWithContext", varargs...) 5898 ret0, _ := ret[0].(*rds.ModifyDBInstanceOutput) 5899 ret1, _ := ret[1].(error) 5900 return ret0, ret1 5901 } 5902 5903 // ModifyDBInstanceWithContext indicates an expected call of ModifyDBInstanceWithContext 5904 func (mr *MockRDSAPIMockRecorder) ModifyDBInstanceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 5905 mr.mock.ctrl.T.Helper() 5906 varargs := append([]interface{}{arg0, arg1}, arg2...) 5907 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyDBInstanceWithContext", reflect.TypeOf((*MockRDSAPI)(nil).ModifyDBInstanceWithContext), varargs...) 5908 } 5909 5910 // ModifyDBParameterGroup mocks base method 5911 func (m *MockRDSAPI) ModifyDBParameterGroup(arg0 *rds.ModifyDBParameterGroupInput) (*rds.DBParameterGroupNameMessage, error) { 5912 m.ctrl.T.Helper() 5913 ret := m.ctrl.Call(m, "ModifyDBParameterGroup", arg0) 5914 ret0, _ := ret[0].(*rds.DBParameterGroupNameMessage) 5915 ret1, _ := ret[1].(error) 5916 return ret0, ret1 5917 } 5918 5919 // ModifyDBParameterGroup indicates an expected call of ModifyDBParameterGroup 5920 func (mr *MockRDSAPIMockRecorder) ModifyDBParameterGroup(arg0 interface{}) *gomock.Call { 5921 mr.mock.ctrl.T.Helper() 5922 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyDBParameterGroup", reflect.TypeOf((*MockRDSAPI)(nil).ModifyDBParameterGroup), arg0) 5923 } 5924 5925 // ModifyDBParameterGroupRequest mocks base method 5926 func (m *MockRDSAPI) ModifyDBParameterGroupRequest(arg0 *rds.ModifyDBParameterGroupInput) (*request.Request, *rds.DBParameterGroupNameMessage) { 5927 m.ctrl.T.Helper() 5928 ret := m.ctrl.Call(m, "ModifyDBParameterGroupRequest", arg0) 5929 ret0, _ := ret[0].(*request.Request) 5930 ret1, _ := ret[1].(*rds.DBParameterGroupNameMessage) 5931 return ret0, ret1 5932 } 5933 5934 // ModifyDBParameterGroupRequest indicates an expected call of ModifyDBParameterGroupRequest 5935 func (mr *MockRDSAPIMockRecorder) ModifyDBParameterGroupRequest(arg0 interface{}) *gomock.Call { 5936 mr.mock.ctrl.T.Helper() 5937 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyDBParameterGroupRequest", reflect.TypeOf((*MockRDSAPI)(nil).ModifyDBParameterGroupRequest), arg0) 5938 } 5939 5940 // ModifyDBParameterGroupWithContext mocks base method 5941 func (m *MockRDSAPI) ModifyDBParameterGroupWithContext(arg0 context.Context, arg1 *rds.ModifyDBParameterGroupInput, arg2 ...request.Option) (*rds.DBParameterGroupNameMessage, error) { 5942 m.ctrl.T.Helper() 5943 varargs := []interface{}{arg0, arg1} 5944 for _, a := range arg2 { 5945 varargs = append(varargs, a) 5946 } 5947 ret := m.ctrl.Call(m, "ModifyDBParameterGroupWithContext", varargs...) 5948 ret0, _ := ret[0].(*rds.DBParameterGroupNameMessage) 5949 ret1, _ := ret[1].(error) 5950 return ret0, ret1 5951 } 5952 5953 // ModifyDBParameterGroupWithContext indicates an expected call of ModifyDBParameterGroupWithContext 5954 func (mr *MockRDSAPIMockRecorder) ModifyDBParameterGroupWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 5955 mr.mock.ctrl.T.Helper() 5956 varargs := append([]interface{}{arg0, arg1}, arg2...) 5957 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyDBParameterGroupWithContext", reflect.TypeOf((*MockRDSAPI)(nil).ModifyDBParameterGroupWithContext), varargs...) 5958 } 5959 5960 // ModifyDBProxy mocks base method 5961 func (m *MockRDSAPI) ModifyDBProxy(arg0 *rds.ModifyDBProxyInput) (*rds.ModifyDBProxyOutput, error) { 5962 m.ctrl.T.Helper() 5963 ret := m.ctrl.Call(m, "ModifyDBProxy", arg0) 5964 ret0, _ := ret[0].(*rds.ModifyDBProxyOutput) 5965 ret1, _ := ret[1].(error) 5966 return ret0, ret1 5967 } 5968 5969 // ModifyDBProxy indicates an expected call of ModifyDBProxy 5970 func (mr *MockRDSAPIMockRecorder) ModifyDBProxy(arg0 interface{}) *gomock.Call { 5971 mr.mock.ctrl.T.Helper() 5972 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyDBProxy", reflect.TypeOf((*MockRDSAPI)(nil).ModifyDBProxy), arg0) 5973 } 5974 5975 // ModifyDBProxyRequest mocks base method 5976 func (m *MockRDSAPI) ModifyDBProxyRequest(arg0 *rds.ModifyDBProxyInput) (*request.Request, *rds.ModifyDBProxyOutput) { 5977 m.ctrl.T.Helper() 5978 ret := m.ctrl.Call(m, "ModifyDBProxyRequest", arg0) 5979 ret0, _ := ret[0].(*request.Request) 5980 ret1, _ := ret[1].(*rds.ModifyDBProxyOutput) 5981 return ret0, ret1 5982 } 5983 5984 // ModifyDBProxyRequest indicates an expected call of ModifyDBProxyRequest 5985 func (mr *MockRDSAPIMockRecorder) ModifyDBProxyRequest(arg0 interface{}) *gomock.Call { 5986 mr.mock.ctrl.T.Helper() 5987 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyDBProxyRequest", reflect.TypeOf((*MockRDSAPI)(nil).ModifyDBProxyRequest), arg0) 5988 } 5989 5990 // ModifyDBProxyTargetGroup mocks base method 5991 func (m *MockRDSAPI) ModifyDBProxyTargetGroup(arg0 *rds.ModifyDBProxyTargetGroupInput) (*rds.ModifyDBProxyTargetGroupOutput, error) { 5992 m.ctrl.T.Helper() 5993 ret := m.ctrl.Call(m, "ModifyDBProxyTargetGroup", arg0) 5994 ret0, _ := ret[0].(*rds.ModifyDBProxyTargetGroupOutput) 5995 ret1, _ := ret[1].(error) 5996 return ret0, ret1 5997 } 5998 5999 // ModifyDBProxyTargetGroup indicates an expected call of ModifyDBProxyTargetGroup 6000 func (mr *MockRDSAPIMockRecorder) ModifyDBProxyTargetGroup(arg0 interface{}) *gomock.Call { 6001 mr.mock.ctrl.T.Helper() 6002 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyDBProxyTargetGroup", reflect.TypeOf((*MockRDSAPI)(nil).ModifyDBProxyTargetGroup), arg0) 6003 } 6004 6005 // ModifyDBProxyTargetGroupRequest mocks base method 6006 func (m *MockRDSAPI) ModifyDBProxyTargetGroupRequest(arg0 *rds.ModifyDBProxyTargetGroupInput) (*request.Request, *rds.ModifyDBProxyTargetGroupOutput) { 6007 m.ctrl.T.Helper() 6008 ret := m.ctrl.Call(m, "ModifyDBProxyTargetGroupRequest", arg0) 6009 ret0, _ := ret[0].(*request.Request) 6010 ret1, _ := ret[1].(*rds.ModifyDBProxyTargetGroupOutput) 6011 return ret0, ret1 6012 } 6013 6014 // ModifyDBProxyTargetGroupRequest indicates an expected call of ModifyDBProxyTargetGroupRequest 6015 func (mr *MockRDSAPIMockRecorder) ModifyDBProxyTargetGroupRequest(arg0 interface{}) *gomock.Call { 6016 mr.mock.ctrl.T.Helper() 6017 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyDBProxyTargetGroupRequest", reflect.TypeOf((*MockRDSAPI)(nil).ModifyDBProxyTargetGroupRequest), arg0) 6018 } 6019 6020 // ModifyDBProxyTargetGroupWithContext mocks base method 6021 func (m *MockRDSAPI) ModifyDBProxyTargetGroupWithContext(arg0 context.Context, arg1 *rds.ModifyDBProxyTargetGroupInput, arg2 ...request.Option) (*rds.ModifyDBProxyTargetGroupOutput, error) { 6022 m.ctrl.T.Helper() 6023 varargs := []interface{}{arg0, arg1} 6024 for _, a := range arg2 { 6025 varargs = append(varargs, a) 6026 } 6027 ret := m.ctrl.Call(m, "ModifyDBProxyTargetGroupWithContext", varargs...) 6028 ret0, _ := ret[0].(*rds.ModifyDBProxyTargetGroupOutput) 6029 ret1, _ := ret[1].(error) 6030 return ret0, ret1 6031 } 6032 6033 // ModifyDBProxyTargetGroupWithContext indicates an expected call of ModifyDBProxyTargetGroupWithContext 6034 func (mr *MockRDSAPIMockRecorder) ModifyDBProxyTargetGroupWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 6035 mr.mock.ctrl.T.Helper() 6036 varargs := append([]interface{}{arg0, arg1}, arg2...) 6037 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyDBProxyTargetGroupWithContext", reflect.TypeOf((*MockRDSAPI)(nil).ModifyDBProxyTargetGroupWithContext), varargs...) 6038 } 6039 6040 // ModifyDBProxyWithContext mocks base method 6041 func (m *MockRDSAPI) ModifyDBProxyWithContext(arg0 context.Context, arg1 *rds.ModifyDBProxyInput, arg2 ...request.Option) (*rds.ModifyDBProxyOutput, error) { 6042 m.ctrl.T.Helper() 6043 varargs := []interface{}{arg0, arg1} 6044 for _, a := range arg2 { 6045 varargs = append(varargs, a) 6046 } 6047 ret := m.ctrl.Call(m, "ModifyDBProxyWithContext", varargs...) 6048 ret0, _ := ret[0].(*rds.ModifyDBProxyOutput) 6049 ret1, _ := ret[1].(error) 6050 return ret0, ret1 6051 } 6052 6053 // ModifyDBProxyWithContext indicates an expected call of ModifyDBProxyWithContext 6054 func (mr *MockRDSAPIMockRecorder) ModifyDBProxyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 6055 mr.mock.ctrl.T.Helper() 6056 varargs := append([]interface{}{arg0, arg1}, arg2...) 6057 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyDBProxyWithContext", reflect.TypeOf((*MockRDSAPI)(nil).ModifyDBProxyWithContext), varargs...) 6058 } 6059 6060 // ModifyDBSnapshot mocks base method 6061 func (m *MockRDSAPI) ModifyDBSnapshot(arg0 *rds.ModifyDBSnapshotInput) (*rds.ModifyDBSnapshotOutput, error) { 6062 m.ctrl.T.Helper() 6063 ret := m.ctrl.Call(m, "ModifyDBSnapshot", arg0) 6064 ret0, _ := ret[0].(*rds.ModifyDBSnapshotOutput) 6065 ret1, _ := ret[1].(error) 6066 return ret0, ret1 6067 } 6068 6069 // ModifyDBSnapshot indicates an expected call of ModifyDBSnapshot 6070 func (mr *MockRDSAPIMockRecorder) ModifyDBSnapshot(arg0 interface{}) *gomock.Call { 6071 mr.mock.ctrl.T.Helper() 6072 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyDBSnapshot", reflect.TypeOf((*MockRDSAPI)(nil).ModifyDBSnapshot), arg0) 6073 } 6074 6075 // ModifyDBSnapshotAttribute mocks base method 6076 func (m *MockRDSAPI) ModifyDBSnapshotAttribute(arg0 *rds.ModifyDBSnapshotAttributeInput) (*rds.ModifyDBSnapshotAttributeOutput, error) { 6077 m.ctrl.T.Helper() 6078 ret := m.ctrl.Call(m, "ModifyDBSnapshotAttribute", arg0) 6079 ret0, _ := ret[0].(*rds.ModifyDBSnapshotAttributeOutput) 6080 ret1, _ := ret[1].(error) 6081 return ret0, ret1 6082 } 6083 6084 // ModifyDBSnapshotAttribute indicates an expected call of ModifyDBSnapshotAttribute 6085 func (mr *MockRDSAPIMockRecorder) ModifyDBSnapshotAttribute(arg0 interface{}) *gomock.Call { 6086 mr.mock.ctrl.T.Helper() 6087 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyDBSnapshotAttribute", reflect.TypeOf((*MockRDSAPI)(nil).ModifyDBSnapshotAttribute), arg0) 6088 } 6089 6090 // ModifyDBSnapshotAttributeRequest mocks base method 6091 func (m *MockRDSAPI) ModifyDBSnapshotAttributeRequest(arg0 *rds.ModifyDBSnapshotAttributeInput) (*request.Request, *rds.ModifyDBSnapshotAttributeOutput) { 6092 m.ctrl.T.Helper() 6093 ret := m.ctrl.Call(m, "ModifyDBSnapshotAttributeRequest", arg0) 6094 ret0, _ := ret[0].(*request.Request) 6095 ret1, _ := ret[1].(*rds.ModifyDBSnapshotAttributeOutput) 6096 return ret0, ret1 6097 } 6098 6099 // ModifyDBSnapshotAttributeRequest indicates an expected call of ModifyDBSnapshotAttributeRequest 6100 func (mr *MockRDSAPIMockRecorder) ModifyDBSnapshotAttributeRequest(arg0 interface{}) *gomock.Call { 6101 mr.mock.ctrl.T.Helper() 6102 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyDBSnapshotAttributeRequest", reflect.TypeOf((*MockRDSAPI)(nil).ModifyDBSnapshotAttributeRequest), arg0) 6103 } 6104 6105 // ModifyDBSnapshotAttributeWithContext mocks base method 6106 func (m *MockRDSAPI) ModifyDBSnapshotAttributeWithContext(arg0 context.Context, arg1 *rds.ModifyDBSnapshotAttributeInput, arg2 ...request.Option) (*rds.ModifyDBSnapshotAttributeOutput, error) { 6107 m.ctrl.T.Helper() 6108 varargs := []interface{}{arg0, arg1} 6109 for _, a := range arg2 { 6110 varargs = append(varargs, a) 6111 } 6112 ret := m.ctrl.Call(m, "ModifyDBSnapshotAttributeWithContext", varargs...) 6113 ret0, _ := ret[0].(*rds.ModifyDBSnapshotAttributeOutput) 6114 ret1, _ := ret[1].(error) 6115 return ret0, ret1 6116 } 6117 6118 // ModifyDBSnapshotAttributeWithContext indicates an expected call of ModifyDBSnapshotAttributeWithContext 6119 func (mr *MockRDSAPIMockRecorder) ModifyDBSnapshotAttributeWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 6120 mr.mock.ctrl.T.Helper() 6121 varargs := append([]interface{}{arg0, arg1}, arg2...) 6122 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyDBSnapshotAttributeWithContext", reflect.TypeOf((*MockRDSAPI)(nil).ModifyDBSnapshotAttributeWithContext), varargs...) 6123 } 6124 6125 // ModifyDBSnapshotRequest mocks base method 6126 func (m *MockRDSAPI) ModifyDBSnapshotRequest(arg0 *rds.ModifyDBSnapshotInput) (*request.Request, *rds.ModifyDBSnapshotOutput) { 6127 m.ctrl.T.Helper() 6128 ret := m.ctrl.Call(m, "ModifyDBSnapshotRequest", arg0) 6129 ret0, _ := ret[0].(*request.Request) 6130 ret1, _ := ret[1].(*rds.ModifyDBSnapshotOutput) 6131 return ret0, ret1 6132 } 6133 6134 // ModifyDBSnapshotRequest indicates an expected call of ModifyDBSnapshotRequest 6135 func (mr *MockRDSAPIMockRecorder) ModifyDBSnapshotRequest(arg0 interface{}) *gomock.Call { 6136 mr.mock.ctrl.T.Helper() 6137 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyDBSnapshotRequest", reflect.TypeOf((*MockRDSAPI)(nil).ModifyDBSnapshotRequest), arg0) 6138 } 6139 6140 // ModifyDBSnapshotWithContext mocks base method 6141 func (m *MockRDSAPI) ModifyDBSnapshotWithContext(arg0 context.Context, arg1 *rds.ModifyDBSnapshotInput, arg2 ...request.Option) (*rds.ModifyDBSnapshotOutput, error) { 6142 m.ctrl.T.Helper() 6143 varargs := []interface{}{arg0, arg1} 6144 for _, a := range arg2 { 6145 varargs = append(varargs, a) 6146 } 6147 ret := m.ctrl.Call(m, "ModifyDBSnapshotWithContext", varargs...) 6148 ret0, _ := ret[0].(*rds.ModifyDBSnapshotOutput) 6149 ret1, _ := ret[1].(error) 6150 return ret0, ret1 6151 } 6152 6153 // ModifyDBSnapshotWithContext indicates an expected call of ModifyDBSnapshotWithContext 6154 func (mr *MockRDSAPIMockRecorder) ModifyDBSnapshotWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 6155 mr.mock.ctrl.T.Helper() 6156 varargs := append([]interface{}{arg0, arg1}, arg2...) 6157 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyDBSnapshotWithContext", reflect.TypeOf((*MockRDSAPI)(nil).ModifyDBSnapshotWithContext), varargs...) 6158 } 6159 6160 // ModifyDBSubnetGroup mocks base method 6161 func (m *MockRDSAPI) ModifyDBSubnetGroup(arg0 *rds.ModifyDBSubnetGroupInput) (*rds.ModifyDBSubnetGroupOutput, error) { 6162 m.ctrl.T.Helper() 6163 ret := m.ctrl.Call(m, "ModifyDBSubnetGroup", arg0) 6164 ret0, _ := ret[0].(*rds.ModifyDBSubnetGroupOutput) 6165 ret1, _ := ret[1].(error) 6166 return ret0, ret1 6167 } 6168 6169 // ModifyDBSubnetGroup indicates an expected call of ModifyDBSubnetGroup 6170 func (mr *MockRDSAPIMockRecorder) ModifyDBSubnetGroup(arg0 interface{}) *gomock.Call { 6171 mr.mock.ctrl.T.Helper() 6172 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyDBSubnetGroup", reflect.TypeOf((*MockRDSAPI)(nil).ModifyDBSubnetGroup), arg0) 6173 } 6174 6175 // ModifyDBSubnetGroupRequest mocks base method 6176 func (m *MockRDSAPI) ModifyDBSubnetGroupRequest(arg0 *rds.ModifyDBSubnetGroupInput) (*request.Request, *rds.ModifyDBSubnetGroupOutput) { 6177 m.ctrl.T.Helper() 6178 ret := m.ctrl.Call(m, "ModifyDBSubnetGroupRequest", arg0) 6179 ret0, _ := ret[0].(*request.Request) 6180 ret1, _ := ret[1].(*rds.ModifyDBSubnetGroupOutput) 6181 return ret0, ret1 6182 } 6183 6184 // ModifyDBSubnetGroupRequest indicates an expected call of ModifyDBSubnetGroupRequest 6185 func (mr *MockRDSAPIMockRecorder) ModifyDBSubnetGroupRequest(arg0 interface{}) *gomock.Call { 6186 mr.mock.ctrl.T.Helper() 6187 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyDBSubnetGroupRequest", reflect.TypeOf((*MockRDSAPI)(nil).ModifyDBSubnetGroupRequest), arg0) 6188 } 6189 6190 // ModifyDBSubnetGroupWithContext mocks base method 6191 func (m *MockRDSAPI) ModifyDBSubnetGroupWithContext(arg0 context.Context, arg1 *rds.ModifyDBSubnetGroupInput, arg2 ...request.Option) (*rds.ModifyDBSubnetGroupOutput, error) { 6192 m.ctrl.T.Helper() 6193 varargs := []interface{}{arg0, arg1} 6194 for _, a := range arg2 { 6195 varargs = append(varargs, a) 6196 } 6197 ret := m.ctrl.Call(m, "ModifyDBSubnetGroupWithContext", varargs...) 6198 ret0, _ := ret[0].(*rds.ModifyDBSubnetGroupOutput) 6199 ret1, _ := ret[1].(error) 6200 return ret0, ret1 6201 } 6202 6203 // ModifyDBSubnetGroupWithContext indicates an expected call of ModifyDBSubnetGroupWithContext 6204 func (mr *MockRDSAPIMockRecorder) ModifyDBSubnetGroupWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 6205 mr.mock.ctrl.T.Helper() 6206 varargs := append([]interface{}{arg0, arg1}, arg2...) 6207 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyDBSubnetGroupWithContext", reflect.TypeOf((*MockRDSAPI)(nil).ModifyDBSubnetGroupWithContext), varargs...) 6208 } 6209 6210 // ModifyEventSubscription mocks base method 6211 func (m *MockRDSAPI) ModifyEventSubscription(arg0 *rds.ModifyEventSubscriptionInput) (*rds.ModifyEventSubscriptionOutput, error) { 6212 m.ctrl.T.Helper() 6213 ret := m.ctrl.Call(m, "ModifyEventSubscription", arg0) 6214 ret0, _ := ret[0].(*rds.ModifyEventSubscriptionOutput) 6215 ret1, _ := ret[1].(error) 6216 return ret0, ret1 6217 } 6218 6219 // ModifyEventSubscription indicates an expected call of ModifyEventSubscription 6220 func (mr *MockRDSAPIMockRecorder) ModifyEventSubscription(arg0 interface{}) *gomock.Call { 6221 mr.mock.ctrl.T.Helper() 6222 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyEventSubscription", reflect.TypeOf((*MockRDSAPI)(nil).ModifyEventSubscription), arg0) 6223 } 6224 6225 // ModifyEventSubscriptionRequest mocks base method 6226 func (m *MockRDSAPI) ModifyEventSubscriptionRequest(arg0 *rds.ModifyEventSubscriptionInput) (*request.Request, *rds.ModifyEventSubscriptionOutput) { 6227 m.ctrl.T.Helper() 6228 ret := m.ctrl.Call(m, "ModifyEventSubscriptionRequest", arg0) 6229 ret0, _ := ret[0].(*request.Request) 6230 ret1, _ := ret[1].(*rds.ModifyEventSubscriptionOutput) 6231 return ret0, ret1 6232 } 6233 6234 // ModifyEventSubscriptionRequest indicates an expected call of ModifyEventSubscriptionRequest 6235 func (mr *MockRDSAPIMockRecorder) ModifyEventSubscriptionRequest(arg0 interface{}) *gomock.Call { 6236 mr.mock.ctrl.T.Helper() 6237 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyEventSubscriptionRequest", reflect.TypeOf((*MockRDSAPI)(nil).ModifyEventSubscriptionRequest), arg0) 6238 } 6239 6240 // ModifyEventSubscriptionWithContext mocks base method 6241 func (m *MockRDSAPI) ModifyEventSubscriptionWithContext(arg0 context.Context, arg1 *rds.ModifyEventSubscriptionInput, arg2 ...request.Option) (*rds.ModifyEventSubscriptionOutput, error) { 6242 m.ctrl.T.Helper() 6243 varargs := []interface{}{arg0, arg1} 6244 for _, a := range arg2 { 6245 varargs = append(varargs, a) 6246 } 6247 ret := m.ctrl.Call(m, "ModifyEventSubscriptionWithContext", varargs...) 6248 ret0, _ := ret[0].(*rds.ModifyEventSubscriptionOutput) 6249 ret1, _ := ret[1].(error) 6250 return ret0, ret1 6251 } 6252 6253 // ModifyEventSubscriptionWithContext indicates an expected call of ModifyEventSubscriptionWithContext 6254 func (mr *MockRDSAPIMockRecorder) ModifyEventSubscriptionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 6255 mr.mock.ctrl.T.Helper() 6256 varargs := append([]interface{}{arg0, arg1}, arg2...) 6257 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyEventSubscriptionWithContext", reflect.TypeOf((*MockRDSAPI)(nil).ModifyEventSubscriptionWithContext), varargs...) 6258 } 6259 6260 // ModifyGlobalCluster mocks base method 6261 func (m *MockRDSAPI) ModifyGlobalCluster(arg0 *rds.ModifyGlobalClusterInput) (*rds.ModifyGlobalClusterOutput, error) { 6262 m.ctrl.T.Helper() 6263 ret := m.ctrl.Call(m, "ModifyGlobalCluster", arg0) 6264 ret0, _ := ret[0].(*rds.ModifyGlobalClusterOutput) 6265 ret1, _ := ret[1].(error) 6266 return ret0, ret1 6267 } 6268 6269 // ModifyGlobalCluster indicates an expected call of ModifyGlobalCluster 6270 func (mr *MockRDSAPIMockRecorder) ModifyGlobalCluster(arg0 interface{}) *gomock.Call { 6271 mr.mock.ctrl.T.Helper() 6272 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyGlobalCluster", reflect.TypeOf((*MockRDSAPI)(nil).ModifyGlobalCluster), arg0) 6273 } 6274 6275 // ModifyGlobalClusterRequest mocks base method 6276 func (m *MockRDSAPI) ModifyGlobalClusterRequest(arg0 *rds.ModifyGlobalClusterInput) (*request.Request, *rds.ModifyGlobalClusterOutput) { 6277 m.ctrl.T.Helper() 6278 ret := m.ctrl.Call(m, "ModifyGlobalClusterRequest", arg0) 6279 ret0, _ := ret[0].(*request.Request) 6280 ret1, _ := ret[1].(*rds.ModifyGlobalClusterOutput) 6281 return ret0, ret1 6282 } 6283 6284 // ModifyGlobalClusterRequest indicates an expected call of ModifyGlobalClusterRequest 6285 func (mr *MockRDSAPIMockRecorder) ModifyGlobalClusterRequest(arg0 interface{}) *gomock.Call { 6286 mr.mock.ctrl.T.Helper() 6287 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyGlobalClusterRequest", reflect.TypeOf((*MockRDSAPI)(nil).ModifyGlobalClusterRequest), arg0) 6288 } 6289 6290 // ModifyGlobalClusterWithContext mocks base method 6291 func (m *MockRDSAPI) ModifyGlobalClusterWithContext(arg0 context.Context, arg1 *rds.ModifyGlobalClusterInput, arg2 ...request.Option) (*rds.ModifyGlobalClusterOutput, error) { 6292 m.ctrl.T.Helper() 6293 varargs := []interface{}{arg0, arg1} 6294 for _, a := range arg2 { 6295 varargs = append(varargs, a) 6296 } 6297 ret := m.ctrl.Call(m, "ModifyGlobalClusterWithContext", varargs...) 6298 ret0, _ := ret[0].(*rds.ModifyGlobalClusterOutput) 6299 ret1, _ := ret[1].(error) 6300 return ret0, ret1 6301 } 6302 6303 // ModifyGlobalClusterWithContext indicates an expected call of ModifyGlobalClusterWithContext 6304 func (mr *MockRDSAPIMockRecorder) ModifyGlobalClusterWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 6305 mr.mock.ctrl.T.Helper() 6306 varargs := append([]interface{}{arg0, arg1}, arg2...) 6307 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyGlobalClusterWithContext", reflect.TypeOf((*MockRDSAPI)(nil).ModifyGlobalClusterWithContext), varargs...) 6308 } 6309 6310 // ModifyOptionGroup mocks base method 6311 func (m *MockRDSAPI) ModifyOptionGroup(arg0 *rds.ModifyOptionGroupInput) (*rds.ModifyOptionGroupOutput, error) { 6312 m.ctrl.T.Helper() 6313 ret := m.ctrl.Call(m, "ModifyOptionGroup", arg0) 6314 ret0, _ := ret[0].(*rds.ModifyOptionGroupOutput) 6315 ret1, _ := ret[1].(error) 6316 return ret0, ret1 6317 } 6318 6319 // ModifyOptionGroup indicates an expected call of ModifyOptionGroup 6320 func (mr *MockRDSAPIMockRecorder) ModifyOptionGroup(arg0 interface{}) *gomock.Call { 6321 mr.mock.ctrl.T.Helper() 6322 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyOptionGroup", reflect.TypeOf((*MockRDSAPI)(nil).ModifyOptionGroup), arg0) 6323 } 6324 6325 // ModifyOptionGroupRequest mocks base method 6326 func (m *MockRDSAPI) ModifyOptionGroupRequest(arg0 *rds.ModifyOptionGroupInput) (*request.Request, *rds.ModifyOptionGroupOutput) { 6327 m.ctrl.T.Helper() 6328 ret := m.ctrl.Call(m, "ModifyOptionGroupRequest", arg0) 6329 ret0, _ := ret[0].(*request.Request) 6330 ret1, _ := ret[1].(*rds.ModifyOptionGroupOutput) 6331 return ret0, ret1 6332 } 6333 6334 // ModifyOptionGroupRequest indicates an expected call of ModifyOptionGroupRequest 6335 func (mr *MockRDSAPIMockRecorder) ModifyOptionGroupRequest(arg0 interface{}) *gomock.Call { 6336 mr.mock.ctrl.T.Helper() 6337 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyOptionGroupRequest", reflect.TypeOf((*MockRDSAPI)(nil).ModifyOptionGroupRequest), arg0) 6338 } 6339 6340 // ModifyOptionGroupWithContext mocks base method 6341 func (m *MockRDSAPI) ModifyOptionGroupWithContext(arg0 context.Context, arg1 *rds.ModifyOptionGroupInput, arg2 ...request.Option) (*rds.ModifyOptionGroupOutput, error) { 6342 m.ctrl.T.Helper() 6343 varargs := []interface{}{arg0, arg1} 6344 for _, a := range arg2 { 6345 varargs = append(varargs, a) 6346 } 6347 ret := m.ctrl.Call(m, "ModifyOptionGroupWithContext", varargs...) 6348 ret0, _ := ret[0].(*rds.ModifyOptionGroupOutput) 6349 ret1, _ := ret[1].(error) 6350 return ret0, ret1 6351 } 6352 6353 // ModifyOptionGroupWithContext indicates an expected call of ModifyOptionGroupWithContext 6354 func (mr *MockRDSAPIMockRecorder) ModifyOptionGroupWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 6355 mr.mock.ctrl.T.Helper() 6356 varargs := append([]interface{}{arg0, arg1}, arg2...) 6357 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyOptionGroupWithContext", reflect.TypeOf((*MockRDSAPI)(nil).ModifyOptionGroupWithContext), varargs...) 6358 } 6359 6360 // PromoteReadReplica mocks base method 6361 func (m *MockRDSAPI) PromoteReadReplica(arg0 *rds.PromoteReadReplicaInput) (*rds.PromoteReadReplicaOutput, error) { 6362 m.ctrl.T.Helper() 6363 ret := m.ctrl.Call(m, "PromoteReadReplica", arg0) 6364 ret0, _ := ret[0].(*rds.PromoteReadReplicaOutput) 6365 ret1, _ := ret[1].(error) 6366 return ret0, ret1 6367 } 6368 6369 // PromoteReadReplica indicates an expected call of PromoteReadReplica 6370 func (mr *MockRDSAPIMockRecorder) PromoteReadReplica(arg0 interface{}) *gomock.Call { 6371 mr.mock.ctrl.T.Helper() 6372 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PromoteReadReplica", reflect.TypeOf((*MockRDSAPI)(nil).PromoteReadReplica), arg0) 6373 } 6374 6375 // PromoteReadReplicaDBCluster mocks base method 6376 func (m *MockRDSAPI) PromoteReadReplicaDBCluster(arg0 *rds.PromoteReadReplicaDBClusterInput) (*rds.PromoteReadReplicaDBClusterOutput, error) { 6377 m.ctrl.T.Helper() 6378 ret := m.ctrl.Call(m, "PromoteReadReplicaDBCluster", arg0) 6379 ret0, _ := ret[0].(*rds.PromoteReadReplicaDBClusterOutput) 6380 ret1, _ := ret[1].(error) 6381 return ret0, ret1 6382 } 6383 6384 // PromoteReadReplicaDBCluster indicates an expected call of PromoteReadReplicaDBCluster 6385 func (mr *MockRDSAPIMockRecorder) PromoteReadReplicaDBCluster(arg0 interface{}) *gomock.Call { 6386 mr.mock.ctrl.T.Helper() 6387 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PromoteReadReplicaDBCluster", reflect.TypeOf((*MockRDSAPI)(nil).PromoteReadReplicaDBCluster), arg0) 6388 } 6389 6390 // PromoteReadReplicaDBClusterRequest mocks base method 6391 func (m *MockRDSAPI) PromoteReadReplicaDBClusterRequest(arg0 *rds.PromoteReadReplicaDBClusterInput) (*request.Request, *rds.PromoteReadReplicaDBClusterOutput) { 6392 m.ctrl.T.Helper() 6393 ret := m.ctrl.Call(m, "PromoteReadReplicaDBClusterRequest", arg0) 6394 ret0, _ := ret[0].(*request.Request) 6395 ret1, _ := ret[1].(*rds.PromoteReadReplicaDBClusterOutput) 6396 return ret0, ret1 6397 } 6398 6399 // PromoteReadReplicaDBClusterRequest indicates an expected call of PromoteReadReplicaDBClusterRequest 6400 func (mr *MockRDSAPIMockRecorder) PromoteReadReplicaDBClusterRequest(arg0 interface{}) *gomock.Call { 6401 mr.mock.ctrl.T.Helper() 6402 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PromoteReadReplicaDBClusterRequest", reflect.TypeOf((*MockRDSAPI)(nil).PromoteReadReplicaDBClusterRequest), arg0) 6403 } 6404 6405 // PromoteReadReplicaDBClusterWithContext mocks base method 6406 func (m *MockRDSAPI) PromoteReadReplicaDBClusterWithContext(arg0 context.Context, arg1 *rds.PromoteReadReplicaDBClusterInput, arg2 ...request.Option) (*rds.PromoteReadReplicaDBClusterOutput, error) { 6407 m.ctrl.T.Helper() 6408 varargs := []interface{}{arg0, arg1} 6409 for _, a := range arg2 { 6410 varargs = append(varargs, a) 6411 } 6412 ret := m.ctrl.Call(m, "PromoteReadReplicaDBClusterWithContext", varargs...) 6413 ret0, _ := ret[0].(*rds.PromoteReadReplicaDBClusterOutput) 6414 ret1, _ := ret[1].(error) 6415 return ret0, ret1 6416 } 6417 6418 // PromoteReadReplicaDBClusterWithContext indicates an expected call of PromoteReadReplicaDBClusterWithContext 6419 func (mr *MockRDSAPIMockRecorder) PromoteReadReplicaDBClusterWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 6420 mr.mock.ctrl.T.Helper() 6421 varargs := append([]interface{}{arg0, arg1}, arg2...) 6422 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PromoteReadReplicaDBClusterWithContext", reflect.TypeOf((*MockRDSAPI)(nil).PromoteReadReplicaDBClusterWithContext), varargs...) 6423 } 6424 6425 // PromoteReadReplicaRequest mocks base method 6426 func (m *MockRDSAPI) PromoteReadReplicaRequest(arg0 *rds.PromoteReadReplicaInput) (*request.Request, *rds.PromoteReadReplicaOutput) { 6427 m.ctrl.T.Helper() 6428 ret := m.ctrl.Call(m, "PromoteReadReplicaRequest", arg0) 6429 ret0, _ := ret[0].(*request.Request) 6430 ret1, _ := ret[1].(*rds.PromoteReadReplicaOutput) 6431 return ret0, ret1 6432 } 6433 6434 // PromoteReadReplicaRequest indicates an expected call of PromoteReadReplicaRequest 6435 func (mr *MockRDSAPIMockRecorder) PromoteReadReplicaRequest(arg0 interface{}) *gomock.Call { 6436 mr.mock.ctrl.T.Helper() 6437 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PromoteReadReplicaRequest", reflect.TypeOf((*MockRDSAPI)(nil).PromoteReadReplicaRequest), arg0) 6438 } 6439 6440 // PromoteReadReplicaWithContext mocks base method 6441 func (m *MockRDSAPI) PromoteReadReplicaWithContext(arg0 context.Context, arg1 *rds.PromoteReadReplicaInput, arg2 ...request.Option) (*rds.PromoteReadReplicaOutput, error) { 6442 m.ctrl.T.Helper() 6443 varargs := []interface{}{arg0, arg1} 6444 for _, a := range arg2 { 6445 varargs = append(varargs, a) 6446 } 6447 ret := m.ctrl.Call(m, "PromoteReadReplicaWithContext", varargs...) 6448 ret0, _ := ret[0].(*rds.PromoteReadReplicaOutput) 6449 ret1, _ := ret[1].(error) 6450 return ret0, ret1 6451 } 6452 6453 // PromoteReadReplicaWithContext indicates an expected call of PromoteReadReplicaWithContext 6454 func (mr *MockRDSAPIMockRecorder) PromoteReadReplicaWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 6455 mr.mock.ctrl.T.Helper() 6456 varargs := append([]interface{}{arg0, arg1}, arg2...) 6457 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PromoteReadReplicaWithContext", reflect.TypeOf((*MockRDSAPI)(nil).PromoteReadReplicaWithContext), varargs...) 6458 } 6459 6460 // PurchaseReservedDBInstancesOffering mocks base method 6461 func (m *MockRDSAPI) PurchaseReservedDBInstancesOffering(arg0 *rds.PurchaseReservedDBInstancesOfferingInput) (*rds.PurchaseReservedDBInstancesOfferingOutput, error) { 6462 m.ctrl.T.Helper() 6463 ret := m.ctrl.Call(m, "PurchaseReservedDBInstancesOffering", arg0) 6464 ret0, _ := ret[0].(*rds.PurchaseReservedDBInstancesOfferingOutput) 6465 ret1, _ := ret[1].(error) 6466 return ret0, ret1 6467 } 6468 6469 // PurchaseReservedDBInstancesOffering indicates an expected call of PurchaseReservedDBInstancesOffering 6470 func (mr *MockRDSAPIMockRecorder) PurchaseReservedDBInstancesOffering(arg0 interface{}) *gomock.Call { 6471 mr.mock.ctrl.T.Helper() 6472 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PurchaseReservedDBInstancesOffering", reflect.TypeOf((*MockRDSAPI)(nil).PurchaseReservedDBInstancesOffering), arg0) 6473 } 6474 6475 // PurchaseReservedDBInstancesOfferingRequest mocks base method 6476 func (m *MockRDSAPI) PurchaseReservedDBInstancesOfferingRequest(arg0 *rds.PurchaseReservedDBInstancesOfferingInput) (*request.Request, *rds.PurchaseReservedDBInstancesOfferingOutput) { 6477 m.ctrl.T.Helper() 6478 ret := m.ctrl.Call(m, "PurchaseReservedDBInstancesOfferingRequest", arg0) 6479 ret0, _ := ret[0].(*request.Request) 6480 ret1, _ := ret[1].(*rds.PurchaseReservedDBInstancesOfferingOutput) 6481 return ret0, ret1 6482 } 6483 6484 // PurchaseReservedDBInstancesOfferingRequest indicates an expected call of PurchaseReservedDBInstancesOfferingRequest 6485 func (mr *MockRDSAPIMockRecorder) PurchaseReservedDBInstancesOfferingRequest(arg0 interface{}) *gomock.Call { 6486 mr.mock.ctrl.T.Helper() 6487 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PurchaseReservedDBInstancesOfferingRequest", reflect.TypeOf((*MockRDSAPI)(nil).PurchaseReservedDBInstancesOfferingRequest), arg0) 6488 } 6489 6490 // PurchaseReservedDBInstancesOfferingWithContext mocks base method 6491 func (m *MockRDSAPI) PurchaseReservedDBInstancesOfferingWithContext(arg0 context.Context, arg1 *rds.PurchaseReservedDBInstancesOfferingInput, arg2 ...request.Option) (*rds.PurchaseReservedDBInstancesOfferingOutput, error) { 6492 m.ctrl.T.Helper() 6493 varargs := []interface{}{arg0, arg1} 6494 for _, a := range arg2 { 6495 varargs = append(varargs, a) 6496 } 6497 ret := m.ctrl.Call(m, "PurchaseReservedDBInstancesOfferingWithContext", varargs...) 6498 ret0, _ := ret[0].(*rds.PurchaseReservedDBInstancesOfferingOutput) 6499 ret1, _ := ret[1].(error) 6500 return ret0, ret1 6501 } 6502 6503 // PurchaseReservedDBInstancesOfferingWithContext indicates an expected call of PurchaseReservedDBInstancesOfferingWithContext 6504 func (mr *MockRDSAPIMockRecorder) PurchaseReservedDBInstancesOfferingWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 6505 mr.mock.ctrl.T.Helper() 6506 varargs := append([]interface{}{arg0, arg1}, arg2...) 6507 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PurchaseReservedDBInstancesOfferingWithContext", reflect.TypeOf((*MockRDSAPI)(nil).PurchaseReservedDBInstancesOfferingWithContext), varargs...) 6508 } 6509 6510 // RebootDBInstance mocks base method 6511 func (m *MockRDSAPI) RebootDBInstance(arg0 *rds.RebootDBInstanceInput) (*rds.RebootDBInstanceOutput, error) { 6512 m.ctrl.T.Helper() 6513 ret := m.ctrl.Call(m, "RebootDBInstance", arg0) 6514 ret0, _ := ret[0].(*rds.RebootDBInstanceOutput) 6515 ret1, _ := ret[1].(error) 6516 return ret0, ret1 6517 } 6518 6519 // RebootDBInstance indicates an expected call of RebootDBInstance 6520 func (mr *MockRDSAPIMockRecorder) RebootDBInstance(arg0 interface{}) *gomock.Call { 6521 mr.mock.ctrl.T.Helper() 6522 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RebootDBInstance", reflect.TypeOf((*MockRDSAPI)(nil).RebootDBInstance), arg0) 6523 } 6524 6525 // RebootDBInstanceRequest mocks base method 6526 func (m *MockRDSAPI) RebootDBInstanceRequest(arg0 *rds.RebootDBInstanceInput) (*request.Request, *rds.RebootDBInstanceOutput) { 6527 m.ctrl.T.Helper() 6528 ret := m.ctrl.Call(m, "RebootDBInstanceRequest", arg0) 6529 ret0, _ := ret[0].(*request.Request) 6530 ret1, _ := ret[1].(*rds.RebootDBInstanceOutput) 6531 return ret0, ret1 6532 } 6533 6534 // RebootDBInstanceRequest indicates an expected call of RebootDBInstanceRequest 6535 func (mr *MockRDSAPIMockRecorder) RebootDBInstanceRequest(arg0 interface{}) *gomock.Call { 6536 mr.mock.ctrl.T.Helper() 6537 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RebootDBInstanceRequest", reflect.TypeOf((*MockRDSAPI)(nil).RebootDBInstanceRequest), arg0) 6538 } 6539 6540 // RebootDBInstanceWithContext mocks base method 6541 func (m *MockRDSAPI) RebootDBInstanceWithContext(arg0 context.Context, arg1 *rds.RebootDBInstanceInput, arg2 ...request.Option) (*rds.RebootDBInstanceOutput, error) { 6542 m.ctrl.T.Helper() 6543 varargs := []interface{}{arg0, arg1} 6544 for _, a := range arg2 { 6545 varargs = append(varargs, a) 6546 } 6547 ret := m.ctrl.Call(m, "RebootDBInstanceWithContext", varargs...) 6548 ret0, _ := ret[0].(*rds.RebootDBInstanceOutput) 6549 ret1, _ := ret[1].(error) 6550 return ret0, ret1 6551 } 6552 6553 // RebootDBInstanceWithContext indicates an expected call of RebootDBInstanceWithContext 6554 func (mr *MockRDSAPIMockRecorder) RebootDBInstanceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 6555 mr.mock.ctrl.T.Helper() 6556 varargs := append([]interface{}{arg0, arg1}, arg2...) 6557 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RebootDBInstanceWithContext", reflect.TypeOf((*MockRDSAPI)(nil).RebootDBInstanceWithContext), varargs...) 6558 } 6559 6560 // RegisterDBProxyTargets mocks base method 6561 func (m *MockRDSAPI) RegisterDBProxyTargets(arg0 *rds.RegisterDBProxyTargetsInput) (*rds.RegisterDBProxyTargetsOutput, error) { 6562 m.ctrl.T.Helper() 6563 ret := m.ctrl.Call(m, "RegisterDBProxyTargets", arg0) 6564 ret0, _ := ret[0].(*rds.RegisterDBProxyTargetsOutput) 6565 ret1, _ := ret[1].(error) 6566 return ret0, ret1 6567 } 6568 6569 // RegisterDBProxyTargets indicates an expected call of RegisterDBProxyTargets 6570 func (mr *MockRDSAPIMockRecorder) RegisterDBProxyTargets(arg0 interface{}) *gomock.Call { 6571 mr.mock.ctrl.T.Helper() 6572 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterDBProxyTargets", reflect.TypeOf((*MockRDSAPI)(nil).RegisterDBProxyTargets), arg0) 6573 } 6574 6575 // RegisterDBProxyTargetsRequest mocks base method 6576 func (m *MockRDSAPI) RegisterDBProxyTargetsRequest(arg0 *rds.RegisterDBProxyTargetsInput) (*request.Request, *rds.RegisterDBProxyTargetsOutput) { 6577 m.ctrl.T.Helper() 6578 ret := m.ctrl.Call(m, "RegisterDBProxyTargetsRequest", arg0) 6579 ret0, _ := ret[0].(*request.Request) 6580 ret1, _ := ret[1].(*rds.RegisterDBProxyTargetsOutput) 6581 return ret0, ret1 6582 } 6583 6584 // RegisterDBProxyTargetsRequest indicates an expected call of RegisterDBProxyTargetsRequest 6585 func (mr *MockRDSAPIMockRecorder) RegisterDBProxyTargetsRequest(arg0 interface{}) *gomock.Call { 6586 mr.mock.ctrl.T.Helper() 6587 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterDBProxyTargetsRequest", reflect.TypeOf((*MockRDSAPI)(nil).RegisterDBProxyTargetsRequest), arg0) 6588 } 6589 6590 // RegisterDBProxyTargetsWithContext mocks base method 6591 func (m *MockRDSAPI) RegisterDBProxyTargetsWithContext(arg0 context.Context, arg1 *rds.RegisterDBProxyTargetsInput, arg2 ...request.Option) (*rds.RegisterDBProxyTargetsOutput, error) { 6592 m.ctrl.T.Helper() 6593 varargs := []interface{}{arg0, arg1} 6594 for _, a := range arg2 { 6595 varargs = append(varargs, a) 6596 } 6597 ret := m.ctrl.Call(m, "RegisterDBProxyTargetsWithContext", varargs...) 6598 ret0, _ := ret[0].(*rds.RegisterDBProxyTargetsOutput) 6599 ret1, _ := ret[1].(error) 6600 return ret0, ret1 6601 } 6602 6603 // RegisterDBProxyTargetsWithContext indicates an expected call of RegisterDBProxyTargetsWithContext 6604 func (mr *MockRDSAPIMockRecorder) RegisterDBProxyTargetsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 6605 mr.mock.ctrl.T.Helper() 6606 varargs := append([]interface{}{arg0, arg1}, arg2...) 6607 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterDBProxyTargetsWithContext", reflect.TypeOf((*MockRDSAPI)(nil).RegisterDBProxyTargetsWithContext), varargs...) 6608 } 6609 6610 // RemoveFromGlobalCluster mocks base method 6611 func (m *MockRDSAPI) RemoveFromGlobalCluster(arg0 *rds.RemoveFromGlobalClusterInput) (*rds.RemoveFromGlobalClusterOutput, error) { 6612 m.ctrl.T.Helper() 6613 ret := m.ctrl.Call(m, "RemoveFromGlobalCluster", arg0) 6614 ret0, _ := ret[0].(*rds.RemoveFromGlobalClusterOutput) 6615 ret1, _ := ret[1].(error) 6616 return ret0, ret1 6617 } 6618 6619 // RemoveFromGlobalCluster indicates an expected call of RemoveFromGlobalCluster 6620 func (mr *MockRDSAPIMockRecorder) RemoveFromGlobalCluster(arg0 interface{}) *gomock.Call { 6621 mr.mock.ctrl.T.Helper() 6622 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveFromGlobalCluster", reflect.TypeOf((*MockRDSAPI)(nil).RemoveFromGlobalCluster), arg0) 6623 } 6624 6625 // RemoveFromGlobalClusterRequest mocks base method 6626 func (m *MockRDSAPI) RemoveFromGlobalClusterRequest(arg0 *rds.RemoveFromGlobalClusterInput) (*request.Request, *rds.RemoveFromGlobalClusterOutput) { 6627 m.ctrl.T.Helper() 6628 ret := m.ctrl.Call(m, "RemoveFromGlobalClusterRequest", arg0) 6629 ret0, _ := ret[0].(*request.Request) 6630 ret1, _ := ret[1].(*rds.RemoveFromGlobalClusterOutput) 6631 return ret0, ret1 6632 } 6633 6634 // RemoveFromGlobalClusterRequest indicates an expected call of RemoveFromGlobalClusterRequest 6635 func (mr *MockRDSAPIMockRecorder) RemoveFromGlobalClusterRequest(arg0 interface{}) *gomock.Call { 6636 mr.mock.ctrl.T.Helper() 6637 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveFromGlobalClusterRequest", reflect.TypeOf((*MockRDSAPI)(nil).RemoveFromGlobalClusterRequest), arg0) 6638 } 6639 6640 // RemoveFromGlobalClusterWithContext mocks base method 6641 func (m *MockRDSAPI) RemoveFromGlobalClusterWithContext(arg0 context.Context, arg1 *rds.RemoveFromGlobalClusterInput, arg2 ...request.Option) (*rds.RemoveFromGlobalClusterOutput, error) { 6642 m.ctrl.T.Helper() 6643 varargs := []interface{}{arg0, arg1} 6644 for _, a := range arg2 { 6645 varargs = append(varargs, a) 6646 } 6647 ret := m.ctrl.Call(m, "RemoveFromGlobalClusterWithContext", varargs...) 6648 ret0, _ := ret[0].(*rds.RemoveFromGlobalClusterOutput) 6649 ret1, _ := ret[1].(error) 6650 return ret0, ret1 6651 } 6652 6653 // RemoveFromGlobalClusterWithContext indicates an expected call of RemoveFromGlobalClusterWithContext 6654 func (mr *MockRDSAPIMockRecorder) RemoveFromGlobalClusterWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 6655 mr.mock.ctrl.T.Helper() 6656 varargs := append([]interface{}{arg0, arg1}, arg2...) 6657 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveFromGlobalClusterWithContext", reflect.TypeOf((*MockRDSAPI)(nil).RemoveFromGlobalClusterWithContext), varargs...) 6658 } 6659 6660 // RemoveRoleFromDBCluster mocks base method 6661 func (m *MockRDSAPI) RemoveRoleFromDBCluster(arg0 *rds.RemoveRoleFromDBClusterInput) (*rds.RemoveRoleFromDBClusterOutput, error) { 6662 m.ctrl.T.Helper() 6663 ret := m.ctrl.Call(m, "RemoveRoleFromDBCluster", arg0) 6664 ret0, _ := ret[0].(*rds.RemoveRoleFromDBClusterOutput) 6665 ret1, _ := ret[1].(error) 6666 return ret0, ret1 6667 } 6668 6669 // RemoveRoleFromDBCluster indicates an expected call of RemoveRoleFromDBCluster 6670 func (mr *MockRDSAPIMockRecorder) RemoveRoleFromDBCluster(arg0 interface{}) *gomock.Call { 6671 mr.mock.ctrl.T.Helper() 6672 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveRoleFromDBCluster", reflect.TypeOf((*MockRDSAPI)(nil).RemoveRoleFromDBCluster), arg0) 6673 } 6674 6675 // RemoveRoleFromDBClusterRequest mocks base method 6676 func (m *MockRDSAPI) RemoveRoleFromDBClusterRequest(arg0 *rds.RemoveRoleFromDBClusterInput) (*request.Request, *rds.RemoveRoleFromDBClusterOutput) { 6677 m.ctrl.T.Helper() 6678 ret := m.ctrl.Call(m, "RemoveRoleFromDBClusterRequest", arg0) 6679 ret0, _ := ret[0].(*request.Request) 6680 ret1, _ := ret[1].(*rds.RemoveRoleFromDBClusterOutput) 6681 return ret0, ret1 6682 } 6683 6684 // RemoveRoleFromDBClusterRequest indicates an expected call of RemoveRoleFromDBClusterRequest 6685 func (mr *MockRDSAPIMockRecorder) RemoveRoleFromDBClusterRequest(arg0 interface{}) *gomock.Call { 6686 mr.mock.ctrl.T.Helper() 6687 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveRoleFromDBClusterRequest", reflect.TypeOf((*MockRDSAPI)(nil).RemoveRoleFromDBClusterRequest), arg0) 6688 } 6689 6690 // RemoveRoleFromDBClusterWithContext mocks base method 6691 func (m *MockRDSAPI) RemoveRoleFromDBClusterWithContext(arg0 context.Context, arg1 *rds.RemoveRoleFromDBClusterInput, arg2 ...request.Option) (*rds.RemoveRoleFromDBClusterOutput, error) { 6692 m.ctrl.T.Helper() 6693 varargs := []interface{}{arg0, arg1} 6694 for _, a := range arg2 { 6695 varargs = append(varargs, a) 6696 } 6697 ret := m.ctrl.Call(m, "RemoveRoleFromDBClusterWithContext", varargs...) 6698 ret0, _ := ret[0].(*rds.RemoveRoleFromDBClusterOutput) 6699 ret1, _ := ret[1].(error) 6700 return ret0, ret1 6701 } 6702 6703 // RemoveRoleFromDBClusterWithContext indicates an expected call of RemoveRoleFromDBClusterWithContext 6704 func (mr *MockRDSAPIMockRecorder) RemoveRoleFromDBClusterWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 6705 mr.mock.ctrl.T.Helper() 6706 varargs := append([]interface{}{arg0, arg1}, arg2...) 6707 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveRoleFromDBClusterWithContext", reflect.TypeOf((*MockRDSAPI)(nil).RemoveRoleFromDBClusterWithContext), varargs...) 6708 } 6709 6710 // RemoveRoleFromDBInstance mocks base method 6711 func (m *MockRDSAPI) RemoveRoleFromDBInstance(arg0 *rds.RemoveRoleFromDBInstanceInput) (*rds.RemoveRoleFromDBInstanceOutput, error) { 6712 m.ctrl.T.Helper() 6713 ret := m.ctrl.Call(m, "RemoveRoleFromDBInstance", arg0) 6714 ret0, _ := ret[0].(*rds.RemoveRoleFromDBInstanceOutput) 6715 ret1, _ := ret[1].(error) 6716 return ret0, ret1 6717 } 6718 6719 // RemoveRoleFromDBInstance indicates an expected call of RemoveRoleFromDBInstance 6720 func (mr *MockRDSAPIMockRecorder) RemoveRoleFromDBInstance(arg0 interface{}) *gomock.Call { 6721 mr.mock.ctrl.T.Helper() 6722 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveRoleFromDBInstance", reflect.TypeOf((*MockRDSAPI)(nil).RemoveRoleFromDBInstance), arg0) 6723 } 6724 6725 // RemoveRoleFromDBInstanceRequest mocks base method 6726 func (m *MockRDSAPI) RemoveRoleFromDBInstanceRequest(arg0 *rds.RemoveRoleFromDBInstanceInput) (*request.Request, *rds.RemoveRoleFromDBInstanceOutput) { 6727 m.ctrl.T.Helper() 6728 ret := m.ctrl.Call(m, "RemoveRoleFromDBInstanceRequest", arg0) 6729 ret0, _ := ret[0].(*request.Request) 6730 ret1, _ := ret[1].(*rds.RemoveRoleFromDBInstanceOutput) 6731 return ret0, ret1 6732 } 6733 6734 // RemoveRoleFromDBInstanceRequest indicates an expected call of RemoveRoleFromDBInstanceRequest 6735 func (mr *MockRDSAPIMockRecorder) RemoveRoleFromDBInstanceRequest(arg0 interface{}) *gomock.Call { 6736 mr.mock.ctrl.T.Helper() 6737 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveRoleFromDBInstanceRequest", reflect.TypeOf((*MockRDSAPI)(nil).RemoveRoleFromDBInstanceRequest), arg0) 6738 } 6739 6740 // RemoveRoleFromDBInstanceWithContext mocks base method 6741 func (m *MockRDSAPI) RemoveRoleFromDBInstanceWithContext(arg0 context.Context, arg1 *rds.RemoveRoleFromDBInstanceInput, arg2 ...request.Option) (*rds.RemoveRoleFromDBInstanceOutput, error) { 6742 m.ctrl.T.Helper() 6743 varargs := []interface{}{arg0, arg1} 6744 for _, a := range arg2 { 6745 varargs = append(varargs, a) 6746 } 6747 ret := m.ctrl.Call(m, "RemoveRoleFromDBInstanceWithContext", varargs...) 6748 ret0, _ := ret[0].(*rds.RemoveRoleFromDBInstanceOutput) 6749 ret1, _ := ret[1].(error) 6750 return ret0, ret1 6751 } 6752 6753 // RemoveRoleFromDBInstanceWithContext indicates an expected call of RemoveRoleFromDBInstanceWithContext 6754 func (mr *MockRDSAPIMockRecorder) RemoveRoleFromDBInstanceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 6755 mr.mock.ctrl.T.Helper() 6756 varargs := append([]interface{}{arg0, arg1}, arg2...) 6757 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveRoleFromDBInstanceWithContext", reflect.TypeOf((*MockRDSAPI)(nil).RemoveRoleFromDBInstanceWithContext), varargs...) 6758 } 6759 6760 // RemoveSourceIdentifierFromSubscription mocks base method 6761 func (m *MockRDSAPI) RemoveSourceIdentifierFromSubscription(arg0 *rds.RemoveSourceIdentifierFromSubscriptionInput) (*rds.RemoveSourceIdentifierFromSubscriptionOutput, error) { 6762 m.ctrl.T.Helper() 6763 ret := m.ctrl.Call(m, "RemoveSourceIdentifierFromSubscription", arg0) 6764 ret0, _ := ret[0].(*rds.RemoveSourceIdentifierFromSubscriptionOutput) 6765 ret1, _ := ret[1].(error) 6766 return ret0, ret1 6767 } 6768 6769 // RemoveSourceIdentifierFromSubscription indicates an expected call of RemoveSourceIdentifierFromSubscription 6770 func (mr *MockRDSAPIMockRecorder) RemoveSourceIdentifierFromSubscription(arg0 interface{}) *gomock.Call { 6771 mr.mock.ctrl.T.Helper() 6772 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveSourceIdentifierFromSubscription", reflect.TypeOf((*MockRDSAPI)(nil).RemoveSourceIdentifierFromSubscription), arg0) 6773 } 6774 6775 // RemoveSourceIdentifierFromSubscriptionRequest mocks base method 6776 func (m *MockRDSAPI) RemoveSourceIdentifierFromSubscriptionRequest(arg0 *rds.RemoveSourceIdentifierFromSubscriptionInput) (*request.Request, *rds.RemoveSourceIdentifierFromSubscriptionOutput) { 6777 m.ctrl.T.Helper() 6778 ret := m.ctrl.Call(m, "RemoveSourceIdentifierFromSubscriptionRequest", arg0) 6779 ret0, _ := ret[0].(*request.Request) 6780 ret1, _ := ret[1].(*rds.RemoveSourceIdentifierFromSubscriptionOutput) 6781 return ret0, ret1 6782 } 6783 6784 // RemoveSourceIdentifierFromSubscriptionRequest indicates an expected call of RemoveSourceIdentifierFromSubscriptionRequest 6785 func (mr *MockRDSAPIMockRecorder) RemoveSourceIdentifierFromSubscriptionRequest(arg0 interface{}) *gomock.Call { 6786 mr.mock.ctrl.T.Helper() 6787 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveSourceIdentifierFromSubscriptionRequest", reflect.TypeOf((*MockRDSAPI)(nil).RemoveSourceIdentifierFromSubscriptionRequest), arg0) 6788 } 6789 6790 // RemoveSourceIdentifierFromSubscriptionWithContext mocks base method 6791 func (m *MockRDSAPI) RemoveSourceIdentifierFromSubscriptionWithContext(arg0 context.Context, arg1 *rds.RemoveSourceIdentifierFromSubscriptionInput, arg2 ...request.Option) (*rds.RemoveSourceIdentifierFromSubscriptionOutput, error) { 6792 m.ctrl.T.Helper() 6793 varargs := []interface{}{arg0, arg1} 6794 for _, a := range arg2 { 6795 varargs = append(varargs, a) 6796 } 6797 ret := m.ctrl.Call(m, "RemoveSourceIdentifierFromSubscriptionWithContext", varargs...) 6798 ret0, _ := ret[0].(*rds.RemoveSourceIdentifierFromSubscriptionOutput) 6799 ret1, _ := ret[1].(error) 6800 return ret0, ret1 6801 } 6802 6803 // RemoveSourceIdentifierFromSubscriptionWithContext indicates an expected call of RemoveSourceIdentifierFromSubscriptionWithContext 6804 func (mr *MockRDSAPIMockRecorder) RemoveSourceIdentifierFromSubscriptionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 6805 mr.mock.ctrl.T.Helper() 6806 varargs := append([]interface{}{arg0, arg1}, arg2...) 6807 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveSourceIdentifierFromSubscriptionWithContext", reflect.TypeOf((*MockRDSAPI)(nil).RemoveSourceIdentifierFromSubscriptionWithContext), varargs...) 6808 } 6809 6810 // RemoveTagsFromResource mocks base method 6811 func (m *MockRDSAPI) RemoveTagsFromResource(arg0 *rds.RemoveTagsFromResourceInput) (*rds.RemoveTagsFromResourceOutput, error) { 6812 m.ctrl.T.Helper() 6813 ret := m.ctrl.Call(m, "RemoveTagsFromResource", arg0) 6814 ret0, _ := ret[0].(*rds.RemoveTagsFromResourceOutput) 6815 ret1, _ := ret[1].(error) 6816 return ret0, ret1 6817 } 6818 6819 // RemoveTagsFromResource indicates an expected call of RemoveTagsFromResource 6820 func (mr *MockRDSAPIMockRecorder) RemoveTagsFromResource(arg0 interface{}) *gomock.Call { 6821 mr.mock.ctrl.T.Helper() 6822 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveTagsFromResource", reflect.TypeOf((*MockRDSAPI)(nil).RemoveTagsFromResource), arg0) 6823 } 6824 6825 // RemoveTagsFromResourceRequest mocks base method 6826 func (m *MockRDSAPI) RemoveTagsFromResourceRequest(arg0 *rds.RemoveTagsFromResourceInput) (*request.Request, *rds.RemoveTagsFromResourceOutput) { 6827 m.ctrl.T.Helper() 6828 ret := m.ctrl.Call(m, "RemoveTagsFromResourceRequest", arg0) 6829 ret0, _ := ret[0].(*request.Request) 6830 ret1, _ := ret[1].(*rds.RemoveTagsFromResourceOutput) 6831 return ret0, ret1 6832 } 6833 6834 // RemoveTagsFromResourceRequest indicates an expected call of RemoveTagsFromResourceRequest 6835 func (mr *MockRDSAPIMockRecorder) RemoveTagsFromResourceRequest(arg0 interface{}) *gomock.Call { 6836 mr.mock.ctrl.T.Helper() 6837 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveTagsFromResourceRequest", reflect.TypeOf((*MockRDSAPI)(nil).RemoveTagsFromResourceRequest), arg0) 6838 } 6839 6840 // RemoveTagsFromResourceWithContext mocks base method 6841 func (m *MockRDSAPI) RemoveTagsFromResourceWithContext(arg0 context.Context, arg1 *rds.RemoveTagsFromResourceInput, arg2 ...request.Option) (*rds.RemoveTagsFromResourceOutput, error) { 6842 m.ctrl.T.Helper() 6843 varargs := []interface{}{arg0, arg1} 6844 for _, a := range arg2 { 6845 varargs = append(varargs, a) 6846 } 6847 ret := m.ctrl.Call(m, "RemoveTagsFromResourceWithContext", varargs...) 6848 ret0, _ := ret[0].(*rds.RemoveTagsFromResourceOutput) 6849 ret1, _ := ret[1].(error) 6850 return ret0, ret1 6851 } 6852 6853 // RemoveTagsFromResourceWithContext indicates an expected call of RemoveTagsFromResourceWithContext 6854 func (mr *MockRDSAPIMockRecorder) RemoveTagsFromResourceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 6855 mr.mock.ctrl.T.Helper() 6856 varargs := append([]interface{}{arg0, arg1}, arg2...) 6857 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveTagsFromResourceWithContext", reflect.TypeOf((*MockRDSAPI)(nil).RemoveTagsFromResourceWithContext), varargs...) 6858 } 6859 6860 // ResetDBClusterParameterGroup mocks base method 6861 func (m *MockRDSAPI) ResetDBClusterParameterGroup(arg0 *rds.ResetDBClusterParameterGroupInput) (*rds.DBClusterParameterGroupNameMessage, error) { 6862 m.ctrl.T.Helper() 6863 ret := m.ctrl.Call(m, "ResetDBClusterParameterGroup", arg0) 6864 ret0, _ := ret[0].(*rds.DBClusterParameterGroupNameMessage) 6865 ret1, _ := ret[1].(error) 6866 return ret0, ret1 6867 } 6868 6869 // ResetDBClusterParameterGroup indicates an expected call of ResetDBClusterParameterGroup 6870 func (mr *MockRDSAPIMockRecorder) ResetDBClusterParameterGroup(arg0 interface{}) *gomock.Call { 6871 mr.mock.ctrl.T.Helper() 6872 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetDBClusterParameterGroup", reflect.TypeOf((*MockRDSAPI)(nil).ResetDBClusterParameterGroup), arg0) 6873 } 6874 6875 // ResetDBClusterParameterGroupRequest mocks base method 6876 func (m *MockRDSAPI) ResetDBClusterParameterGroupRequest(arg0 *rds.ResetDBClusterParameterGroupInput) (*request.Request, *rds.DBClusterParameterGroupNameMessage) { 6877 m.ctrl.T.Helper() 6878 ret := m.ctrl.Call(m, "ResetDBClusterParameterGroupRequest", arg0) 6879 ret0, _ := ret[0].(*request.Request) 6880 ret1, _ := ret[1].(*rds.DBClusterParameterGroupNameMessage) 6881 return ret0, ret1 6882 } 6883 6884 // ResetDBClusterParameterGroupRequest indicates an expected call of ResetDBClusterParameterGroupRequest 6885 func (mr *MockRDSAPIMockRecorder) ResetDBClusterParameterGroupRequest(arg0 interface{}) *gomock.Call { 6886 mr.mock.ctrl.T.Helper() 6887 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetDBClusterParameterGroupRequest", reflect.TypeOf((*MockRDSAPI)(nil).ResetDBClusterParameterGroupRequest), arg0) 6888 } 6889 6890 // ResetDBClusterParameterGroupWithContext mocks base method 6891 func (m *MockRDSAPI) ResetDBClusterParameterGroupWithContext(arg0 context.Context, arg1 *rds.ResetDBClusterParameterGroupInput, arg2 ...request.Option) (*rds.DBClusterParameterGroupNameMessage, error) { 6892 m.ctrl.T.Helper() 6893 varargs := []interface{}{arg0, arg1} 6894 for _, a := range arg2 { 6895 varargs = append(varargs, a) 6896 } 6897 ret := m.ctrl.Call(m, "ResetDBClusterParameterGroupWithContext", varargs...) 6898 ret0, _ := ret[0].(*rds.DBClusterParameterGroupNameMessage) 6899 ret1, _ := ret[1].(error) 6900 return ret0, ret1 6901 } 6902 6903 // ResetDBClusterParameterGroupWithContext indicates an expected call of ResetDBClusterParameterGroupWithContext 6904 func (mr *MockRDSAPIMockRecorder) ResetDBClusterParameterGroupWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 6905 mr.mock.ctrl.T.Helper() 6906 varargs := append([]interface{}{arg0, arg1}, arg2...) 6907 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetDBClusterParameterGroupWithContext", reflect.TypeOf((*MockRDSAPI)(nil).ResetDBClusterParameterGroupWithContext), varargs...) 6908 } 6909 6910 // ResetDBParameterGroup mocks base method 6911 func (m *MockRDSAPI) ResetDBParameterGroup(arg0 *rds.ResetDBParameterGroupInput) (*rds.DBParameterGroupNameMessage, error) { 6912 m.ctrl.T.Helper() 6913 ret := m.ctrl.Call(m, "ResetDBParameterGroup", arg0) 6914 ret0, _ := ret[0].(*rds.DBParameterGroupNameMessage) 6915 ret1, _ := ret[1].(error) 6916 return ret0, ret1 6917 } 6918 6919 // ResetDBParameterGroup indicates an expected call of ResetDBParameterGroup 6920 func (mr *MockRDSAPIMockRecorder) ResetDBParameterGroup(arg0 interface{}) *gomock.Call { 6921 mr.mock.ctrl.T.Helper() 6922 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetDBParameterGroup", reflect.TypeOf((*MockRDSAPI)(nil).ResetDBParameterGroup), arg0) 6923 } 6924 6925 // ResetDBParameterGroupRequest mocks base method 6926 func (m *MockRDSAPI) ResetDBParameterGroupRequest(arg0 *rds.ResetDBParameterGroupInput) (*request.Request, *rds.DBParameterGroupNameMessage) { 6927 m.ctrl.T.Helper() 6928 ret := m.ctrl.Call(m, "ResetDBParameterGroupRequest", arg0) 6929 ret0, _ := ret[0].(*request.Request) 6930 ret1, _ := ret[1].(*rds.DBParameterGroupNameMessage) 6931 return ret0, ret1 6932 } 6933 6934 // ResetDBParameterGroupRequest indicates an expected call of ResetDBParameterGroupRequest 6935 func (mr *MockRDSAPIMockRecorder) ResetDBParameterGroupRequest(arg0 interface{}) *gomock.Call { 6936 mr.mock.ctrl.T.Helper() 6937 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetDBParameterGroupRequest", reflect.TypeOf((*MockRDSAPI)(nil).ResetDBParameterGroupRequest), arg0) 6938 } 6939 6940 // ResetDBParameterGroupWithContext mocks base method 6941 func (m *MockRDSAPI) ResetDBParameterGroupWithContext(arg0 context.Context, arg1 *rds.ResetDBParameterGroupInput, arg2 ...request.Option) (*rds.DBParameterGroupNameMessage, error) { 6942 m.ctrl.T.Helper() 6943 varargs := []interface{}{arg0, arg1} 6944 for _, a := range arg2 { 6945 varargs = append(varargs, a) 6946 } 6947 ret := m.ctrl.Call(m, "ResetDBParameterGroupWithContext", varargs...) 6948 ret0, _ := ret[0].(*rds.DBParameterGroupNameMessage) 6949 ret1, _ := ret[1].(error) 6950 return ret0, ret1 6951 } 6952 6953 // ResetDBParameterGroupWithContext indicates an expected call of ResetDBParameterGroupWithContext 6954 func (mr *MockRDSAPIMockRecorder) ResetDBParameterGroupWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 6955 mr.mock.ctrl.T.Helper() 6956 varargs := append([]interface{}{arg0, arg1}, arg2...) 6957 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetDBParameterGroupWithContext", reflect.TypeOf((*MockRDSAPI)(nil).ResetDBParameterGroupWithContext), varargs...) 6958 } 6959 6960 // RestoreDBClusterFromS3 mocks base method 6961 func (m *MockRDSAPI) RestoreDBClusterFromS3(arg0 *rds.RestoreDBClusterFromS3Input) (*rds.RestoreDBClusterFromS3Output, error) { 6962 m.ctrl.T.Helper() 6963 ret := m.ctrl.Call(m, "RestoreDBClusterFromS3", arg0) 6964 ret0, _ := ret[0].(*rds.RestoreDBClusterFromS3Output) 6965 ret1, _ := ret[1].(error) 6966 return ret0, ret1 6967 } 6968 6969 // RestoreDBClusterFromS3 indicates an expected call of RestoreDBClusterFromS3 6970 func (mr *MockRDSAPIMockRecorder) RestoreDBClusterFromS3(arg0 interface{}) *gomock.Call { 6971 mr.mock.ctrl.T.Helper() 6972 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RestoreDBClusterFromS3", reflect.TypeOf((*MockRDSAPI)(nil).RestoreDBClusterFromS3), arg0) 6973 } 6974 6975 // RestoreDBClusterFromS3Request mocks base method 6976 func (m *MockRDSAPI) RestoreDBClusterFromS3Request(arg0 *rds.RestoreDBClusterFromS3Input) (*request.Request, *rds.RestoreDBClusterFromS3Output) { 6977 m.ctrl.T.Helper() 6978 ret := m.ctrl.Call(m, "RestoreDBClusterFromS3Request", arg0) 6979 ret0, _ := ret[0].(*request.Request) 6980 ret1, _ := ret[1].(*rds.RestoreDBClusterFromS3Output) 6981 return ret0, ret1 6982 } 6983 6984 // RestoreDBClusterFromS3Request indicates an expected call of RestoreDBClusterFromS3Request 6985 func (mr *MockRDSAPIMockRecorder) RestoreDBClusterFromS3Request(arg0 interface{}) *gomock.Call { 6986 mr.mock.ctrl.T.Helper() 6987 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RestoreDBClusterFromS3Request", reflect.TypeOf((*MockRDSAPI)(nil).RestoreDBClusterFromS3Request), arg0) 6988 } 6989 6990 // RestoreDBClusterFromS3WithContext mocks base method 6991 func (m *MockRDSAPI) RestoreDBClusterFromS3WithContext(arg0 context.Context, arg1 *rds.RestoreDBClusterFromS3Input, arg2 ...request.Option) (*rds.RestoreDBClusterFromS3Output, error) { 6992 m.ctrl.T.Helper() 6993 varargs := []interface{}{arg0, arg1} 6994 for _, a := range arg2 { 6995 varargs = append(varargs, a) 6996 } 6997 ret := m.ctrl.Call(m, "RestoreDBClusterFromS3WithContext", varargs...) 6998 ret0, _ := ret[0].(*rds.RestoreDBClusterFromS3Output) 6999 ret1, _ := ret[1].(error) 7000 return ret0, ret1 7001 } 7002 7003 // RestoreDBClusterFromS3WithContext indicates an expected call of RestoreDBClusterFromS3WithContext 7004 func (mr *MockRDSAPIMockRecorder) RestoreDBClusterFromS3WithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 7005 mr.mock.ctrl.T.Helper() 7006 varargs := append([]interface{}{arg0, arg1}, arg2...) 7007 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RestoreDBClusterFromS3WithContext", reflect.TypeOf((*MockRDSAPI)(nil).RestoreDBClusterFromS3WithContext), varargs...) 7008 } 7009 7010 // RestoreDBClusterFromSnapshot mocks base method 7011 func (m *MockRDSAPI) RestoreDBClusterFromSnapshot(arg0 *rds.RestoreDBClusterFromSnapshotInput) (*rds.RestoreDBClusterFromSnapshotOutput, error) { 7012 m.ctrl.T.Helper() 7013 ret := m.ctrl.Call(m, "RestoreDBClusterFromSnapshot", arg0) 7014 ret0, _ := ret[0].(*rds.RestoreDBClusterFromSnapshotOutput) 7015 ret1, _ := ret[1].(error) 7016 return ret0, ret1 7017 } 7018 7019 // RestoreDBClusterFromSnapshot indicates an expected call of RestoreDBClusterFromSnapshot 7020 func (mr *MockRDSAPIMockRecorder) RestoreDBClusterFromSnapshot(arg0 interface{}) *gomock.Call { 7021 mr.mock.ctrl.T.Helper() 7022 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RestoreDBClusterFromSnapshot", reflect.TypeOf((*MockRDSAPI)(nil).RestoreDBClusterFromSnapshot), arg0) 7023 } 7024 7025 // RestoreDBClusterFromSnapshotRequest mocks base method 7026 func (m *MockRDSAPI) RestoreDBClusterFromSnapshotRequest(arg0 *rds.RestoreDBClusterFromSnapshotInput) (*request.Request, *rds.RestoreDBClusterFromSnapshotOutput) { 7027 m.ctrl.T.Helper() 7028 ret := m.ctrl.Call(m, "RestoreDBClusterFromSnapshotRequest", arg0) 7029 ret0, _ := ret[0].(*request.Request) 7030 ret1, _ := ret[1].(*rds.RestoreDBClusterFromSnapshotOutput) 7031 return ret0, ret1 7032 } 7033 7034 // RestoreDBClusterFromSnapshotRequest indicates an expected call of RestoreDBClusterFromSnapshotRequest 7035 func (mr *MockRDSAPIMockRecorder) RestoreDBClusterFromSnapshotRequest(arg0 interface{}) *gomock.Call { 7036 mr.mock.ctrl.T.Helper() 7037 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RestoreDBClusterFromSnapshotRequest", reflect.TypeOf((*MockRDSAPI)(nil).RestoreDBClusterFromSnapshotRequest), arg0) 7038 } 7039 7040 // RestoreDBClusterFromSnapshotWithContext mocks base method 7041 func (m *MockRDSAPI) RestoreDBClusterFromSnapshotWithContext(arg0 context.Context, arg1 *rds.RestoreDBClusterFromSnapshotInput, arg2 ...request.Option) (*rds.RestoreDBClusterFromSnapshotOutput, error) { 7042 m.ctrl.T.Helper() 7043 varargs := []interface{}{arg0, arg1} 7044 for _, a := range arg2 { 7045 varargs = append(varargs, a) 7046 } 7047 ret := m.ctrl.Call(m, "RestoreDBClusterFromSnapshotWithContext", varargs...) 7048 ret0, _ := ret[0].(*rds.RestoreDBClusterFromSnapshotOutput) 7049 ret1, _ := ret[1].(error) 7050 return ret0, ret1 7051 } 7052 7053 // RestoreDBClusterFromSnapshotWithContext indicates an expected call of RestoreDBClusterFromSnapshotWithContext 7054 func (mr *MockRDSAPIMockRecorder) RestoreDBClusterFromSnapshotWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 7055 mr.mock.ctrl.T.Helper() 7056 varargs := append([]interface{}{arg0, arg1}, arg2...) 7057 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RestoreDBClusterFromSnapshotWithContext", reflect.TypeOf((*MockRDSAPI)(nil).RestoreDBClusterFromSnapshotWithContext), varargs...) 7058 } 7059 7060 // RestoreDBClusterToPointInTime mocks base method 7061 func (m *MockRDSAPI) RestoreDBClusterToPointInTime(arg0 *rds.RestoreDBClusterToPointInTimeInput) (*rds.RestoreDBClusterToPointInTimeOutput, error) { 7062 m.ctrl.T.Helper() 7063 ret := m.ctrl.Call(m, "RestoreDBClusterToPointInTime", arg0) 7064 ret0, _ := ret[0].(*rds.RestoreDBClusterToPointInTimeOutput) 7065 ret1, _ := ret[1].(error) 7066 return ret0, ret1 7067 } 7068 7069 // RestoreDBClusterToPointInTime indicates an expected call of RestoreDBClusterToPointInTime 7070 func (mr *MockRDSAPIMockRecorder) RestoreDBClusterToPointInTime(arg0 interface{}) *gomock.Call { 7071 mr.mock.ctrl.T.Helper() 7072 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RestoreDBClusterToPointInTime", reflect.TypeOf((*MockRDSAPI)(nil).RestoreDBClusterToPointInTime), arg0) 7073 } 7074 7075 // RestoreDBClusterToPointInTimeRequest mocks base method 7076 func (m *MockRDSAPI) RestoreDBClusterToPointInTimeRequest(arg0 *rds.RestoreDBClusterToPointInTimeInput) (*request.Request, *rds.RestoreDBClusterToPointInTimeOutput) { 7077 m.ctrl.T.Helper() 7078 ret := m.ctrl.Call(m, "RestoreDBClusterToPointInTimeRequest", arg0) 7079 ret0, _ := ret[0].(*request.Request) 7080 ret1, _ := ret[1].(*rds.RestoreDBClusterToPointInTimeOutput) 7081 return ret0, ret1 7082 } 7083 7084 // RestoreDBClusterToPointInTimeRequest indicates an expected call of RestoreDBClusterToPointInTimeRequest 7085 func (mr *MockRDSAPIMockRecorder) RestoreDBClusterToPointInTimeRequest(arg0 interface{}) *gomock.Call { 7086 mr.mock.ctrl.T.Helper() 7087 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RestoreDBClusterToPointInTimeRequest", reflect.TypeOf((*MockRDSAPI)(nil).RestoreDBClusterToPointInTimeRequest), arg0) 7088 } 7089 7090 // RestoreDBClusterToPointInTimeWithContext mocks base method 7091 func (m *MockRDSAPI) RestoreDBClusterToPointInTimeWithContext(arg0 context.Context, arg1 *rds.RestoreDBClusterToPointInTimeInput, arg2 ...request.Option) (*rds.RestoreDBClusterToPointInTimeOutput, error) { 7092 m.ctrl.T.Helper() 7093 varargs := []interface{}{arg0, arg1} 7094 for _, a := range arg2 { 7095 varargs = append(varargs, a) 7096 } 7097 ret := m.ctrl.Call(m, "RestoreDBClusterToPointInTimeWithContext", varargs...) 7098 ret0, _ := ret[0].(*rds.RestoreDBClusterToPointInTimeOutput) 7099 ret1, _ := ret[1].(error) 7100 return ret0, ret1 7101 } 7102 7103 // RestoreDBClusterToPointInTimeWithContext indicates an expected call of RestoreDBClusterToPointInTimeWithContext 7104 func (mr *MockRDSAPIMockRecorder) RestoreDBClusterToPointInTimeWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 7105 mr.mock.ctrl.T.Helper() 7106 varargs := append([]interface{}{arg0, arg1}, arg2...) 7107 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RestoreDBClusterToPointInTimeWithContext", reflect.TypeOf((*MockRDSAPI)(nil).RestoreDBClusterToPointInTimeWithContext), varargs...) 7108 } 7109 7110 // RestoreDBInstanceFromDBSnapshot mocks base method 7111 func (m *MockRDSAPI) RestoreDBInstanceFromDBSnapshot(arg0 *rds.RestoreDBInstanceFromDBSnapshotInput) (*rds.RestoreDBInstanceFromDBSnapshotOutput, error) { 7112 m.ctrl.T.Helper() 7113 ret := m.ctrl.Call(m, "RestoreDBInstanceFromDBSnapshot", arg0) 7114 ret0, _ := ret[0].(*rds.RestoreDBInstanceFromDBSnapshotOutput) 7115 ret1, _ := ret[1].(error) 7116 return ret0, ret1 7117 } 7118 7119 // RestoreDBInstanceFromDBSnapshot indicates an expected call of RestoreDBInstanceFromDBSnapshot 7120 func (mr *MockRDSAPIMockRecorder) RestoreDBInstanceFromDBSnapshot(arg0 interface{}) *gomock.Call { 7121 mr.mock.ctrl.T.Helper() 7122 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RestoreDBInstanceFromDBSnapshot", reflect.TypeOf((*MockRDSAPI)(nil).RestoreDBInstanceFromDBSnapshot), arg0) 7123 } 7124 7125 // RestoreDBInstanceFromDBSnapshotRequest mocks base method 7126 func (m *MockRDSAPI) RestoreDBInstanceFromDBSnapshotRequest(arg0 *rds.RestoreDBInstanceFromDBSnapshotInput) (*request.Request, *rds.RestoreDBInstanceFromDBSnapshotOutput) { 7127 m.ctrl.T.Helper() 7128 ret := m.ctrl.Call(m, "RestoreDBInstanceFromDBSnapshotRequest", arg0) 7129 ret0, _ := ret[0].(*request.Request) 7130 ret1, _ := ret[1].(*rds.RestoreDBInstanceFromDBSnapshotOutput) 7131 return ret0, ret1 7132 } 7133 7134 // RestoreDBInstanceFromDBSnapshotRequest indicates an expected call of RestoreDBInstanceFromDBSnapshotRequest 7135 func (mr *MockRDSAPIMockRecorder) RestoreDBInstanceFromDBSnapshotRequest(arg0 interface{}) *gomock.Call { 7136 mr.mock.ctrl.T.Helper() 7137 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RestoreDBInstanceFromDBSnapshotRequest", reflect.TypeOf((*MockRDSAPI)(nil).RestoreDBInstanceFromDBSnapshotRequest), arg0) 7138 } 7139 7140 // RestoreDBInstanceFromDBSnapshotWithContext mocks base method 7141 func (m *MockRDSAPI) RestoreDBInstanceFromDBSnapshotWithContext(arg0 context.Context, arg1 *rds.RestoreDBInstanceFromDBSnapshotInput, arg2 ...request.Option) (*rds.RestoreDBInstanceFromDBSnapshotOutput, error) { 7142 m.ctrl.T.Helper() 7143 varargs := []interface{}{arg0, arg1} 7144 for _, a := range arg2 { 7145 varargs = append(varargs, a) 7146 } 7147 ret := m.ctrl.Call(m, "RestoreDBInstanceFromDBSnapshotWithContext", varargs...) 7148 ret0, _ := ret[0].(*rds.RestoreDBInstanceFromDBSnapshotOutput) 7149 ret1, _ := ret[1].(error) 7150 return ret0, ret1 7151 } 7152 7153 // RestoreDBInstanceFromDBSnapshotWithContext indicates an expected call of RestoreDBInstanceFromDBSnapshotWithContext 7154 func (mr *MockRDSAPIMockRecorder) RestoreDBInstanceFromDBSnapshotWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 7155 mr.mock.ctrl.T.Helper() 7156 varargs := append([]interface{}{arg0, arg1}, arg2...) 7157 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RestoreDBInstanceFromDBSnapshotWithContext", reflect.TypeOf((*MockRDSAPI)(nil).RestoreDBInstanceFromDBSnapshotWithContext), varargs...) 7158 } 7159 7160 // RestoreDBInstanceFromS3 mocks base method 7161 func (m *MockRDSAPI) RestoreDBInstanceFromS3(arg0 *rds.RestoreDBInstanceFromS3Input) (*rds.RestoreDBInstanceFromS3Output, error) { 7162 m.ctrl.T.Helper() 7163 ret := m.ctrl.Call(m, "RestoreDBInstanceFromS3", arg0) 7164 ret0, _ := ret[0].(*rds.RestoreDBInstanceFromS3Output) 7165 ret1, _ := ret[1].(error) 7166 return ret0, ret1 7167 } 7168 7169 // RestoreDBInstanceFromS3 indicates an expected call of RestoreDBInstanceFromS3 7170 func (mr *MockRDSAPIMockRecorder) RestoreDBInstanceFromS3(arg0 interface{}) *gomock.Call { 7171 mr.mock.ctrl.T.Helper() 7172 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RestoreDBInstanceFromS3", reflect.TypeOf((*MockRDSAPI)(nil).RestoreDBInstanceFromS3), arg0) 7173 } 7174 7175 // RestoreDBInstanceFromS3Request mocks base method 7176 func (m *MockRDSAPI) RestoreDBInstanceFromS3Request(arg0 *rds.RestoreDBInstanceFromS3Input) (*request.Request, *rds.RestoreDBInstanceFromS3Output) { 7177 m.ctrl.T.Helper() 7178 ret := m.ctrl.Call(m, "RestoreDBInstanceFromS3Request", arg0) 7179 ret0, _ := ret[0].(*request.Request) 7180 ret1, _ := ret[1].(*rds.RestoreDBInstanceFromS3Output) 7181 return ret0, ret1 7182 } 7183 7184 // RestoreDBInstanceFromS3Request indicates an expected call of RestoreDBInstanceFromS3Request 7185 func (mr *MockRDSAPIMockRecorder) RestoreDBInstanceFromS3Request(arg0 interface{}) *gomock.Call { 7186 mr.mock.ctrl.T.Helper() 7187 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RestoreDBInstanceFromS3Request", reflect.TypeOf((*MockRDSAPI)(nil).RestoreDBInstanceFromS3Request), arg0) 7188 } 7189 7190 // RestoreDBInstanceFromS3WithContext mocks base method 7191 func (m *MockRDSAPI) RestoreDBInstanceFromS3WithContext(arg0 context.Context, arg1 *rds.RestoreDBInstanceFromS3Input, arg2 ...request.Option) (*rds.RestoreDBInstanceFromS3Output, error) { 7192 m.ctrl.T.Helper() 7193 varargs := []interface{}{arg0, arg1} 7194 for _, a := range arg2 { 7195 varargs = append(varargs, a) 7196 } 7197 ret := m.ctrl.Call(m, "RestoreDBInstanceFromS3WithContext", varargs...) 7198 ret0, _ := ret[0].(*rds.RestoreDBInstanceFromS3Output) 7199 ret1, _ := ret[1].(error) 7200 return ret0, ret1 7201 } 7202 7203 // RestoreDBInstanceFromS3WithContext indicates an expected call of RestoreDBInstanceFromS3WithContext 7204 func (mr *MockRDSAPIMockRecorder) RestoreDBInstanceFromS3WithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 7205 mr.mock.ctrl.T.Helper() 7206 varargs := append([]interface{}{arg0, arg1}, arg2...) 7207 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RestoreDBInstanceFromS3WithContext", reflect.TypeOf((*MockRDSAPI)(nil).RestoreDBInstanceFromS3WithContext), varargs...) 7208 } 7209 7210 // RestoreDBInstanceToPointInTime mocks base method 7211 func (m *MockRDSAPI) RestoreDBInstanceToPointInTime(arg0 *rds.RestoreDBInstanceToPointInTimeInput) (*rds.RestoreDBInstanceToPointInTimeOutput, error) { 7212 m.ctrl.T.Helper() 7213 ret := m.ctrl.Call(m, "RestoreDBInstanceToPointInTime", arg0) 7214 ret0, _ := ret[0].(*rds.RestoreDBInstanceToPointInTimeOutput) 7215 ret1, _ := ret[1].(error) 7216 return ret0, ret1 7217 } 7218 7219 // RestoreDBInstanceToPointInTime indicates an expected call of RestoreDBInstanceToPointInTime 7220 func (mr *MockRDSAPIMockRecorder) RestoreDBInstanceToPointInTime(arg0 interface{}) *gomock.Call { 7221 mr.mock.ctrl.T.Helper() 7222 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RestoreDBInstanceToPointInTime", reflect.TypeOf((*MockRDSAPI)(nil).RestoreDBInstanceToPointInTime), arg0) 7223 } 7224 7225 // RestoreDBInstanceToPointInTimeRequest mocks base method 7226 func (m *MockRDSAPI) RestoreDBInstanceToPointInTimeRequest(arg0 *rds.RestoreDBInstanceToPointInTimeInput) (*request.Request, *rds.RestoreDBInstanceToPointInTimeOutput) { 7227 m.ctrl.T.Helper() 7228 ret := m.ctrl.Call(m, "RestoreDBInstanceToPointInTimeRequest", arg0) 7229 ret0, _ := ret[0].(*request.Request) 7230 ret1, _ := ret[1].(*rds.RestoreDBInstanceToPointInTimeOutput) 7231 return ret0, ret1 7232 } 7233 7234 // RestoreDBInstanceToPointInTimeRequest indicates an expected call of RestoreDBInstanceToPointInTimeRequest 7235 func (mr *MockRDSAPIMockRecorder) RestoreDBInstanceToPointInTimeRequest(arg0 interface{}) *gomock.Call { 7236 mr.mock.ctrl.T.Helper() 7237 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RestoreDBInstanceToPointInTimeRequest", reflect.TypeOf((*MockRDSAPI)(nil).RestoreDBInstanceToPointInTimeRequest), arg0) 7238 } 7239 7240 // RestoreDBInstanceToPointInTimeWithContext mocks base method 7241 func (m *MockRDSAPI) RestoreDBInstanceToPointInTimeWithContext(arg0 context.Context, arg1 *rds.RestoreDBInstanceToPointInTimeInput, arg2 ...request.Option) (*rds.RestoreDBInstanceToPointInTimeOutput, error) { 7242 m.ctrl.T.Helper() 7243 varargs := []interface{}{arg0, arg1} 7244 for _, a := range arg2 { 7245 varargs = append(varargs, a) 7246 } 7247 ret := m.ctrl.Call(m, "RestoreDBInstanceToPointInTimeWithContext", varargs...) 7248 ret0, _ := ret[0].(*rds.RestoreDBInstanceToPointInTimeOutput) 7249 ret1, _ := ret[1].(error) 7250 return ret0, ret1 7251 } 7252 7253 // RestoreDBInstanceToPointInTimeWithContext indicates an expected call of RestoreDBInstanceToPointInTimeWithContext 7254 func (mr *MockRDSAPIMockRecorder) RestoreDBInstanceToPointInTimeWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 7255 mr.mock.ctrl.T.Helper() 7256 varargs := append([]interface{}{arg0, arg1}, arg2...) 7257 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RestoreDBInstanceToPointInTimeWithContext", reflect.TypeOf((*MockRDSAPI)(nil).RestoreDBInstanceToPointInTimeWithContext), varargs...) 7258 } 7259 7260 // RevokeDBSecurityGroupIngress mocks base method 7261 func (m *MockRDSAPI) RevokeDBSecurityGroupIngress(arg0 *rds.RevokeDBSecurityGroupIngressInput) (*rds.RevokeDBSecurityGroupIngressOutput, error) { 7262 m.ctrl.T.Helper() 7263 ret := m.ctrl.Call(m, "RevokeDBSecurityGroupIngress", arg0) 7264 ret0, _ := ret[0].(*rds.RevokeDBSecurityGroupIngressOutput) 7265 ret1, _ := ret[1].(error) 7266 return ret0, ret1 7267 } 7268 7269 // RevokeDBSecurityGroupIngress indicates an expected call of RevokeDBSecurityGroupIngress 7270 func (mr *MockRDSAPIMockRecorder) RevokeDBSecurityGroupIngress(arg0 interface{}) *gomock.Call { 7271 mr.mock.ctrl.T.Helper() 7272 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RevokeDBSecurityGroupIngress", reflect.TypeOf((*MockRDSAPI)(nil).RevokeDBSecurityGroupIngress), arg0) 7273 } 7274 7275 // RevokeDBSecurityGroupIngressRequest mocks base method 7276 func (m *MockRDSAPI) RevokeDBSecurityGroupIngressRequest(arg0 *rds.RevokeDBSecurityGroupIngressInput) (*request.Request, *rds.RevokeDBSecurityGroupIngressOutput) { 7277 m.ctrl.T.Helper() 7278 ret := m.ctrl.Call(m, "RevokeDBSecurityGroupIngressRequest", arg0) 7279 ret0, _ := ret[0].(*request.Request) 7280 ret1, _ := ret[1].(*rds.RevokeDBSecurityGroupIngressOutput) 7281 return ret0, ret1 7282 } 7283 7284 // RevokeDBSecurityGroupIngressRequest indicates an expected call of RevokeDBSecurityGroupIngressRequest 7285 func (mr *MockRDSAPIMockRecorder) RevokeDBSecurityGroupIngressRequest(arg0 interface{}) *gomock.Call { 7286 mr.mock.ctrl.T.Helper() 7287 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RevokeDBSecurityGroupIngressRequest", reflect.TypeOf((*MockRDSAPI)(nil).RevokeDBSecurityGroupIngressRequest), arg0) 7288 } 7289 7290 // RevokeDBSecurityGroupIngressWithContext mocks base method 7291 func (m *MockRDSAPI) RevokeDBSecurityGroupIngressWithContext(arg0 context.Context, arg1 *rds.RevokeDBSecurityGroupIngressInput, arg2 ...request.Option) (*rds.RevokeDBSecurityGroupIngressOutput, error) { 7292 m.ctrl.T.Helper() 7293 varargs := []interface{}{arg0, arg1} 7294 for _, a := range arg2 { 7295 varargs = append(varargs, a) 7296 } 7297 ret := m.ctrl.Call(m, "RevokeDBSecurityGroupIngressWithContext", varargs...) 7298 ret0, _ := ret[0].(*rds.RevokeDBSecurityGroupIngressOutput) 7299 ret1, _ := ret[1].(error) 7300 return ret0, ret1 7301 } 7302 7303 // RevokeDBSecurityGroupIngressWithContext indicates an expected call of RevokeDBSecurityGroupIngressWithContext 7304 func (mr *MockRDSAPIMockRecorder) RevokeDBSecurityGroupIngressWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 7305 mr.mock.ctrl.T.Helper() 7306 varargs := append([]interface{}{arg0, arg1}, arg2...) 7307 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RevokeDBSecurityGroupIngressWithContext", reflect.TypeOf((*MockRDSAPI)(nil).RevokeDBSecurityGroupIngressWithContext), varargs...) 7308 } 7309 7310 // StartActivityStream mocks base method 7311 func (m *MockRDSAPI) StartActivityStream(arg0 *rds.StartActivityStreamInput) (*rds.StartActivityStreamOutput, error) { 7312 m.ctrl.T.Helper() 7313 ret := m.ctrl.Call(m, "StartActivityStream", arg0) 7314 ret0, _ := ret[0].(*rds.StartActivityStreamOutput) 7315 ret1, _ := ret[1].(error) 7316 return ret0, ret1 7317 } 7318 7319 // StartActivityStream indicates an expected call of StartActivityStream 7320 func (mr *MockRDSAPIMockRecorder) StartActivityStream(arg0 interface{}) *gomock.Call { 7321 mr.mock.ctrl.T.Helper() 7322 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartActivityStream", reflect.TypeOf((*MockRDSAPI)(nil).StartActivityStream), arg0) 7323 } 7324 7325 // StartActivityStreamRequest mocks base method 7326 func (m *MockRDSAPI) StartActivityStreamRequest(arg0 *rds.StartActivityStreamInput) (*request.Request, *rds.StartActivityStreamOutput) { 7327 m.ctrl.T.Helper() 7328 ret := m.ctrl.Call(m, "StartActivityStreamRequest", arg0) 7329 ret0, _ := ret[0].(*request.Request) 7330 ret1, _ := ret[1].(*rds.StartActivityStreamOutput) 7331 return ret0, ret1 7332 } 7333 7334 // StartActivityStreamRequest indicates an expected call of StartActivityStreamRequest 7335 func (mr *MockRDSAPIMockRecorder) StartActivityStreamRequest(arg0 interface{}) *gomock.Call { 7336 mr.mock.ctrl.T.Helper() 7337 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartActivityStreamRequest", reflect.TypeOf((*MockRDSAPI)(nil).StartActivityStreamRequest), arg0) 7338 } 7339 7340 // StartActivityStreamWithContext mocks base method 7341 func (m *MockRDSAPI) StartActivityStreamWithContext(arg0 context.Context, arg1 *rds.StartActivityStreamInput, arg2 ...request.Option) (*rds.StartActivityStreamOutput, error) { 7342 m.ctrl.T.Helper() 7343 varargs := []interface{}{arg0, arg1} 7344 for _, a := range arg2 { 7345 varargs = append(varargs, a) 7346 } 7347 ret := m.ctrl.Call(m, "StartActivityStreamWithContext", varargs...) 7348 ret0, _ := ret[0].(*rds.StartActivityStreamOutput) 7349 ret1, _ := ret[1].(error) 7350 return ret0, ret1 7351 } 7352 7353 // StartActivityStreamWithContext indicates an expected call of StartActivityStreamWithContext 7354 func (mr *MockRDSAPIMockRecorder) StartActivityStreamWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 7355 mr.mock.ctrl.T.Helper() 7356 varargs := append([]interface{}{arg0, arg1}, arg2...) 7357 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartActivityStreamWithContext", reflect.TypeOf((*MockRDSAPI)(nil).StartActivityStreamWithContext), varargs...) 7358 } 7359 7360 // StartDBCluster mocks base method 7361 func (m *MockRDSAPI) StartDBCluster(arg0 *rds.StartDBClusterInput) (*rds.StartDBClusterOutput, error) { 7362 m.ctrl.T.Helper() 7363 ret := m.ctrl.Call(m, "StartDBCluster", arg0) 7364 ret0, _ := ret[0].(*rds.StartDBClusterOutput) 7365 ret1, _ := ret[1].(error) 7366 return ret0, ret1 7367 } 7368 7369 // StartDBCluster indicates an expected call of StartDBCluster 7370 func (mr *MockRDSAPIMockRecorder) StartDBCluster(arg0 interface{}) *gomock.Call { 7371 mr.mock.ctrl.T.Helper() 7372 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartDBCluster", reflect.TypeOf((*MockRDSAPI)(nil).StartDBCluster), arg0) 7373 } 7374 7375 // StartDBClusterRequest mocks base method 7376 func (m *MockRDSAPI) StartDBClusterRequest(arg0 *rds.StartDBClusterInput) (*request.Request, *rds.StartDBClusterOutput) { 7377 m.ctrl.T.Helper() 7378 ret := m.ctrl.Call(m, "StartDBClusterRequest", arg0) 7379 ret0, _ := ret[0].(*request.Request) 7380 ret1, _ := ret[1].(*rds.StartDBClusterOutput) 7381 return ret0, ret1 7382 } 7383 7384 // StartDBClusterRequest indicates an expected call of StartDBClusterRequest 7385 func (mr *MockRDSAPIMockRecorder) StartDBClusterRequest(arg0 interface{}) *gomock.Call { 7386 mr.mock.ctrl.T.Helper() 7387 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartDBClusterRequest", reflect.TypeOf((*MockRDSAPI)(nil).StartDBClusterRequest), arg0) 7388 } 7389 7390 // StartDBClusterWithContext mocks base method 7391 func (m *MockRDSAPI) StartDBClusterWithContext(arg0 context.Context, arg1 *rds.StartDBClusterInput, arg2 ...request.Option) (*rds.StartDBClusterOutput, error) { 7392 m.ctrl.T.Helper() 7393 varargs := []interface{}{arg0, arg1} 7394 for _, a := range arg2 { 7395 varargs = append(varargs, a) 7396 } 7397 ret := m.ctrl.Call(m, "StartDBClusterWithContext", varargs...) 7398 ret0, _ := ret[0].(*rds.StartDBClusterOutput) 7399 ret1, _ := ret[1].(error) 7400 return ret0, ret1 7401 } 7402 7403 // StartDBClusterWithContext indicates an expected call of StartDBClusterWithContext 7404 func (mr *MockRDSAPIMockRecorder) StartDBClusterWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 7405 mr.mock.ctrl.T.Helper() 7406 varargs := append([]interface{}{arg0, arg1}, arg2...) 7407 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartDBClusterWithContext", reflect.TypeOf((*MockRDSAPI)(nil).StartDBClusterWithContext), varargs...) 7408 } 7409 7410 // StartDBInstance mocks base method 7411 func (m *MockRDSAPI) StartDBInstance(arg0 *rds.StartDBInstanceInput) (*rds.StartDBInstanceOutput, error) { 7412 m.ctrl.T.Helper() 7413 ret := m.ctrl.Call(m, "StartDBInstance", arg0) 7414 ret0, _ := ret[0].(*rds.StartDBInstanceOutput) 7415 ret1, _ := ret[1].(error) 7416 return ret0, ret1 7417 } 7418 7419 // StartDBInstance indicates an expected call of StartDBInstance 7420 func (mr *MockRDSAPIMockRecorder) StartDBInstance(arg0 interface{}) *gomock.Call { 7421 mr.mock.ctrl.T.Helper() 7422 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartDBInstance", reflect.TypeOf((*MockRDSAPI)(nil).StartDBInstance), arg0) 7423 } 7424 7425 // StartDBInstanceRequest mocks base method 7426 func (m *MockRDSAPI) StartDBInstanceRequest(arg0 *rds.StartDBInstanceInput) (*request.Request, *rds.StartDBInstanceOutput) { 7427 m.ctrl.T.Helper() 7428 ret := m.ctrl.Call(m, "StartDBInstanceRequest", arg0) 7429 ret0, _ := ret[0].(*request.Request) 7430 ret1, _ := ret[1].(*rds.StartDBInstanceOutput) 7431 return ret0, ret1 7432 } 7433 7434 // StartDBInstanceRequest indicates an expected call of StartDBInstanceRequest 7435 func (mr *MockRDSAPIMockRecorder) StartDBInstanceRequest(arg0 interface{}) *gomock.Call { 7436 mr.mock.ctrl.T.Helper() 7437 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartDBInstanceRequest", reflect.TypeOf((*MockRDSAPI)(nil).StartDBInstanceRequest), arg0) 7438 } 7439 7440 // StartDBInstanceWithContext mocks base method 7441 func (m *MockRDSAPI) StartDBInstanceWithContext(arg0 context.Context, arg1 *rds.StartDBInstanceInput, arg2 ...request.Option) (*rds.StartDBInstanceOutput, error) { 7442 m.ctrl.T.Helper() 7443 varargs := []interface{}{arg0, arg1} 7444 for _, a := range arg2 { 7445 varargs = append(varargs, a) 7446 } 7447 ret := m.ctrl.Call(m, "StartDBInstanceWithContext", varargs...) 7448 ret0, _ := ret[0].(*rds.StartDBInstanceOutput) 7449 ret1, _ := ret[1].(error) 7450 return ret0, ret1 7451 } 7452 7453 // StartDBInstanceWithContext indicates an expected call of StartDBInstanceWithContext 7454 func (mr *MockRDSAPIMockRecorder) StartDBInstanceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 7455 mr.mock.ctrl.T.Helper() 7456 varargs := append([]interface{}{arg0, arg1}, arg2...) 7457 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartDBInstanceWithContext", reflect.TypeOf((*MockRDSAPI)(nil).StartDBInstanceWithContext), varargs...) 7458 } 7459 7460 // StartExportTask mocks base method 7461 func (m *MockRDSAPI) StartExportTask(arg0 *rds.StartExportTaskInput) (*rds.StartExportTaskOutput, error) { 7462 m.ctrl.T.Helper() 7463 ret := m.ctrl.Call(m, "StartExportTask", arg0) 7464 ret0, _ := ret[0].(*rds.StartExportTaskOutput) 7465 ret1, _ := ret[1].(error) 7466 return ret0, ret1 7467 } 7468 7469 // StartExportTask indicates an expected call of StartExportTask 7470 func (mr *MockRDSAPIMockRecorder) StartExportTask(arg0 interface{}) *gomock.Call { 7471 mr.mock.ctrl.T.Helper() 7472 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartExportTask", reflect.TypeOf((*MockRDSAPI)(nil).StartExportTask), arg0) 7473 } 7474 7475 // StartExportTaskRequest mocks base method 7476 func (m *MockRDSAPI) StartExportTaskRequest(arg0 *rds.StartExportTaskInput) (*request.Request, *rds.StartExportTaskOutput) { 7477 m.ctrl.T.Helper() 7478 ret := m.ctrl.Call(m, "StartExportTaskRequest", arg0) 7479 ret0, _ := ret[0].(*request.Request) 7480 ret1, _ := ret[1].(*rds.StartExportTaskOutput) 7481 return ret0, ret1 7482 } 7483 7484 // StartExportTaskRequest indicates an expected call of StartExportTaskRequest 7485 func (mr *MockRDSAPIMockRecorder) StartExportTaskRequest(arg0 interface{}) *gomock.Call { 7486 mr.mock.ctrl.T.Helper() 7487 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartExportTaskRequest", reflect.TypeOf((*MockRDSAPI)(nil).StartExportTaskRequest), arg0) 7488 } 7489 7490 // StartExportTaskWithContext mocks base method 7491 func (m *MockRDSAPI) StartExportTaskWithContext(arg0 context.Context, arg1 *rds.StartExportTaskInput, arg2 ...request.Option) (*rds.StartExportTaskOutput, error) { 7492 m.ctrl.T.Helper() 7493 varargs := []interface{}{arg0, arg1} 7494 for _, a := range arg2 { 7495 varargs = append(varargs, a) 7496 } 7497 ret := m.ctrl.Call(m, "StartExportTaskWithContext", varargs...) 7498 ret0, _ := ret[0].(*rds.StartExportTaskOutput) 7499 ret1, _ := ret[1].(error) 7500 return ret0, ret1 7501 } 7502 7503 // StartExportTaskWithContext indicates an expected call of StartExportTaskWithContext 7504 func (mr *MockRDSAPIMockRecorder) StartExportTaskWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 7505 mr.mock.ctrl.T.Helper() 7506 varargs := append([]interface{}{arg0, arg1}, arg2...) 7507 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartExportTaskWithContext", reflect.TypeOf((*MockRDSAPI)(nil).StartExportTaskWithContext), varargs...) 7508 } 7509 7510 // StopActivityStream mocks base method 7511 func (m *MockRDSAPI) StopActivityStream(arg0 *rds.StopActivityStreamInput) (*rds.StopActivityStreamOutput, error) { 7512 m.ctrl.T.Helper() 7513 ret := m.ctrl.Call(m, "StopActivityStream", arg0) 7514 ret0, _ := ret[0].(*rds.StopActivityStreamOutput) 7515 ret1, _ := ret[1].(error) 7516 return ret0, ret1 7517 } 7518 7519 // StopActivityStream indicates an expected call of StopActivityStream 7520 func (mr *MockRDSAPIMockRecorder) StopActivityStream(arg0 interface{}) *gomock.Call { 7521 mr.mock.ctrl.T.Helper() 7522 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopActivityStream", reflect.TypeOf((*MockRDSAPI)(nil).StopActivityStream), arg0) 7523 } 7524 7525 // StopActivityStreamRequest mocks base method 7526 func (m *MockRDSAPI) StopActivityStreamRequest(arg0 *rds.StopActivityStreamInput) (*request.Request, *rds.StopActivityStreamOutput) { 7527 m.ctrl.T.Helper() 7528 ret := m.ctrl.Call(m, "StopActivityStreamRequest", arg0) 7529 ret0, _ := ret[0].(*request.Request) 7530 ret1, _ := ret[1].(*rds.StopActivityStreamOutput) 7531 return ret0, ret1 7532 } 7533 7534 // StopActivityStreamRequest indicates an expected call of StopActivityStreamRequest 7535 func (mr *MockRDSAPIMockRecorder) StopActivityStreamRequest(arg0 interface{}) *gomock.Call { 7536 mr.mock.ctrl.T.Helper() 7537 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopActivityStreamRequest", reflect.TypeOf((*MockRDSAPI)(nil).StopActivityStreamRequest), arg0) 7538 } 7539 7540 // StopActivityStreamWithContext mocks base method 7541 func (m *MockRDSAPI) StopActivityStreamWithContext(arg0 context.Context, arg1 *rds.StopActivityStreamInput, arg2 ...request.Option) (*rds.StopActivityStreamOutput, error) { 7542 m.ctrl.T.Helper() 7543 varargs := []interface{}{arg0, arg1} 7544 for _, a := range arg2 { 7545 varargs = append(varargs, a) 7546 } 7547 ret := m.ctrl.Call(m, "StopActivityStreamWithContext", varargs...) 7548 ret0, _ := ret[0].(*rds.StopActivityStreamOutput) 7549 ret1, _ := ret[1].(error) 7550 return ret0, ret1 7551 } 7552 7553 // StopActivityStreamWithContext indicates an expected call of StopActivityStreamWithContext 7554 func (mr *MockRDSAPIMockRecorder) StopActivityStreamWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 7555 mr.mock.ctrl.T.Helper() 7556 varargs := append([]interface{}{arg0, arg1}, arg2...) 7557 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopActivityStreamWithContext", reflect.TypeOf((*MockRDSAPI)(nil).StopActivityStreamWithContext), varargs...) 7558 } 7559 7560 // StopDBCluster mocks base method 7561 func (m *MockRDSAPI) StopDBCluster(arg0 *rds.StopDBClusterInput) (*rds.StopDBClusterOutput, error) { 7562 m.ctrl.T.Helper() 7563 ret := m.ctrl.Call(m, "StopDBCluster", arg0) 7564 ret0, _ := ret[0].(*rds.StopDBClusterOutput) 7565 ret1, _ := ret[1].(error) 7566 return ret0, ret1 7567 } 7568 7569 // StopDBCluster indicates an expected call of StopDBCluster 7570 func (mr *MockRDSAPIMockRecorder) StopDBCluster(arg0 interface{}) *gomock.Call { 7571 mr.mock.ctrl.T.Helper() 7572 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopDBCluster", reflect.TypeOf((*MockRDSAPI)(nil).StopDBCluster), arg0) 7573 } 7574 7575 // StopDBClusterRequest mocks base method 7576 func (m *MockRDSAPI) StopDBClusterRequest(arg0 *rds.StopDBClusterInput) (*request.Request, *rds.StopDBClusterOutput) { 7577 m.ctrl.T.Helper() 7578 ret := m.ctrl.Call(m, "StopDBClusterRequest", arg0) 7579 ret0, _ := ret[0].(*request.Request) 7580 ret1, _ := ret[1].(*rds.StopDBClusterOutput) 7581 return ret0, ret1 7582 } 7583 7584 // StopDBClusterRequest indicates an expected call of StopDBClusterRequest 7585 func (mr *MockRDSAPIMockRecorder) StopDBClusterRequest(arg0 interface{}) *gomock.Call { 7586 mr.mock.ctrl.T.Helper() 7587 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopDBClusterRequest", reflect.TypeOf((*MockRDSAPI)(nil).StopDBClusterRequest), arg0) 7588 } 7589 7590 // StopDBClusterWithContext mocks base method 7591 func (m *MockRDSAPI) StopDBClusterWithContext(arg0 context.Context, arg1 *rds.StopDBClusterInput, arg2 ...request.Option) (*rds.StopDBClusterOutput, error) { 7592 m.ctrl.T.Helper() 7593 varargs := []interface{}{arg0, arg1} 7594 for _, a := range arg2 { 7595 varargs = append(varargs, a) 7596 } 7597 ret := m.ctrl.Call(m, "StopDBClusterWithContext", varargs...) 7598 ret0, _ := ret[0].(*rds.StopDBClusterOutput) 7599 ret1, _ := ret[1].(error) 7600 return ret0, ret1 7601 } 7602 7603 // StopDBClusterWithContext indicates an expected call of StopDBClusterWithContext 7604 func (mr *MockRDSAPIMockRecorder) StopDBClusterWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 7605 mr.mock.ctrl.T.Helper() 7606 varargs := append([]interface{}{arg0, arg1}, arg2...) 7607 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopDBClusterWithContext", reflect.TypeOf((*MockRDSAPI)(nil).StopDBClusterWithContext), varargs...) 7608 } 7609 7610 // StopDBInstance mocks base method 7611 func (m *MockRDSAPI) StopDBInstance(arg0 *rds.StopDBInstanceInput) (*rds.StopDBInstanceOutput, error) { 7612 m.ctrl.T.Helper() 7613 ret := m.ctrl.Call(m, "StopDBInstance", arg0) 7614 ret0, _ := ret[0].(*rds.StopDBInstanceOutput) 7615 ret1, _ := ret[1].(error) 7616 return ret0, ret1 7617 } 7618 7619 // StopDBInstance indicates an expected call of StopDBInstance 7620 func (mr *MockRDSAPIMockRecorder) StopDBInstance(arg0 interface{}) *gomock.Call { 7621 mr.mock.ctrl.T.Helper() 7622 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopDBInstance", reflect.TypeOf((*MockRDSAPI)(nil).StopDBInstance), arg0) 7623 } 7624 7625 // StopDBInstanceRequest mocks base method 7626 func (m *MockRDSAPI) StopDBInstanceRequest(arg0 *rds.StopDBInstanceInput) (*request.Request, *rds.StopDBInstanceOutput) { 7627 m.ctrl.T.Helper() 7628 ret := m.ctrl.Call(m, "StopDBInstanceRequest", arg0) 7629 ret0, _ := ret[0].(*request.Request) 7630 ret1, _ := ret[1].(*rds.StopDBInstanceOutput) 7631 return ret0, ret1 7632 } 7633 7634 // StopDBInstanceRequest indicates an expected call of StopDBInstanceRequest 7635 func (mr *MockRDSAPIMockRecorder) StopDBInstanceRequest(arg0 interface{}) *gomock.Call { 7636 mr.mock.ctrl.T.Helper() 7637 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopDBInstanceRequest", reflect.TypeOf((*MockRDSAPI)(nil).StopDBInstanceRequest), arg0) 7638 } 7639 7640 // StopDBInstanceWithContext mocks base method 7641 func (m *MockRDSAPI) StopDBInstanceWithContext(arg0 context.Context, arg1 *rds.StopDBInstanceInput, arg2 ...request.Option) (*rds.StopDBInstanceOutput, error) { 7642 m.ctrl.T.Helper() 7643 varargs := []interface{}{arg0, arg1} 7644 for _, a := range arg2 { 7645 varargs = append(varargs, a) 7646 } 7647 ret := m.ctrl.Call(m, "StopDBInstanceWithContext", varargs...) 7648 ret0, _ := ret[0].(*rds.StopDBInstanceOutput) 7649 ret1, _ := ret[1].(error) 7650 return ret0, ret1 7651 } 7652 7653 // StopDBInstanceWithContext indicates an expected call of StopDBInstanceWithContext 7654 func (mr *MockRDSAPIMockRecorder) StopDBInstanceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 7655 mr.mock.ctrl.T.Helper() 7656 varargs := append([]interface{}{arg0, arg1}, arg2...) 7657 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopDBInstanceWithContext", reflect.TypeOf((*MockRDSAPI)(nil).StopDBInstanceWithContext), varargs...) 7658 } 7659 7660 // WaitUntilDBClusterSnapshotAvailable mocks base method 7661 func (m *MockRDSAPI) WaitUntilDBClusterSnapshotAvailable(arg0 *rds.DescribeDBClusterSnapshotsInput) error { 7662 m.ctrl.T.Helper() 7663 ret := m.ctrl.Call(m, "WaitUntilDBClusterSnapshotAvailable", arg0) 7664 ret0, _ := ret[0].(error) 7665 return ret0 7666 } 7667 7668 // WaitUntilDBClusterSnapshotAvailable indicates an expected call of WaitUntilDBClusterSnapshotAvailable 7669 func (mr *MockRDSAPIMockRecorder) WaitUntilDBClusterSnapshotAvailable(arg0 interface{}) *gomock.Call { 7670 mr.mock.ctrl.T.Helper() 7671 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilDBClusterSnapshotAvailable", reflect.TypeOf((*MockRDSAPI)(nil).WaitUntilDBClusterSnapshotAvailable), arg0) 7672 } 7673 7674 // WaitUntilDBClusterSnapshotAvailableWithContext mocks base method 7675 func (m *MockRDSAPI) WaitUntilDBClusterSnapshotAvailableWithContext(arg0 context.Context, arg1 *rds.DescribeDBClusterSnapshotsInput, arg2 ...request.WaiterOption) error { 7676 m.ctrl.T.Helper() 7677 varargs := []interface{}{arg0, arg1} 7678 for _, a := range arg2 { 7679 varargs = append(varargs, a) 7680 } 7681 ret := m.ctrl.Call(m, "WaitUntilDBClusterSnapshotAvailableWithContext", varargs...) 7682 ret0, _ := ret[0].(error) 7683 return ret0 7684 } 7685 7686 // WaitUntilDBClusterSnapshotAvailableWithContext indicates an expected call of WaitUntilDBClusterSnapshotAvailableWithContext 7687 func (mr *MockRDSAPIMockRecorder) WaitUntilDBClusterSnapshotAvailableWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 7688 mr.mock.ctrl.T.Helper() 7689 varargs := append([]interface{}{arg0, arg1}, arg2...) 7690 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilDBClusterSnapshotAvailableWithContext", reflect.TypeOf((*MockRDSAPI)(nil).WaitUntilDBClusterSnapshotAvailableWithContext), varargs...) 7691 } 7692 7693 // WaitUntilDBClusterSnapshotDeleted mocks base method 7694 func (m *MockRDSAPI) WaitUntilDBClusterSnapshotDeleted(arg0 *rds.DescribeDBClusterSnapshotsInput) error { 7695 m.ctrl.T.Helper() 7696 ret := m.ctrl.Call(m, "WaitUntilDBClusterSnapshotDeleted", arg0) 7697 ret0, _ := ret[0].(error) 7698 return ret0 7699 } 7700 7701 // WaitUntilDBClusterSnapshotDeleted indicates an expected call of WaitUntilDBClusterSnapshotDeleted 7702 func (mr *MockRDSAPIMockRecorder) WaitUntilDBClusterSnapshotDeleted(arg0 interface{}) *gomock.Call { 7703 mr.mock.ctrl.T.Helper() 7704 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilDBClusterSnapshotDeleted", reflect.TypeOf((*MockRDSAPI)(nil).WaitUntilDBClusterSnapshotDeleted), arg0) 7705 } 7706 7707 // WaitUntilDBClusterSnapshotDeletedWithContext mocks base method 7708 func (m *MockRDSAPI) WaitUntilDBClusterSnapshotDeletedWithContext(arg0 context.Context, arg1 *rds.DescribeDBClusterSnapshotsInput, arg2 ...request.WaiterOption) error { 7709 m.ctrl.T.Helper() 7710 varargs := []interface{}{arg0, arg1} 7711 for _, a := range arg2 { 7712 varargs = append(varargs, a) 7713 } 7714 ret := m.ctrl.Call(m, "WaitUntilDBClusterSnapshotDeletedWithContext", varargs...) 7715 ret0, _ := ret[0].(error) 7716 return ret0 7717 } 7718 7719 // WaitUntilDBClusterSnapshotDeletedWithContext indicates an expected call of WaitUntilDBClusterSnapshotDeletedWithContext 7720 func (mr *MockRDSAPIMockRecorder) WaitUntilDBClusterSnapshotDeletedWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 7721 mr.mock.ctrl.T.Helper() 7722 varargs := append([]interface{}{arg0, arg1}, arg2...) 7723 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilDBClusterSnapshotDeletedWithContext", reflect.TypeOf((*MockRDSAPI)(nil).WaitUntilDBClusterSnapshotDeletedWithContext), varargs...) 7724 } 7725 7726 // WaitUntilDBInstanceAvailable mocks base method 7727 func (m *MockRDSAPI) WaitUntilDBInstanceAvailable(arg0 *rds.DescribeDBInstancesInput) error { 7728 m.ctrl.T.Helper() 7729 ret := m.ctrl.Call(m, "WaitUntilDBInstanceAvailable", arg0) 7730 ret0, _ := ret[0].(error) 7731 return ret0 7732 } 7733 7734 // WaitUntilDBInstanceAvailable indicates an expected call of WaitUntilDBInstanceAvailable 7735 func (mr *MockRDSAPIMockRecorder) WaitUntilDBInstanceAvailable(arg0 interface{}) *gomock.Call { 7736 mr.mock.ctrl.T.Helper() 7737 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilDBInstanceAvailable", reflect.TypeOf((*MockRDSAPI)(nil).WaitUntilDBInstanceAvailable), arg0) 7738 } 7739 7740 // WaitUntilDBInstanceAvailableWithContext mocks base method 7741 func (m *MockRDSAPI) WaitUntilDBInstanceAvailableWithContext(arg0 context.Context, arg1 *rds.DescribeDBInstancesInput, arg2 ...request.WaiterOption) error { 7742 m.ctrl.T.Helper() 7743 varargs := []interface{}{arg0, arg1} 7744 for _, a := range arg2 { 7745 varargs = append(varargs, a) 7746 } 7747 ret := m.ctrl.Call(m, "WaitUntilDBInstanceAvailableWithContext", varargs...) 7748 ret0, _ := ret[0].(error) 7749 return ret0 7750 } 7751 7752 // WaitUntilDBInstanceAvailableWithContext indicates an expected call of WaitUntilDBInstanceAvailableWithContext 7753 func (mr *MockRDSAPIMockRecorder) WaitUntilDBInstanceAvailableWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 7754 mr.mock.ctrl.T.Helper() 7755 varargs := append([]interface{}{arg0, arg1}, arg2...) 7756 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilDBInstanceAvailableWithContext", reflect.TypeOf((*MockRDSAPI)(nil).WaitUntilDBInstanceAvailableWithContext), varargs...) 7757 } 7758 7759 // WaitUntilDBInstanceDeleted mocks base method 7760 func (m *MockRDSAPI) WaitUntilDBInstanceDeleted(arg0 *rds.DescribeDBInstancesInput) error { 7761 m.ctrl.T.Helper() 7762 ret := m.ctrl.Call(m, "WaitUntilDBInstanceDeleted", arg0) 7763 ret0, _ := ret[0].(error) 7764 return ret0 7765 } 7766 7767 // WaitUntilDBInstanceDeleted indicates an expected call of WaitUntilDBInstanceDeleted 7768 func (mr *MockRDSAPIMockRecorder) WaitUntilDBInstanceDeleted(arg0 interface{}) *gomock.Call { 7769 mr.mock.ctrl.T.Helper() 7770 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilDBInstanceDeleted", reflect.TypeOf((*MockRDSAPI)(nil).WaitUntilDBInstanceDeleted), arg0) 7771 } 7772 7773 // WaitUntilDBInstanceDeletedWithContext mocks base method 7774 func (m *MockRDSAPI) WaitUntilDBInstanceDeletedWithContext(arg0 context.Context, arg1 *rds.DescribeDBInstancesInput, arg2 ...request.WaiterOption) error { 7775 m.ctrl.T.Helper() 7776 varargs := []interface{}{arg0, arg1} 7777 for _, a := range arg2 { 7778 varargs = append(varargs, a) 7779 } 7780 ret := m.ctrl.Call(m, "WaitUntilDBInstanceDeletedWithContext", varargs...) 7781 ret0, _ := ret[0].(error) 7782 return ret0 7783 } 7784 7785 // WaitUntilDBInstanceDeletedWithContext indicates an expected call of WaitUntilDBInstanceDeletedWithContext 7786 func (mr *MockRDSAPIMockRecorder) WaitUntilDBInstanceDeletedWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 7787 mr.mock.ctrl.T.Helper() 7788 varargs := append([]interface{}{arg0, arg1}, arg2...) 7789 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilDBInstanceDeletedWithContext", reflect.TypeOf((*MockRDSAPI)(nil).WaitUntilDBInstanceDeletedWithContext), varargs...) 7790 } 7791 7792 // WaitUntilDBSnapshotAvailable mocks base method 7793 func (m *MockRDSAPI) WaitUntilDBSnapshotAvailable(arg0 *rds.DescribeDBSnapshotsInput) error { 7794 m.ctrl.T.Helper() 7795 ret := m.ctrl.Call(m, "WaitUntilDBSnapshotAvailable", arg0) 7796 ret0, _ := ret[0].(error) 7797 return ret0 7798 } 7799 7800 // WaitUntilDBSnapshotAvailable indicates an expected call of WaitUntilDBSnapshotAvailable 7801 func (mr *MockRDSAPIMockRecorder) WaitUntilDBSnapshotAvailable(arg0 interface{}) *gomock.Call { 7802 mr.mock.ctrl.T.Helper() 7803 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilDBSnapshotAvailable", reflect.TypeOf((*MockRDSAPI)(nil).WaitUntilDBSnapshotAvailable), arg0) 7804 } 7805 7806 // WaitUntilDBSnapshotAvailableWithContext mocks base method 7807 func (m *MockRDSAPI) WaitUntilDBSnapshotAvailableWithContext(arg0 context.Context, arg1 *rds.DescribeDBSnapshotsInput, arg2 ...request.WaiterOption) error { 7808 m.ctrl.T.Helper() 7809 varargs := []interface{}{arg0, arg1} 7810 for _, a := range arg2 { 7811 varargs = append(varargs, a) 7812 } 7813 ret := m.ctrl.Call(m, "WaitUntilDBSnapshotAvailableWithContext", varargs...) 7814 ret0, _ := ret[0].(error) 7815 return ret0 7816 } 7817 7818 // WaitUntilDBSnapshotAvailableWithContext indicates an expected call of WaitUntilDBSnapshotAvailableWithContext 7819 func (mr *MockRDSAPIMockRecorder) WaitUntilDBSnapshotAvailableWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 7820 mr.mock.ctrl.T.Helper() 7821 varargs := append([]interface{}{arg0, arg1}, arg2...) 7822 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilDBSnapshotAvailableWithContext", reflect.TypeOf((*MockRDSAPI)(nil).WaitUntilDBSnapshotAvailableWithContext), varargs...) 7823 } 7824 7825 // WaitUntilDBSnapshotDeleted mocks base method 7826 func (m *MockRDSAPI) WaitUntilDBSnapshotDeleted(arg0 *rds.DescribeDBSnapshotsInput) error { 7827 m.ctrl.T.Helper() 7828 ret := m.ctrl.Call(m, "WaitUntilDBSnapshotDeleted", arg0) 7829 ret0, _ := ret[0].(error) 7830 return ret0 7831 } 7832 7833 // WaitUntilDBSnapshotDeleted indicates an expected call of WaitUntilDBSnapshotDeleted 7834 func (mr *MockRDSAPIMockRecorder) WaitUntilDBSnapshotDeleted(arg0 interface{}) *gomock.Call { 7835 mr.mock.ctrl.T.Helper() 7836 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilDBSnapshotDeleted", reflect.TypeOf((*MockRDSAPI)(nil).WaitUntilDBSnapshotDeleted), arg0) 7837 } 7838 7839 // WaitUntilDBSnapshotDeletedWithContext mocks base method 7840 func (m *MockRDSAPI) WaitUntilDBSnapshotDeletedWithContext(arg0 context.Context, arg1 *rds.DescribeDBSnapshotsInput, arg2 ...request.WaiterOption) error { 7841 m.ctrl.T.Helper() 7842 varargs := []interface{}{arg0, arg1} 7843 for _, a := range arg2 { 7844 varargs = append(varargs, a) 7845 } 7846 ret := m.ctrl.Call(m, "WaitUntilDBSnapshotDeletedWithContext", varargs...) 7847 ret0, _ := ret[0].(error) 7848 return ret0 7849 } 7850 7851 // WaitUntilDBSnapshotDeletedWithContext indicates an expected call of WaitUntilDBSnapshotDeletedWithContext 7852 func (mr *MockRDSAPIMockRecorder) WaitUntilDBSnapshotDeletedWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 7853 mr.mock.ctrl.T.Helper() 7854 varargs := append([]interface{}{arg0, arg1}, arg2...) 7855 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilDBSnapshotDeletedWithContext", reflect.TypeOf((*MockRDSAPI)(nil).WaitUntilDBSnapshotDeletedWithContext), varargs...) 7856 }