// Code generated by MockGen. DO NOT EDIT.
// Source: /home/runner/go/pkg/mod/github.com/aws/aws-sdk-go@v1.55.5/service/budgets/budgetsiface/interface.go

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

import (
	reflect "reflect"

	aws "github.com/aws/aws-sdk-go/aws"
	request "github.com/aws/aws-sdk-go/aws/request"
	budgets "github.com/aws/aws-sdk-go/service/budgets"
	gomock "github.com/golang/mock/gomock"
)

// MockBudgetsAPI is a mock of BudgetsAPI interface.
type MockBudgetsAPI struct {
	ctrl     *gomock.Controller
	recorder *MockBudgetsAPIMockRecorder
}

// MockBudgetsAPIMockRecorder is the mock recorder for MockBudgetsAPI.
type MockBudgetsAPIMockRecorder struct {
	mock *MockBudgetsAPI
}

// NewMockBudgetsAPI creates a new mock instance.
func NewMockBudgetsAPI(ctrl *gomock.Controller) *MockBudgetsAPI {
	mock := &MockBudgetsAPI{ctrl: ctrl}
	mock.recorder = &MockBudgetsAPIMockRecorder{mock}
	return mock
}

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

// CreateBudget mocks base method.
func (m *MockBudgetsAPI) CreateBudget(arg0 *budgets.CreateBudgetInput) (*budgets.CreateBudgetOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateBudget", arg0)
	ret0, _ := ret[0].(*budgets.CreateBudgetOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateBudgetAction mocks base method.
func (m *MockBudgetsAPI) CreateBudgetAction(arg0 *budgets.CreateBudgetActionInput) (*budgets.CreateBudgetActionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateBudgetAction", arg0)
	ret0, _ := ret[0].(*budgets.CreateBudgetActionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateBudgetActionRequest mocks base method.
func (m *MockBudgetsAPI) CreateBudgetActionRequest(arg0 *budgets.CreateBudgetActionInput) (*request.Request, *budgets.CreateBudgetActionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateBudgetActionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*budgets.CreateBudgetActionOutput)
	return ret0, ret1
}

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

// CreateBudgetActionWithContext mocks base method.
func (m *MockBudgetsAPI) CreateBudgetActionWithContext(arg0 aws.Context, arg1 *budgets.CreateBudgetActionInput, arg2 ...request.Option) (*budgets.CreateBudgetActionOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateBudgetActionWithContext", varargs...)
	ret0, _ := ret[0].(*budgets.CreateBudgetActionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateBudgetActionWithContext indicates an expected call of CreateBudgetActionWithContext.
func (mr *MockBudgetsAPIMockRecorder) CreateBudgetActionWithContext(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, "CreateBudgetActionWithContext", reflect.TypeOf((*MockBudgetsAPI)(nil).CreateBudgetActionWithContext), varargs...)
}

// CreateBudgetRequest mocks base method.
func (m *MockBudgetsAPI) CreateBudgetRequest(arg0 *budgets.CreateBudgetInput) (*request.Request, *budgets.CreateBudgetOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateBudgetRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*budgets.CreateBudgetOutput)
	return ret0, ret1
}

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

// CreateBudgetWithContext mocks base method.
func (m *MockBudgetsAPI) CreateBudgetWithContext(arg0 aws.Context, arg1 *budgets.CreateBudgetInput, arg2 ...request.Option) (*budgets.CreateBudgetOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateBudgetWithContext", varargs...)
	ret0, _ := ret[0].(*budgets.CreateBudgetOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateBudgetWithContext indicates an expected call of CreateBudgetWithContext.
func (mr *MockBudgetsAPIMockRecorder) CreateBudgetWithContext(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, "CreateBudgetWithContext", reflect.TypeOf((*MockBudgetsAPI)(nil).CreateBudgetWithContext), varargs...)
}

// CreateNotification mocks base method.
func (m *MockBudgetsAPI) CreateNotification(arg0 *budgets.CreateNotificationInput) (*budgets.CreateNotificationOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateNotification", arg0)
	ret0, _ := ret[0].(*budgets.CreateNotificationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateNotificationRequest mocks base method.
func (m *MockBudgetsAPI) CreateNotificationRequest(arg0 *budgets.CreateNotificationInput) (*request.Request, *budgets.CreateNotificationOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateNotificationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*budgets.CreateNotificationOutput)
	return ret0, ret1
}

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

// CreateNotificationWithContext mocks base method.
func (m *MockBudgetsAPI) CreateNotificationWithContext(arg0 aws.Context, arg1 *budgets.CreateNotificationInput, arg2 ...request.Option) (*budgets.CreateNotificationOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateNotificationWithContext", varargs...)
	ret0, _ := ret[0].(*budgets.CreateNotificationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateNotificationWithContext indicates an expected call of CreateNotificationWithContext.
func (mr *MockBudgetsAPIMockRecorder) CreateNotificationWithContext(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, "CreateNotificationWithContext", reflect.TypeOf((*MockBudgetsAPI)(nil).CreateNotificationWithContext), varargs...)
}

// CreateSubscriber mocks base method.
func (m *MockBudgetsAPI) CreateSubscriber(arg0 *budgets.CreateSubscriberInput) (*budgets.CreateSubscriberOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateSubscriber", arg0)
	ret0, _ := ret[0].(*budgets.CreateSubscriberOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateSubscriberRequest mocks base method.
func (m *MockBudgetsAPI) CreateSubscriberRequest(arg0 *budgets.CreateSubscriberInput) (*request.Request, *budgets.CreateSubscriberOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateSubscriberRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*budgets.CreateSubscriberOutput)
	return ret0, ret1
}

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

// CreateSubscriberWithContext mocks base method.
func (m *MockBudgetsAPI) CreateSubscriberWithContext(arg0 aws.Context, arg1 *budgets.CreateSubscriberInput, arg2 ...request.Option) (*budgets.CreateSubscriberOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateSubscriberWithContext", varargs...)
	ret0, _ := ret[0].(*budgets.CreateSubscriberOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateSubscriberWithContext indicates an expected call of CreateSubscriberWithContext.
func (mr *MockBudgetsAPIMockRecorder) CreateSubscriberWithContext(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, "CreateSubscriberWithContext", reflect.TypeOf((*MockBudgetsAPI)(nil).CreateSubscriberWithContext), varargs...)
}

// DeleteBudget mocks base method.
func (m *MockBudgetsAPI) DeleteBudget(arg0 *budgets.DeleteBudgetInput) (*budgets.DeleteBudgetOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteBudget", arg0)
	ret0, _ := ret[0].(*budgets.DeleteBudgetOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteBudgetAction mocks base method.
func (m *MockBudgetsAPI) DeleteBudgetAction(arg0 *budgets.DeleteBudgetActionInput) (*budgets.DeleteBudgetActionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteBudgetAction", arg0)
	ret0, _ := ret[0].(*budgets.DeleteBudgetActionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteBudgetActionRequest mocks base method.
func (m *MockBudgetsAPI) DeleteBudgetActionRequest(arg0 *budgets.DeleteBudgetActionInput) (*request.Request, *budgets.DeleteBudgetActionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteBudgetActionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*budgets.DeleteBudgetActionOutput)
	return ret0, ret1
}

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

// DeleteBudgetActionWithContext mocks base method.
func (m *MockBudgetsAPI) DeleteBudgetActionWithContext(arg0 aws.Context, arg1 *budgets.DeleteBudgetActionInput, arg2 ...request.Option) (*budgets.DeleteBudgetActionOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteBudgetActionWithContext", varargs...)
	ret0, _ := ret[0].(*budgets.DeleteBudgetActionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteBudgetActionWithContext indicates an expected call of DeleteBudgetActionWithContext.
func (mr *MockBudgetsAPIMockRecorder) DeleteBudgetActionWithContext(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, "DeleteBudgetActionWithContext", reflect.TypeOf((*MockBudgetsAPI)(nil).DeleteBudgetActionWithContext), varargs...)
}

// DeleteBudgetRequest mocks base method.
func (m *MockBudgetsAPI) DeleteBudgetRequest(arg0 *budgets.DeleteBudgetInput) (*request.Request, *budgets.DeleteBudgetOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteBudgetRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*budgets.DeleteBudgetOutput)
	return ret0, ret1
}

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

// DeleteBudgetWithContext mocks base method.
func (m *MockBudgetsAPI) DeleteBudgetWithContext(arg0 aws.Context, arg1 *budgets.DeleteBudgetInput, arg2 ...request.Option) (*budgets.DeleteBudgetOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteBudgetWithContext", varargs...)
	ret0, _ := ret[0].(*budgets.DeleteBudgetOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteBudgetWithContext indicates an expected call of DeleteBudgetWithContext.
func (mr *MockBudgetsAPIMockRecorder) DeleteBudgetWithContext(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, "DeleteBudgetWithContext", reflect.TypeOf((*MockBudgetsAPI)(nil).DeleteBudgetWithContext), varargs...)
}

// DeleteNotification mocks base method.
func (m *MockBudgetsAPI) DeleteNotification(arg0 *budgets.DeleteNotificationInput) (*budgets.DeleteNotificationOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteNotification", arg0)
	ret0, _ := ret[0].(*budgets.DeleteNotificationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteNotificationRequest mocks base method.
func (m *MockBudgetsAPI) DeleteNotificationRequest(arg0 *budgets.DeleteNotificationInput) (*request.Request, *budgets.DeleteNotificationOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteNotificationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*budgets.DeleteNotificationOutput)
	return ret0, ret1
}

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

// DeleteNotificationWithContext mocks base method.
func (m *MockBudgetsAPI) DeleteNotificationWithContext(arg0 aws.Context, arg1 *budgets.DeleteNotificationInput, arg2 ...request.Option) (*budgets.DeleteNotificationOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteNotificationWithContext", varargs...)
	ret0, _ := ret[0].(*budgets.DeleteNotificationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteNotificationWithContext indicates an expected call of DeleteNotificationWithContext.
func (mr *MockBudgetsAPIMockRecorder) DeleteNotificationWithContext(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, "DeleteNotificationWithContext", reflect.TypeOf((*MockBudgetsAPI)(nil).DeleteNotificationWithContext), varargs...)
}

// DeleteSubscriber mocks base method.
func (m *MockBudgetsAPI) DeleteSubscriber(arg0 *budgets.DeleteSubscriberInput) (*budgets.DeleteSubscriberOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteSubscriber", arg0)
	ret0, _ := ret[0].(*budgets.DeleteSubscriberOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteSubscriberRequest mocks base method.
func (m *MockBudgetsAPI) DeleteSubscriberRequest(arg0 *budgets.DeleteSubscriberInput) (*request.Request, *budgets.DeleteSubscriberOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteSubscriberRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*budgets.DeleteSubscriberOutput)
	return ret0, ret1
}

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

// DeleteSubscriberWithContext mocks base method.
func (m *MockBudgetsAPI) DeleteSubscriberWithContext(arg0 aws.Context, arg1 *budgets.DeleteSubscriberInput, arg2 ...request.Option) (*budgets.DeleteSubscriberOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteSubscriberWithContext", varargs...)
	ret0, _ := ret[0].(*budgets.DeleteSubscriberOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteSubscriberWithContext indicates an expected call of DeleteSubscriberWithContext.
func (mr *MockBudgetsAPIMockRecorder) DeleteSubscriberWithContext(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, "DeleteSubscriberWithContext", reflect.TypeOf((*MockBudgetsAPI)(nil).DeleteSubscriberWithContext), varargs...)
}

// DescribeBudget mocks base method.
func (m *MockBudgetsAPI) DescribeBudget(arg0 *budgets.DescribeBudgetInput) (*budgets.DescribeBudgetOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeBudget", arg0)
	ret0, _ := ret[0].(*budgets.DescribeBudgetOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeBudgetAction mocks base method.
func (m *MockBudgetsAPI) DescribeBudgetAction(arg0 *budgets.DescribeBudgetActionInput) (*budgets.DescribeBudgetActionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeBudgetAction", arg0)
	ret0, _ := ret[0].(*budgets.DescribeBudgetActionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeBudgetActionHistories mocks base method.
func (m *MockBudgetsAPI) DescribeBudgetActionHistories(arg0 *budgets.DescribeBudgetActionHistoriesInput) (*budgets.DescribeBudgetActionHistoriesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeBudgetActionHistories", arg0)
	ret0, _ := ret[0].(*budgets.DescribeBudgetActionHistoriesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeBudgetActionHistoriesPages mocks base method.
func (m *MockBudgetsAPI) DescribeBudgetActionHistoriesPages(arg0 *budgets.DescribeBudgetActionHistoriesInput, arg1 func(*budgets.DescribeBudgetActionHistoriesOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeBudgetActionHistoriesPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeBudgetActionHistoriesPagesWithContext mocks base method.
func (m *MockBudgetsAPI) DescribeBudgetActionHistoriesPagesWithContext(arg0 aws.Context, arg1 *budgets.DescribeBudgetActionHistoriesInput, arg2 func(*budgets.DescribeBudgetActionHistoriesOutput, 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, "DescribeBudgetActionHistoriesPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeBudgetActionHistoriesPagesWithContext indicates an expected call of DescribeBudgetActionHistoriesPagesWithContext.
func (mr *MockBudgetsAPIMockRecorder) DescribeBudgetActionHistoriesPagesWithContext(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, "DescribeBudgetActionHistoriesPagesWithContext", reflect.TypeOf((*MockBudgetsAPI)(nil).DescribeBudgetActionHistoriesPagesWithContext), varargs...)
}

// DescribeBudgetActionHistoriesRequest mocks base method.
func (m *MockBudgetsAPI) DescribeBudgetActionHistoriesRequest(arg0 *budgets.DescribeBudgetActionHistoriesInput) (*request.Request, *budgets.DescribeBudgetActionHistoriesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeBudgetActionHistoriesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*budgets.DescribeBudgetActionHistoriesOutput)
	return ret0, ret1
}

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

// DescribeBudgetActionHistoriesWithContext mocks base method.
func (m *MockBudgetsAPI) DescribeBudgetActionHistoriesWithContext(arg0 aws.Context, arg1 *budgets.DescribeBudgetActionHistoriesInput, arg2 ...request.Option) (*budgets.DescribeBudgetActionHistoriesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeBudgetActionHistoriesWithContext", varargs...)
	ret0, _ := ret[0].(*budgets.DescribeBudgetActionHistoriesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeBudgetActionHistoriesWithContext indicates an expected call of DescribeBudgetActionHistoriesWithContext.
func (mr *MockBudgetsAPIMockRecorder) DescribeBudgetActionHistoriesWithContext(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, "DescribeBudgetActionHistoriesWithContext", reflect.TypeOf((*MockBudgetsAPI)(nil).DescribeBudgetActionHistoriesWithContext), varargs...)
}

// DescribeBudgetActionRequest mocks base method.
func (m *MockBudgetsAPI) DescribeBudgetActionRequest(arg0 *budgets.DescribeBudgetActionInput) (*request.Request, *budgets.DescribeBudgetActionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeBudgetActionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*budgets.DescribeBudgetActionOutput)
	return ret0, ret1
}

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

// DescribeBudgetActionWithContext mocks base method.
func (m *MockBudgetsAPI) DescribeBudgetActionWithContext(arg0 aws.Context, arg1 *budgets.DescribeBudgetActionInput, arg2 ...request.Option) (*budgets.DescribeBudgetActionOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeBudgetActionWithContext", varargs...)
	ret0, _ := ret[0].(*budgets.DescribeBudgetActionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeBudgetActionWithContext indicates an expected call of DescribeBudgetActionWithContext.
func (mr *MockBudgetsAPIMockRecorder) DescribeBudgetActionWithContext(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, "DescribeBudgetActionWithContext", reflect.TypeOf((*MockBudgetsAPI)(nil).DescribeBudgetActionWithContext), varargs...)
}

// DescribeBudgetActionsForAccount mocks base method.
func (m *MockBudgetsAPI) DescribeBudgetActionsForAccount(arg0 *budgets.DescribeBudgetActionsForAccountInput) (*budgets.DescribeBudgetActionsForAccountOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeBudgetActionsForAccount", arg0)
	ret0, _ := ret[0].(*budgets.DescribeBudgetActionsForAccountOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeBudgetActionsForAccountPages mocks base method.
func (m *MockBudgetsAPI) DescribeBudgetActionsForAccountPages(arg0 *budgets.DescribeBudgetActionsForAccountInput, arg1 func(*budgets.DescribeBudgetActionsForAccountOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeBudgetActionsForAccountPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeBudgetActionsForAccountPagesWithContext mocks base method.
func (m *MockBudgetsAPI) DescribeBudgetActionsForAccountPagesWithContext(arg0 aws.Context, arg1 *budgets.DescribeBudgetActionsForAccountInput, arg2 func(*budgets.DescribeBudgetActionsForAccountOutput, 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, "DescribeBudgetActionsForAccountPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeBudgetActionsForAccountPagesWithContext indicates an expected call of DescribeBudgetActionsForAccountPagesWithContext.
func (mr *MockBudgetsAPIMockRecorder) DescribeBudgetActionsForAccountPagesWithContext(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, "DescribeBudgetActionsForAccountPagesWithContext", reflect.TypeOf((*MockBudgetsAPI)(nil).DescribeBudgetActionsForAccountPagesWithContext), varargs...)
}

// DescribeBudgetActionsForAccountRequest mocks base method.
func (m *MockBudgetsAPI) DescribeBudgetActionsForAccountRequest(arg0 *budgets.DescribeBudgetActionsForAccountInput) (*request.Request, *budgets.DescribeBudgetActionsForAccountOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeBudgetActionsForAccountRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*budgets.DescribeBudgetActionsForAccountOutput)
	return ret0, ret1
}

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

// DescribeBudgetActionsForAccountWithContext mocks base method.
func (m *MockBudgetsAPI) DescribeBudgetActionsForAccountWithContext(arg0 aws.Context, arg1 *budgets.DescribeBudgetActionsForAccountInput, arg2 ...request.Option) (*budgets.DescribeBudgetActionsForAccountOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeBudgetActionsForAccountWithContext", varargs...)
	ret0, _ := ret[0].(*budgets.DescribeBudgetActionsForAccountOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeBudgetActionsForAccountWithContext indicates an expected call of DescribeBudgetActionsForAccountWithContext.
func (mr *MockBudgetsAPIMockRecorder) DescribeBudgetActionsForAccountWithContext(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, "DescribeBudgetActionsForAccountWithContext", reflect.TypeOf((*MockBudgetsAPI)(nil).DescribeBudgetActionsForAccountWithContext), varargs...)
}

// DescribeBudgetActionsForBudget mocks base method.
func (m *MockBudgetsAPI) DescribeBudgetActionsForBudget(arg0 *budgets.DescribeBudgetActionsForBudgetInput) (*budgets.DescribeBudgetActionsForBudgetOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeBudgetActionsForBudget", arg0)
	ret0, _ := ret[0].(*budgets.DescribeBudgetActionsForBudgetOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeBudgetActionsForBudgetPages mocks base method.
func (m *MockBudgetsAPI) DescribeBudgetActionsForBudgetPages(arg0 *budgets.DescribeBudgetActionsForBudgetInput, arg1 func(*budgets.DescribeBudgetActionsForBudgetOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeBudgetActionsForBudgetPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeBudgetActionsForBudgetPagesWithContext mocks base method.
func (m *MockBudgetsAPI) DescribeBudgetActionsForBudgetPagesWithContext(arg0 aws.Context, arg1 *budgets.DescribeBudgetActionsForBudgetInput, arg2 func(*budgets.DescribeBudgetActionsForBudgetOutput, 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, "DescribeBudgetActionsForBudgetPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeBudgetActionsForBudgetPagesWithContext indicates an expected call of DescribeBudgetActionsForBudgetPagesWithContext.
func (mr *MockBudgetsAPIMockRecorder) DescribeBudgetActionsForBudgetPagesWithContext(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, "DescribeBudgetActionsForBudgetPagesWithContext", reflect.TypeOf((*MockBudgetsAPI)(nil).DescribeBudgetActionsForBudgetPagesWithContext), varargs...)
}

// DescribeBudgetActionsForBudgetRequest mocks base method.
func (m *MockBudgetsAPI) DescribeBudgetActionsForBudgetRequest(arg0 *budgets.DescribeBudgetActionsForBudgetInput) (*request.Request, *budgets.DescribeBudgetActionsForBudgetOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeBudgetActionsForBudgetRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*budgets.DescribeBudgetActionsForBudgetOutput)
	return ret0, ret1
}

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

// DescribeBudgetActionsForBudgetWithContext mocks base method.
func (m *MockBudgetsAPI) DescribeBudgetActionsForBudgetWithContext(arg0 aws.Context, arg1 *budgets.DescribeBudgetActionsForBudgetInput, arg2 ...request.Option) (*budgets.DescribeBudgetActionsForBudgetOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeBudgetActionsForBudgetWithContext", varargs...)
	ret0, _ := ret[0].(*budgets.DescribeBudgetActionsForBudgetOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeBudgetActionsForBudgetWithContext indicates an expected call of DescribeBudgetActionsForBudgetWithContext.
func (mr *MockBudgetsAPIMockRecorder) DescribeBudgetActionsForBudgetWithContext(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, "DescribeBudgetActionsForBudgetWithContext", reflect.TypeOf((*MockBudgetsAPI)(nil).DescribeBudgetActionsForBudgetWithContext), varargs...)
}

// DescribeBudgetNotificationsForAccount mocks base method.
func (m *MockBudgetsAPI) DescribeBudgetNotificationsForAccount(arg0 *budgets.DescribeBudgetNotificationsForAccountInput) (*budgets.DescribeBudgetNotificationsForAccountOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeBudgetNotificationsForAccount", arg0)
	ret0, _ := ret[0].(*budgets.DescribeBudgetNotificationsForAccountOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeBudgetNotificationsForAccountPages mocks base method.
func (m *MockBudgetsAPI) DescribeBudgetNotificationsForAccountPages(arg0 *budgets.DescribeBudgetNotificationsForAccountInput, arg1 func(*budgets.DescribeBudgetNotificationsForAccountOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeBudgetNotificationsForAccountPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeBudgetNotificationsForAccountPagesWithContext mocks base method.
func (m *MockBudgetsAPI) DescribeBudgetNotificationsForAccountPagesWithContext(arg0 aws.Context, arg1 *budgets.DescribeBudgetNotificationsForAccountInput, arg2 func(*budgets.DescribeBudgetNotificationsForAccountOutput, 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, "DescribeBudgetNotificationsForAccountPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeBudgetNotificationsForAccountPagesWithContext indicates an expected call of DescribeBudgetNotificationsForAccountPagesWithContext.
func (mr *MockBudgetsAPIMockRecorder) DescribeBudgetNotificationsForAccountPagesWithContext(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, "DescribeBudgetNotificationsForAccountPagesWithContext", reflect.TypeOf((*MockBudgetsAPI)(nil).DescribeBudgetNotificationsForAccountPagesWithContext), varargs...)
}

// DescribeBudgetNotificationsForAccountRequest mocks base method.
func (m *MockBudgetsAPI) DescribeBudgetNotificationsForAccountRequest(arg0 *budgets.DescribeBudgetNotificationsForAccountInput) (*request.Request, *budgets.DescribeBudgetNotificationsForAccountOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeBudgetNotificationsForAccountRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*budgets.DescribeBudgetNotificationsForAccountOutput)
	return ret0, ret1
}

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

// DescribeBudgetNotificationsForAccountWithContext mocks base method.
func (m *MockBudgetsAPI) DescribeBudgetNotificationsForAccountWithContext(arg0 aws.Context, arg1 *budgets.DescribeBudgetNotificationsForAccountInput, arg2 ...request.Option) (*budgets.DescribeBudgetNotificationsForAccountOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeBudgetNotificationsForAccountWithContext", varargs...)
	ret0, _ := ret[0].(*budgets.DescribeBudgetNotificationsForAccountOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeBudgetNotificationsForAccountWithContext indicates an expected call of DescribeBudgetNotificationsForAccountWithContext.
func (mr *MockBudgetsAPIMockRecorder) DescribeBudgetNotificationsForAccountWithContext(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, "DescribeBudgetNotificationsForAccountWithContext", reflect.TypeOf((*MockBudgetsAPI)(nil).DescribeBudgetNotificationsForAccountWithContext), varargs...)
}

// DescribeBudgetPerformanceHistory mocks base method.
func (m *MockBudgetsAPI) DescribeBudgetPerformanceHistory(arg0 *budgets.DescribeBudgetPerformanceHistoryInput) (*budgets.DescribeBudgetPerformanceHistoryOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeBudgetPerformanceHistory", arg0)
	ret0, _ := ret[0].(*budgets.DescribeBudgetPerformanceHistoryOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeBudgetPerformanceHistoryPages mocks base method.
func (m *MockBudgetsAPI) DescribeBudgetPerformanceHistoryPages(arg0 *budgets.DescribeBudgetPerformanceHistoryInput, arg1 func(*budgets.DescribeBudgetPerformanceHistoryOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeBudgetPerformanceHistoryPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeBudgetPerformanceHistoryPagesWithContext mocks base method.
func (m *MockBudgetsAPI) DescribeBudgetPerformanceHistoryPagesWithContext(arg0 aws.Context, arg1 *budgets.DescribeBudgetPerformanceHistoryInput, arg2 func(*budgets.DescribeBudgetPerformanceHistoryOutput, 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, "DescribeBudgetPerformanceHistoryPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeBudgetPerformanceHistoryPagesWithContext indicates an expected call of DescribeBudgetPerformanceHistoryPagesWithContext.
func (mr *MockBudgetsAPIMockRecorder) DescribeBudgetPerformanceHistoryPagesWithContext(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, "DescribeBudgetPerformanceHistoryPagesWithContext", reflect.TypeOf((*MockBudgetsAPI)(nil).DescribeBudgetPerformanceHistoryPagesWithContext), varargs...)
}

// DescribeBudgetPerformanceHistoryRequest mocks base method.
func (m *MockBudgetsAPI) DescribeBudgetPerformanceHistoryRequest(arg0 *budgets.DescribeBudgetPerformanceHistoryInput) (*request.Request, *budgets.DescribeBudgetPerformanceHistoryOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeBudgetPerformanceHistoryRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*budgets.DescribeBudgetPerformanceHistoryOutput)
	return ret0, ret1
}

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

// DescribeBudgetPerformanceHistoryWithContext mocks base method.
func (m *MockBudgetsAPI) DescribeBudgetPerformanceHistoryWithContext(arg0 aws.Context, arg1 *budgets.DescribeBudgetPerformanceHistoryInput, arg2 ...request.Option) (*budgets.DescribeBudgetPerformanceHistoryOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeBudgetPerformanceHistoryWithContext", varargs...)
	ret0, _ := ret[0].(*budgets.DescribeBudgetPerformanceHistoryOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeBudgetPerformanceHistoryWithContext indicates an expected call of DescribeBudgetPerformanceHistoryWithContext.
func (mr *MockBudgetsAPIMockRecorder) DescribeBudgetPerformanceHistoryWithContext(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, "DescribeBudgetPerformanceHistoryWithContext", reflect.TypeOf((*MockBudgetsAPI)(nil).DescribeBudgetPerformanceHistoryWithContext), varargs...)
}

// DescribeBudgetRequest mocks base method.
func (m *MockBudgetsAPI) DescribeBudgetRequest(arg0 *budgets.DescribeBudgetInput) (*request.Request, *budgets.DescribeBudgetOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeBudgetRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*budgets.DescribeBudgetOutput)
	return ret0, ret1
}

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

// DescribeBudgetWithContext mocks base method.
func (m *MockBudgetsAPI) DescribeBudgetWithContext(arg0 aws.Context, arg1 *budgets.DescribeBudgetInput, arg2 ...request.Option) (*budgets.DescribeBudgetOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeBudgetWithContext", varargs...)
	ret0, _ := ret[0].(*budgets.DescribeBudgetOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeBudgetWithContext indicates an expected call of DescribeBudgetWithContext.
func (mr *MockBudgetsAPIMockRecorder) DescribeBudgetWithContext(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, "DescribeBudgetWithContext", reflect.TypeOf((*MockBudgetsAPI)(nil).DescribeBudgetWithContext), varargs...)
}

// DescribeBudgets mocks base method.
func (m *MockBudgetsAPI) DescribeBudgets(arg0 *budgets.DescribeBudgetsInput) (*budgets.DescribeBudgetsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeBudgets", arg0)
	ret0, _ := ret[0].(*budgets.DescribeBudgetsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeBudgetsPages mocks base method.
func (m *MockBudgetsAPI) DescribeBudgetsPages(arg0 *budgets.DescribeBudgetsInput, arg1 func(*budgets.DescribeBudgetsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeBudgetsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeBudgetsPagesWithContext mocks base method.
func (m *MockBudgetsAPI) DescribeBudgetsPagesWithContext(arg0 aws.Context, arg1 *budgets.DescribeBudgetsInput, arg2 func(*budgets.DescribeBudgetsOutput, 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, "DescribeBudgetsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeBudgetsPagesWithContext indicates an expected call of DescribeBudgetsPagesWithContext.
func (mr *MockBudgetsAPIMockRecorder) DescribeBudgetsPagesWithContext(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, "DescribeBudgetsPagesWithContext", reflect.TypeOf((*MockBudgetsAPI)(nil).DescribeBudgetsPagesWithContext), varargs...)
}

// DescribeBudgetsRequest mocks base method.
func (m *MockBudgetsAPI) DescribeBudgetsRequest(arg0 *budgets.DescribeBudgetsInput) (*request.Request, *budgets.DescribeBudgetsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeBudgetsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*budgets.DescribeBudgetsOutput)
	return ret0, ret1
}

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

// DescribeBudgetsWithContext mocks base method.
func (m *MockBudgetsAPI) DescribeBudgetsWithContext(arg0 aws.Context, arg1 *budgets.DescribeBudgetsInput, arg2 ...request.Option) (*budgets.DescribeBudgetsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeBudgetsWithContext", varargs...)
	ret0, _ := ret[0].(*budgets.DescribeBudgetsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeBudgetsWithContext indicates an expected call of DescribeBudgetsWithContext.
func (mr *MockBudgetsAPIMockRecorder) DescribeBudgetsWithContext(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, "DescribeBudgetsWithContext", reflect.TypeOf((*MockBudgetsAPI)(nil).DescribeBudgetsWithContext), varargs...)
}

// DescribeNotificationsForBudget mocks base method.
func (m *MockBudgetsAPI) DescribeNotificationsForBudget(arg0 *budgets.DescribeNotificationsForBudgetInput) (*budgets.DescribeNotificationsForBudgetOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeNotificationsForBudget", arg0)
	ret0, _ := ret[0].(*budgets.DescribeNotificationsForBudgetOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeNotificationsForBudgetPages mocks base method.
func (m *MockBudgetsAPI) DescribeNotificationsForBudgetPages(arg0 *budgets.DescribeNotificationsForBudgetInput, arg1 func(*budgets.DescribeNotificationsForBudgetOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeNotificationsForBudgetPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeNotificationsForBudgetPagesWithContext mocks base method.
func (m *MockBudgetsAPI) DescribeNotificationsForBudgetPagesWithContext(arg0 aws.Context, arg1 *budgets.DescribeNotificationsForBudgetInput, arg2 func(*budgets.DescribeNotificationsForBudgetOutput, 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, "DescribeNotificationsForBudgetPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeNotificationsForBudgetPagesWithContext indicates an expected call of DescribeNotificationsForBudgetPagesWithContext.
func (mr *MockBudgetsAPIMockRecorder) DescribeNotificationsForBudgetPagesWithContext(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, "DescribeNotificationsForBudgetPagesWithContext", reflect.TypeOf((*MockBudgetsAPI)(nil).DescribeNotificationsForBudgetPagesWithContext), varargs...)
}

// DescribeNotificationsForBudgetRequest mocks base method.
func (m *MockBudgetsAPI) DescribeNotificationsForBudgetRequest(arg0 *budgets.DescribeNotificationsForBudgetInput) (*request.Request, *budgets.DescribeNotificationsForBudgetOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeNotificationsForBudgetRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*budgets.DescribeNotificationsForBudgetOutput)
	return ret0, ret1
}

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

// DescribeNotificationsForBudgetWithContext mocks base method.
func (m *MockBudgetsAPI) DescribeNotificationsForBudgetWithContext(arg0 aws.Context, arg1 *budgets.DescribeNotificationsForBudgetInput, arg2 ...request.Option) (*budgets.DescribeNotificationsForBudgetOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeNotificationsForBudgetWithContext", varargs...)
	ret0, _ := ret[0].(*budgets.DescribeNotificationsForBudgetOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeNotificationsForBudgetWithContext indicates an expected call of DescribeNotificationsForBudgetWithContext.
func (mr *MockBudgetsAPIMockRecorder) DescribeNotificationsForBudgetWithContext(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, "DescribeNotificationsForBudgetWithContext", reflect.TypeOf((*MockBudgetsAPI)(nil).DescribeNotificationsForBudgetWithContext), varargs...)
}

// DescribeSubscribersForNotification mocks base method.
func (m *MockBudgetsAPI) DescribeSubscribersForNotification(arg0 *budgets.DescribeSubscribersForNotificationInput) (*budgets.DescribeSubscribersForNotificationOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeSubscribersForNotification", arg0)
	ret0, _ := ret[0].(*budgets.DescribeSubscribersForNotificationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeSubscribersForNotificationPages mocks base method.
func (m *MockBudgetsAPI) DescribeSubscribersForNotificationPages(arg0 *budgets.DescribeSubscribersForNotificationInput, arg1 func(*budgets.DescribeSubscribersForNotificationOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeSubscribersForNotificationPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeSubscribersForNotificationPagesWithContext mocks base method.
func (m *MockBudgetsAPI) DescribeSubscribersForNotificationPagesWithContext(arg0 aws.Context, arg1 *budgets.DescribeSubscribersForNotificationInput, arg2 func(*budgets.DescribeSubscribersForNotificationOutput, 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, "DescribeSubscribersForNotificationPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeSubscribersForNotificationPagesWithContext indicates an expected call of DescribeSubscribersForNotificationPagesWithContext.
func (mr *MockBudgetsAPIMockRecorder) DescribeSubscribersForNotificationPagesWithContext(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, "DescribeSubscribersForNotificationPagesWithContext", reflect.TypeOf((*MockBudgetsAPI)(nil).DescribeSubscribersForNotificationPagesWithContext), varargs...)
}

// DescribeSubscribersForNotificationRequest mocks base method.
func (m *MockBudgetsAPI) DescribeSubscribersForNotificationRequest(arg0 *budgets.DescribeSubscribersForNotificationInput) (*request.Request, *budgets.DescribeSubscribersForNotificationOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeSubscribersForNotificationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*budgets.DescribeSubscribersForNotificationOutput)
	return ret0, ret1
}

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

// DescribeSubscribersForNotificationWithContext mocks base method.
func (m *MockBudgetsAPI) DescribeSubscribersForNotificationWithContext(arg0 aws.Context, arg1 *budgets.DescribeSubscribersForNotificationInput, arg2 ...request.Option) (*budgets.DescribeSubscribersForNotificationOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeSubscribersForNotificationWithContext", varargs...)
	ret0, _ := ret[0].(*budgets.DescribeSubscribersForNotificationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeSubscribersForNotificationWithContext indicates an expected call of DescribeSubscribersForNotificationWithContext.
func (mr *MockBudgetsAPIMockRecorder) DescribeSubscribersForNotificationWithContext(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, "DescribeSubscribersForNotificationWithContext", reflect.TypeOf((*MockBudgetsAPI)(nil).DescribeSubscribersForNotificationWithContext), varargs...)
}

// ExecuteBudgetAction mocks base method.
func (m *MockBudgetsAPI) ExecuteBudgetAction(arg0 *budgets.ExecuteBudgetActionInput) (*budgets.ExecuteBudgetActionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ExecuteBudgetAction", arg0)
	ret0, _ := ret[0].(*budgets.ExecuteBudgetActionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ExecuteBudgetActionRequest mocks base method.
func (m *MockBudgetsAPI) ExecuteBudgetActionRequest(arg0 *budgets.ExecuteBudgetActionInput) (*request.Request, *budgets.ExecuteBudgetActionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ExecuteBudgetActionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*budgets.ExecuteBudgetActionOutput)
	return ret0, ret1
}

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

// ExecuteBudgetActionWithContext mocks base method.
func (m *MockBudgetsAPI) ExecuteBudgetActionWithContext(arg0 aws.Context, arg1 *budgets.ExecuteBudgetActionInput, arg2 ...request.Option) (*budgets.ExecuteBudgetActionOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ExecuteBudgetActionWithContext", varargs...)
	ret0, _ := ret[0].(*budgets.ExecuteBudgetActionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ExecuteBudgetActionWithContext indicates an expected call of ExecuteBudgetActionWithContext.
func (mr *MockBudgetsAPIMockRecorder) ExecuteBudgetActionWithContext(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, "ExecuteBudgetActionWithContext", reflect.TypeOf((*MockBudgetsAPI)(nil).ExecuteBudgetActionWithContext), varargs...)
}

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

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

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

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

// ListTagsForResourceWithContext mocks base method.
func (m *MockBudgetsAPI) ListTagsForResourceWithContext(arg0 aws.Context, arg1 *budgets.ListTagsForResourceInput, arg2 ...request.Option) (*budgets.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].(*budgets.ListTagsForResourceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListTagsForResourceWithContext indicates an expected call of ListTagsForResourceWithContext.
func (mr *MockBudgetsAPIMockRecorder) 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((*MockBudgetsAPI)(nil).ListTagsForResourceWithContext), varargs...)
}

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

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

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

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

// TagResourceWithContext mocks base method.
func (m *MockBudgetsAPI) TagResourceWithContext(arg0 aws.Context, arg1 *budgets.TagResourceInput, arg2 ...request.Option) (*budgets.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].(*budgets.TagResourceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// TagResourceWithContext indicates an expected call of TagResourceWithContext.
func (mr *MockBudgetsAPIMockRecorder) 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((*MockBudgetsAPI)(nil).TagResourceWithContext), varargs...)
}

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

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

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

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

// UntagResourceWithContext mocks base method.
func (m *MockBudgetsAPI) UntagResourceWithContext(arg0 aws.Context, arg1 *budgets.UntagResourceInput, arg2 ...request.Option) (*budgets.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].(*budgets.UntagResourceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UntagResourceWithContext indicates an expected call of UntagResourceWithContext.
func (mr *MockBudgetsAPIMockRecorder) 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((*MockBudgetsAPI)(nil).UntagResourceWithContext), varargs...)
}

// UpdateBudget mocks base method.
func (m *MockBudgetsAPI) UpdateBudget(arg0 *budgets.UpdateBudgetInput) (*budgets.UpdateBudgetOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateBudget", arg0)
	ret0, _ := ret[0].(*budgets.UpdateBudgetOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateBudgetAction mocks base method.
func (m *MockBudgetsAPI) UpdateBudgetAction(arg0 *budgets.UpdateBudgetActionInput) (*budgets.UpdateBudgetActionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateBudgetAction", arg0)
	ret0, _ := ret[0].(*budgets.UpdateBudgetActionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateBudgetActionRequest mocks base method.
func (m *MockBudgetsAPI) UpdateBudgetActionRequest(arg0 *budgets.UpdateBudgetActionInput) (*request.Request, *budgets.UpdateBudgetActionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateBudgetActionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*budgets.UpdateBudgetActionOutput)
	return ret0, ret1
}

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

// UpdateBudgetActionWithContext mocks base method.
func (m *MockBudgetsAPI) UpdateBudgetActionWithContext(arg0 aws.Context, arg1 *budgets.UpdateBudgetActionInput, arg2 ...request.Option) (*budgets.UpdateBudgetActionOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateBudgetActionWithContext", varargs...)
	ret0, _ := ret[0].(*budgets.UpdateBudgetActionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateBudgetActionWithContext indicates an expected call of UpdateBudgetActionWithContext.
func (mr *MockBudgetsAPIMockRecorder) UpdateBudgetActionWithContext(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, "UpdateBudgetActionWithContext", reflect.TypeOf((*MockBudgetsAPI)(nil).UpdateBudgetActionWithContext), varargs...)
}

// UpdateBudgetRequest mocks base method.
func (m *MockBudgetsAPI) UpdateBudgetRequest(arg0 *budgets.UpdateBudgetInput) (*request.Request, *budgets.UpdateBudgetOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateBudgetRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*budgets.UpdateBudgetOutput)
	return ret0, ret1
}

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

// UpdateBudgetWithContext mocks base method.
func (m *MockBudgetsAPI) UpdateBudgetWithContext(arg0 aws.Context, arg1 *budgets.UpdateBudgetInput, arg2 ...request.Option) (*budgets.UpdateBudgetOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateBudgetWithContext", varargs...)
	ret0, _ := ret[0].(*budgets.UpdateBudgetOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateBudgetWithContext indicates an expected call of UpdateBudgetWithContext.
func (mr *MockBudgetsAPIMockRecorder) UpdateBudgetWithContext(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, "UpdateBudgetWithContext", reflect.TypeOf((*MockBudgetsAPI)(nil).UpdateBudgetWithContext), varargs...)
}

// UpdateNotification mocks base method.
func (m *MockBudgetsAPI) UpdateNotification(arg0 *budgets.UpdateNotificationInput) (*budgets.UpdateNotificationOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateNotification", arg0)
	ret0, _ := ret[0].(*budgets.UpdateNotificationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateNotificationRequest mocks base method.
func (m *MockBudgetsAPI) UpdateNotificationRequest(arg0 *budgets.UpdateNotificationInput) (*request.Request, *budgets.UpdateNotificationOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateNotificationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*budgets.UpdateNotificationOutput)
	return ret0, ret1
}

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

// UpdateNotificationWithContext mocks base method.
func (m *MockBudgetsAPI) UpdateNotificationWithContext(arg0 aws.Context, arg1 *budgets.UpdateNotificationInput, arg2 ...request.Option) (*budgets.UpdateNotificationOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateNotificationWithContext", varargs...)
	ret0, _ := ret[0].(*budgets.UpdateNotificationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateNotificationWithContext indicates an expected call of UpdateNotificationWithContext.
func (mr *MockBudgetsAPIMockRecorder) UpdateNotificationWithContext(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, "UpdateNotificationWithContext", reflect.TypeOf((*MockBudgetsAPI)(nil).UpdateNotificationWithContext), varargs...)
}

// UpdateSubscriber mocks base method.
func (m *MockBudgetsAPI) UpdateSubscriber(arg0 *budgets.UpdateSubscriberInput) (*budgets.UpdateSubscriberOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateSubscriber", arg0)
	ret0, _ := ret[0].(*budgets.UpdateSubscriberOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateSubscriberRequest mocks base method.
func (m *MockBudgetsAPI) UpdateSubscriberRequest(arg0 *budgets.UpdateSubscriberInput) (*request.Request, *budgets.UpdateSubscriberOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateSubscriberRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*budgets.UpdateSubscriberOutput)
	return ret0, ret1
}

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

// UpdateSubscriberWithContext mocks base method.
func (m *MockBudgetsAPI) UpdateSubscriberWithContext(arg0 aws.Context, arg1 *budgets.UpdateSubscriberInput, arg2 ...request.Option) (*budgets.UpdateSubscriberOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateSubscriberWithContext", varargs...)
	ret0, _ := ret[0].(*budgets.UpdateSubscriberOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateSubscriberWithContext indicates an expected call of UpdateSubscriberWithContext.
func (mr *MockBudgetsAPIMockRecorder) UpdateSubscriberWithContext(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, "UpdateSubscriberWithContext", reflect.TypeOf((*MockBudgetsAPI)(nil).UpdateSubscriberWithContext), varargs...)
}
