// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: MIT-0

// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/aws/aws-sdk-go/service/cloudwatch/cloudwatchiface (interfaces: CloudWatchAPI)

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

import (
	context "context"
	request "github.com/aws/aws-sdk-go/aws/request"
	cloudwatch "github.com/aws/aws-sdk-go/service/cloudwatch"
	gomock "github.com/golang/mock/gomock"
	reflect "reflect"
)

// MockCloudWatchAPI is a mock of CloudWatchAPI interface
type MockCloudWatchAPI struct {
	ctrl     *gomock.Controller
	recorder *MockCloudWatchAPIMockRecorder
}

// MockCloudWatchAPIMockRecorder is the mock recorder for MockCloudWatchAPI
type MockCloudWatchAPIMockRecorder struct {
	mock *MockCloudWatchAPI
}

// NewMockCloudWatchAPI creates a new mock instance
func NewMockCloudWatchAPI(ctrl *gomock.Controller) *MockCloudWatchAPI {
	mock := &MockCloudWatchAPI{ctrl: ctrl}
	mock.recorder = &MockCloudWatchAPIMockRecorder{mock}
	return mock
}

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

// DeleteAlarms mocks base method
func (m *MockCloudWatchAPI) DeleteAlarms(arg0 *cloudwatch.DeleteAlarmsInput) (*cloudwatch.DeleteAlarmsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteAlarms", arg0)
	ret0, _ := ret[0].(*cloudwatch.DeleteAlarmsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteAlarmsRequest mocks base method
func (m *MockCloudWatchAPI) DeleteAlarmsRequest(arg0 *cloudwatch.DeleteAlarmsInput) (*request.Request, *cloudwatch.DeleteAlarmsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteAlarmsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*cloudwatch.DeleteAlarmsOutput)
	return ret0, ret1
}

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

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

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

// DeleteAnomalyDetector mocks base method
func (m *MockCloudWatchAPI) DeleteAnomalyDetector(arg0 *cloudwatch.DeleteAnomalyDetectorInput) (*cloudwatch.DeleteAnomalyDetectorOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteAnomalyDetector", arg0)
	ret0, _ := ret[0].(*cloudwatch.DeleteAnomalyDetectorOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteAnomalyDetectorRequest mocks base method
func (m *MockCloudWatchAPI) DeleteAnomalyDetectorRequest(arg0 *cloudwatch.DeleteAnomalyDetectorInput) (*request.Request, *cloudwatch.DeleteAnomalyDetectorOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteAnomalyDetectorRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*cloudwatch.DeleteAnomalyDetectorOutput)
	return ret0, ret1
}

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

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

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

// DeleteDashboards mocks base method
func (m *MockCloudWatchAPI) DeleteDashboards(arg0 *cloudwatch.DeleteDashboardsInput) (*cloudwatch.DeleteDashboardsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteDashboards", arg0)
	ret0, _ := ret[0].(*cloudwatch.DeleteDashboardsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteDashboardsRequest mocks base method
func (m *MockCloudWatchAPI) DeleteDashboardsRequest(arg0 *cloudwatch.DeleteDashboardsInput) (*request.Request, *cloudwatch.DeleteDashboardsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteDashboardsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*cloudwatch.DeleteDashboardsOutput)
	return ret0, ret1
}

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

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

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

// DeleteInsightRules mocks base method
func (m *MockCloudWatchAPI) DeleteInsightRules(arg0 *cloudwatch.DeleteInsightRulesInput) (*cloudwatch.DeleteInsightRulesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteInsightRules", arg0)
	ret0, _ := ret[0].(*cloudwatch.DeleteInsightRulesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteInsightRulesRequest mocks base method
func (m *MockCloudWatchAPI) DeleteInsightRulesRequest(arg0 *cloudwatch.DeleteInsightRulesInput) (*request.Request, *cloudwatch.DeleteInsightRulesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteInsightRulesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*cloudwatch.DeleteInsightRulesOutput)
	return ret0, ret1
}

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

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

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

// DescribeAlarmHistory mocks base method
func (m *MockCloudWatchAPI) DescribeAlarmHistory(arg0 *cloudwatch.DescribeAlarmHistoryInput) (*cloudwatch.DescribeAlarmHistoryOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeAlarmHistory", arg0)
	ret0, _ := ret[0].(*cloudwatch.DescribeAlarmHistoryOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeAlarmHistoryPages mocks base method
func (m *MockCloudWatchAPI) DescribeAlarmHistoryPages(arg0 *cloudwatch.DescribeAlarmHistoryInput, arg1 func(*cloudwatch.DescribeAlarmHistoryOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeAlarmHistoryPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

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

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

// DescribeAlarmHistoryRequest mocks base method
func (m *MockCloudWatchAPI) DescribeAlarmHistoryRequest(arg0 *cloudwatch.DescribeAlarmHistoryInput) (*request.Request, *cloudwatch.DescribeAlarmHistoryOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeAlarmHistoryRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*cloudwatch.DescribeAlarmHistoryOutput)
	return ret0, ret1
}

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

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

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

// DescribeAlarms mocks base method
func (m *MockCloudWatchAPI) DescribeAlarms(arg0 *cloudwatch.DescribeAlarmsInput) (*cloudwatch.DescribeAlarmsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeAlarms", arg0)
	ret0, _ := ret[0].(*cloudwatch.DescribeAlarmsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeAlarmsForMetric mocks base method
func (m *MockCloudWatchAPI) DescribeAlarmsForMetric(arg0 *cloudwatch.DescribeAlarmsForMetricInput) (*cloudwatch.DescribeAlarmsForMetricOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeAlarmsForMetric", arg0)
	ret0, _ := ret[0].(*cloudwatch.DescribeAlarmsForMetricOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeAlarmsForMetricRequest mocks base method
func (m *MockCloudWatchAPI) DescribeAlarmsForMetricRequest(arg0 *cloudwatch.DescribeAlarmsForMetricInput) (*request.Request, *cloudwatch.DescribeAlarmsForMetricOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeAlarmsForMetricRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*cloudwatch.DescribeAlarmsForMetricOutput)
	return ret0, ret1
}

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

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

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

// DescribeAlarmsPages mocks base method
func (m *MockCloudWatchAPI) DescribeAlarmsPages(arg0 *cloudwatch.DescribeAlarmsInput, arg1 func(*cloudwatch.DescribeAlarmsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeAlarmsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

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

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

// DescribeAlarmsRequest mocks base method
func (m *MockCloudWatchAPI) DescribeAlarmsRequest(arg0 *cloudwatch.DescribeAlarmsInput) (*request.Request, *cloudwatch.DescribeAlarmsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeAlarmsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*cloudwatch.DescribeAlarmsOutput)
	return ret0, ret1
}

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

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

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

// DescribeAnomalyDetectors mocks base method
func (m *MockCloudWatchAPI) DescribeAnomalyDetectors(arg0 *cloudwatch.DescribeAnomalyDetectorsInput) (*cloudwatch.DescribeAnomalyDetectorsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeAnomalyDetectors", arg0)
	ret0, _ := ret[0].(*cloudwatch.DescribeAnomalyDetectorsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeAnomalyDetectorsRequest mocks base method
func (m *MockCloudWatchAPI) DescribeAnomalyDetectorsRequest(arg0 *cloudwatch.DescribeAnomalyDetectorsInput) (*request.Request, *cloudwatch.DescribeAnomalyDetectorsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeAnomalyDetectorsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*cloudwatch.DescribeAnomalyDetectorsOutput)
	return ret0, ret1
}

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

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

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

// DescribeInsightRules mocks base method
func (m *MockCloudWatchAPI) DescribeInsightRules(arg0 *cloudwatch.DescribeInsightRulesInput) (*cloudwatch.DescribeInsightRulesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeInsightRules", arg0)
	ret0, _ := ret[0].(*cloudwatch.DescribeInsightRulesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeInsightRulesPages mocks base method
func (m *MockCloudWatchAPI) DescribeInsightRulesPages(arg0 *cloudwatch.DescribeInsightRulesInput, arg1 func(*cloudwatch.DescribeInsightRulesOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeInsightRulesPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

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

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

// DescribeInsightRulesRequest mocks base method
func (m *MockCloudWatchAPI) DescribeInsightRulesRequest(arg0 *cloudwatch.DescribeInsightRulesInput) (*request.Request, *cloudwatch.DescribeInsightRulesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeInsightRulesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*cloudwatch.DescribeInsightRulesOutput)
	return ret0, ret1
}

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

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

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

// DisableAlarmActions mocks base method
func (m *MockCloudWatchAPI) DisableAlarmActions(arg0 *cloudwatch.DisableAlarmActionsInput) (*cloudwatch.DisableAlarmActionsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DisableAlarmActions", arg0)
	ret0, _ := ret[0].(*cloudwatch.DisableAlarmActionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DisableAlarmActionsRequest mocks base method
func (m *MockCloudWatchAPI) DisableAlarmActionsRequest(arg0 *cloudwatch.DisableAlarmActionsInput) (*request.Request, *cloudwatch.DisableAlarmActionsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DisableAlarmActionsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*cloudwatch.DisableAlarmActionsOutput)
	return ret0, ret1
}

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

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

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

// DisableInsightRules mocks base method
func (m *MockCloudWatchAPI) DisableInsightRules(arg0 *cloudwatch.DisableInsightRulesInput) (*cloudwatch.DisableInsightRulesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DisableInsightRules", arg0)
	ret0, _ := ret[0].(*cloudwatch.DisableInsightRulesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DisableInsightRulesRequest mocks base method
func (m *MockCloudWatchAPI) DisableInsightRulesRequest(arg0 *cloudwatch.DisableInsightRulesInput) (*request.Request, *cloudwatch.DisableInsightRulesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DisableInsightRulesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*cloudwatch.DisableInsightRulesOutput)
	return ret0, ret1
}

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

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

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

// EnableAlarmActions mocks base method
func (m *MockCloudWatchAPI) EnableAlarmActions(arg0 *cloudwatch.EnableAlarmActionsInput) (*cloudwatch.EnableAlarmActionsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EnableAlarmActions", arg0)
	ret0, _ := ret[0].(*cloudwatch.EnableAlarmActionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// EnableAlarmActionsRequest mocks base method
func (m *MockCloudWatchAPI) EnableAlarmActionsRequest(arg0 *cloudwatch.EnableAlarmActionsInput) (*request.Request, *cloudwatch.EnableAlarmActionsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EnableAlarmActionsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*cloudwatch.EnableAlarmActionsOutput)
	return ret0, ret1
}

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

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

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

// EnableInsightRules mocks base method
func (m *MockCloudWatchAPI) EnableInsightRules(arg0 *cloudwatch.EnableInsightRulesInput) (*cloudwatch.EnableInsightRulesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EnableInsightRules", arg0)
	ret0, _ := ret[0].(*cloudwatch.EnableInsightRulesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// EnableInsightRulesRequest mocks base method
func (m *MockCloudWatchAPI) EnableInsightRulesRequest(arg0 *cloudwatch.EnableInsightRulesInput) (*request.Request, *cloudwatch.EnableInsightRulesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EnableInsightRulesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*cloudwatch.EnableInsightRulesOutput)
	return ret0, ret1
}

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

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

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

// GetDashboard mocks base method
func (m *MockCloudWatchAPI) GetDashboard(arg0 *cloudwatch.GetDashboardInput) (*cloudwatch.GetDashboardOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetDashboard", arg0)
	ret0, _ := ret[0].(*cloudwatch.GetDashboardOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetDashboardRequest mocks base method
func (m *MockCloudWatchAPI) GetDashboardRequest(arg0 *cloudwatch.GetDashboardInput) (*request.Request, *cloudwatch.GetDashboardOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetDashboardRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*cloudwatch.GetDashboardOutput)
	return ret0, ret1
}

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

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

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

// GetInsightRuleReport mocks base method
func (m *MockCloudWatchAPI) GetInsightRuleReport(arg0 *cloudwatch.GetInsightRuleReportInput) (*cloudwatch.GetInsightRuleReportOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetInsightRuleReport", arg0)
	ret0, _ := ret[0].(*cloudwatch.GetInsightRuleReportOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetInsightRuleReportRequest mocks base method
func (m *MockCloudWatchAPI) GetInsightRuleReportRequest(arg0 *cloudwatch.GetInsightRuleReportInput) (*request.Request, *cloudwatch.GetInsightRuleReportOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetInsightRuleReportRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*cloudwatch.GetInsightRuleReportOutput)
	return ret0, ret1
}

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

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

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

// GetMetricData mocks base method
func (m *MockCloudWatchAPI) GetMetricData(arg0 *cloudwatch.GetMetricDataInput) (*cloudwatch.GetMetricDataOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetMetricData", arg0)
	ret0, _ := ret[0].(*cloudwatch.GetMetricDataOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetMetricDataPages mocks base method
func (m *MockCloudWatchAPI) GetMetricDataPages(arg0 *cloudwatch.GetMetricDataInput, arg1 func(*cloudwatch.GetMetricDataOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetMetricDataPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

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

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

// GetMetricDataRequest mocks base method
func (m *MockCloudWatchAPI) GetMetricDataRequest(arg0 *cloudwatch.GetMetricDataInput) (*request.Request, *cloudwatch.GetMetricDataOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetMetricDataRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*cloudwatch.GetMetricDataOutput)
	return ret0, ret1
}

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

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

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

// GetMetricStatistics mocks base method
func (m *MockCloudWatchAPI) GetMetricStatistics(arg0 *cloudwatch.GetMetricStatisticsInput) (*cloudwatch.GetMetricStatisticsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetMetricStatistics", arg0)
	ret0, _ := ret[0].(*cloudwatch.GetMetricStatisticsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetMetricStatisticsRequest mocks base method
func (m *MockCloudWatchAPI) GetMetricStatisticsRequest(arg0 *cloudwatch.GetMetricStatisticsInput) (*request.Request, *cloudwatch.GetMetricStatisticsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetMetricStatisticsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*cloudwatch.GetMetricStatisticsOutput)
	return ret0, ret1
}

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

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

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

// GetMetricWidgetImage mocks base method
func (m *MockCloudWatchAPI) GetMetricWidgetImage(arg0 *cloudwatch.GetMetricWidgetImageInput) (*cloudwatch.GetMetricWidgetImageOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetMetricWidgetImage", arg0)
	ret0, _ := ret[0].(*cloudwatch.GetMetricWidgetImageOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetMetricWidgetImageRequest mocks base method
func (m *MockCloudWatchAPI) GetMetricWidgetImageRequest(arg0 *cloudwatch.GetMetricWidgetImageInput) (*request.Request, *cloudwatch.GetMetricWidgetImageOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetMetricWidgetImageRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*cloudwatch.GetMetricWidgetImageOutput)
	return ret0, ret1
}

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

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

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

// ListDashboards mocks base method
func (m *MockCloudWatchAPI) ListDashboards(arg0 *cloudwatch.ListDashboardsInput) (*cloudwatch.ListDashboardsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListDashboards", arg0)
	ret0, _ := ret[0].(*cloudwatch.ListDashboardsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListDashboardsPages mocks base method
func (m *MockCloudWatchAPI) ListDashboardsPages(arg0 *cloudwatch.ListDashboardsInput, arg1 func(*cloudwatch.ListDashboardsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListDashboardsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

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

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

// ListDashboardsRequest mocks base method
func (m *MockCloudWatchAPI) ListDashboardsRequest(arg0 *cloudwatch.ListDashboardsInput) (*request.Request, *cloudwatch.ListDashboardsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListDashboardsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*cloudwatch.ListDashboardsOutput)
	return ret0, ret1
}

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

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

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

// ListMetrics mocks base method
func (m *MockCloudWatchAPI) ListMetrics(arg0 *cloudwatch.ListMetricsInput) (*cloudwatch.ListMetricsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListMetrics", arg0)
	ret0, _ := ret[0].(*cloudwatch.ListMetricsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListMetricsPages mocks base method
func (m *MockCloudWatchAPI) ListMetricsPages(arg0 *cloudwatch.ListMetricsInput, arg1 func(*cloudwatch.ListMetricsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListMetricsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

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

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

// ListMetricsRequest mocks base method
func (m *MockCloudWatchAPI) ListMetricsRequest(arg0 *cloudwatch.ListMetricsInput) (*request.Request, *cloudwatch.ListMetricsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListMetricsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*cloudwatch.ListMetricsOutput)
	return ret0, ret1
}

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

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

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

// ListTagsForResource mocks base method
func (m *MockCloudWatchAPI) ListTagsForResource(arg0 *cloudwatch.ListTagsForResourceInput) (*cloudwatch.ListTagsForResourceOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListTagsForResource", arg0)
	ret0, _ := ret[0].(*cloudwatch.ListTagsForResourceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListTagsForResourceRequest mocks base method
func (m *MockCloudWatchAPI) ListTagsForResourceRequest(arg0 *cloudwatch.ListTagsForResourceInput) (*request.Request, *cloudwatch.ListTagsForResourceOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListTagsForResourceRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*cloudwatch.ListTagsForResourceOutput)
	return ret0, ret1
}

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

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

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

// PutAnomalyDetector mocks base method
func (m *MockCloudWatchAPI) PutAnomalyDetector(arg0 *cloudwatch.PutAnomalyDetectorInput) (*cloudwatch.PutAnomalyDetectorOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutAnomalyDetector", arg0)
	ret0, _ := ret[0].(*cloudwatch.PutAnomalyDetectorOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// PutAnomalyDetectorRequest mocks base method
func (m *MockCloudWatchAPI) PutAnomalyDetectorRequest(arg0 *cloudwatch.PutAnomalyDetectorInput) (*request.Request, *cloudwatch.PutAnomalyDetectorOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutAnomalyDetectorRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*cloudwatch.PutAnomalyDetectorOutput)
	return ret0, ret1
}

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

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

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

// PutCompositeAlarm mocks base method
func (m *MockCloudWatchAPI) PutCompositeAlarm(arg0 *cloudwatch.PutCompositeAlarmInput) (*cloudwatch.PutCompositeAlarmOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutCompositeAlarm", arg0)
	ret0, _ := ret[0].(*cloudwatch.PutCompositeAlarmOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// PutCompositeAlarmRequest mocks base method
func (m *MockCloudWatchAPI) PutCompositeAlarmRequest(arg0 *cloudwatch.PutCompositeAlarmInput) (*request.Request, *cloudwatch.PutCompositeAlarmOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutCompositeAlarmRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*cloudwatch.PutCompositeAlarmOutput)
	return ret0, ret1
}

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

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

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

// PutDashboard mocks base method
func (m *MockCloudWatchAPI) PutDashboard(arg0 *cloudwatch.PutDashboardInput) (*cloudwatch.PutDashboardOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutDashboard", arg0)
	ret0, _ := ret[0].(*cloudwatch.PutDashboardOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// PutDashboardRequest mocks base method
func (m *MockCloudWatchAPI) PutDashboardRequest(arg0 *cloudwatch.PutDashboardInput) (*request.Request, *cloudwatch.PutDashboardOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutDashboardRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*cloudwatch.PutDashboardOutput)
	return ret0, ret1
}

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

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

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

// PutInsightRule mocks base method
func (m *MockCloudWatchAPI) PutInsightRule(arg0 *cloudwatch.PutInsightRuleInput) (*cloudwatch.PutInsightRuleOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutInsightRule", arg0)
	ret0, _ := ret[0].(*cloudwatch.PutInsightRuleOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// PutInsightRuleRequest mocks base method
func (m *MockCloudWatchAPI) PutInsightRuleRequest(arg0 *cloudwatch.PutInsightRuleInput) (*request.Request, *cloudwatch.PutInsightRuleOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutInsightRuleRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*cloudwatch.PutInsightRuleOutput)
	return ret0, ret1
}

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

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

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

// PutMetricAlarm mocks base method
func (m *MockCloudWatchAPI) PutMetricAlarm(arg0 *cloudwatch.PutMetricAlarmInput) (*cloudwatch.PutMetricAlarmOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutMetricAlarm", arg0)
	ret0, _ := ret[0].(*cloudwatch.PutMetricAlarmOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// PutMetricAlarmRequest mocks base method
func (m *MockCloudWatchAPI) PutMetricAlarmRequest(arg0 *cloudwatch.PutMetricAlarmInput) (*request.Request, *cloudwatch.PutMetricAlarmOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutMetricAlarmRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*cloudwatch.PutMetricAlarmOutput)
	return ret0, ret1
}

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

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

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

// PutMetricData mocks base method
func (m *MockCloudWatchAPI) PutMetricData(arg0 *cloudwatch.PutMetricDataInput) (*cloudwatch.PutMetricDataOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutMetricData", arg0)
	ret0, _ := ret[0].(*cloudwatch.PutMetricDataOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// PutMetricDataRequest mocks base method
func (m *MockCloudWatchAPI) PutMetricDataRequest(arg0 *cloudwatch.PutMetricDataInput) (*request.Request, *cloudwatch.PutMetricDataOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutMetricDataRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*cloudwatch.PutMetricDataOutput)
	return ret0, ret1
}

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

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

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

// SetAlarmState mocks base method
func (m *MockCloudWatchAPI) SetAlarmState(arg0 *cloudwatch.SetAlarmStateInput) (*cloudwatch.SetAlarmStateOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetAlarmState", arg0)
	ret0, _ := ret[0].(*cloudwatch.SetAlarmStateOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SetAlarmStateRequest mocks base method
func (m *MockCloudWatchAPI) SetAlarmStateRequest(arg0 *cloudwatch.SetAlarmStateInput) (*request.Request, *cloudwatch.SetAlarmStateOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetAlarmStateRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*cloudwatch.SetAlarmStateOutput)
	return ret0, ret1
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// WaitUntilAlarmExists mocks base method
func (m *MockCloudWatchAPI) WaitUntilAlarmExists(arg0 *cloudwatch.DescribeAlarmsInput) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WaitUntilAlarmExists", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// WaitUntilAlarmExistsWithContext mocks base method
func (m *MockCloudWatchAPI) WaitUntilAlarmExistsWithContext(arg0 context.Context, arg1 *cloudwatch.DescribeAlarmsInput, arg2 ...request.WaiterOption) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "WaitUntilAlarmExistsWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// WaitUntilCompositeAlarmExists mocks base method
func (m *MockCloudWatchAPI) WaitUntilCompositeAlarmExists(arg0 *cloudwatch.DescribeAlarmsInput) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WaitUntilCompositeAlarmExists", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// WaitUntilCompositeAlarmExistsWithContext mocks base method
func (m *MockCloudWatchAPI) WaitUntilCompositeAlarmExistsWithContext(arg0 context.Context, arg1 *cloudwatch.DescribeAlarmsInput, arg2 ...request.WaiterOption) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "WaitUntilCompositeAlarmExistsWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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