mock.go

// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/aws/aws-sdk-go/service/eventbridge/eventbridgeiface (interfaces: EventBridgeAPI)

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

import (
	context "context"
	reflect "reflect"

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

// MockEventBridgeAPI is a mock of EventBridgeAPI interface.
type MockEventBridgeAPI struct {
	ctrl     *gomock.Controller
	recorder *MockEventBridgeAPIMockRecorder
}

// MockEventBridgeAPIMockRecorder is the mock recorder for MockEventBridgeAPI.
type MockEventBridgeAPIMockRecorder struct {
	mock *MockEventBridgeAPI
}

// NewMockEventBridgeAPI creates a new mock instance.
func NewMockEventBridgeAPI(ctrl *gomock.Controller) *MockEventBridgeAPI {
	mock := &MockEventBridgeAPI{ctrl: ctrl}
	mock.recorder = &MockEventBridgeAPIMockRecorder{mock}
	return mock
}

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

// ActivateEventSource mocks base method.
func (m *MockEventBridgeAPI) ActivateEventSource(arg0 *eventbridge.ActivateEventSourceInput) (*eventbridge.ActivateEventSourceOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ActivateEventSource", arg0)
	ret0, _ := ret[0].(*eventbridge.ActivateEventSourceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ActivateEventSourceRequest mocks base method.
func (m *MockEventBridgeAPI) ActivateEventSourceRequest(arg0 *eventbridge.ActivateEventSourceInput) (*request.Request, *eventbridge.ActivateEventSourceOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ActivateEventSourceRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*eventbridge.ActivateEventSourceOutput)
	return ret0, ret1
}

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

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

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

// CancelReplay mocks base method.
func (m *MockEventBridgeAPI) CancelReplay(arg0 *eventbridge.CancelReplayInput) (*eventbridge.CancelReplayOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CancelReplay", arg0)
	ret0, _ := ret[0].(*eventbridge.CancelReplayOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CancelReplayRequest mocks base method.
func (m *MockEventBridgeAPI) CancelReplayRequest(arg0 *eventbridge.CancelReplayInput) (*request.Request, *eventbridge.CancelReplayOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CancelReplayRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*eventbridge.CancelReplayOutput)
	return ret0, ret1
}

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

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

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

// CreateApiDestination mocks base method.
func (m *MockEventBridgeAPI) CreateApiDestination(arg0 *eventbridge.CreateApiDestinationInput) (*eventbridge.CreateApiDestinationOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateApiDestination", arg0)
	ret0, _ := ret[0].(*eventbridge.CreateApiDestinationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateApiDestinationRequest mocks base method.
func (m *MockEventBridgeAPI) CreateApiDestinationRequest(arg0 *eventbridge.CreateApiDestinationInput) (*request.Request, *eventbridge.CreateApiDestinationOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateApiDestinationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*eventbridge.CreateApiDestinationOutput)
	return ret0, ret1
}

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

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

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

// CreateArchive mocks base method.
func (m *MockEventBridgeAPI) CreateArchive(arg0 *eventbridge.CreateArchiveInput) (*eventbridge.CreateArchiveOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateArchive", arg0)
	ret0, _ := ret[0].(*eventbridge.CreateArchiveOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateArchiveRequest mocks base method.
func (m *MockEventBridgeAPI) CreateArchiveRequest(arg0 *eventbridge.CreateArchiveInput) (*request.Request, *eventbridge.CreateArchiveOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateArchiveRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*eventbridge.CreateArchiveOutput)
	return ret0, ret1
}

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

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

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

// CreateConnection mocks base method.
func (m *MockEventBridgeAPI) CreateConnection(arg0 *eventbridge.CreateConnectionInput) (*eventbridge.CreateConnectionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateConnection", arg0)
	ret0, _ := ret[0].(*eventbridge.CreateConnectionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateConnectionRequest mocks base method.
func (m *MockEventBridgeAPI) CreateConnectionRequest(arg0 *eventbridge.CreateConnectionInput) (*request.Request, *eventbridge.CreateConnectionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateConnectionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*eventbridge.CreateConnectionOutput)
	return ret0, ret1
}

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

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

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

// CreateEventBus mocks base method.
func (m *MockEventBridgeAPI) CreateEventBus(arg0 *eventbridge.CreateEventBusInput) (*eventbridge.CreateEventBusOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateEventBus", arg0)
	ret0, _ := ret[0].(*eventbridge.CreateEventBusOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateEventBusRequest mocks base method.
func (m *MockEventBridgeAPI) CreateEventBusRequest(arg0 *eventbridge.CreateEventBusInput) (*request.Request, *eventbridge.CreateEventBusOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateEventBusRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*eventbridge.CreateEventBusOutput)
	return ret0, ret1
}

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

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

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

// CreatePartnerEventSource mocks base method.
func (m *MockEventBridgeAPI) CreatePartnerEventSource(arg0 *eventbridge.CreatePartnerEventSourceInput) (*eventbridge.CreatePartnerEventSourceOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreatePartnerEventSource", arg0)
	ret0, _ := ret[0].(*eventbridge.CreatePartnerEventSourceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreatePartnerEventSourceRequest mocks base method.
func (m *MockEventBridgeAPI) CreatePartnerEventSourceRequest(arg0 *eventbridge.CreatePartnerEventSourceInput) (*request.Request, *eventbridge.CreatePartnerEventSourceOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreatePartnerEventSourceRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*eventbridge.CreatePartnerEventSourceOutput)
	return ret0, ret1
}

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

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

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

// DeactivateEventSource mocks base method.
func (m *MockEventBridgeAPI) DeactivateEventSource(arg0 *eventbridge.DeactivateEventSourceInput) (*eventbridge.DeactivateEventSourceOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeactivateEventSource", arg0)
	ret0, _ := ret[0].(*eventbridge.DeactivateEventSourceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeactivateEventSourceRequest mocks base method.
func (m *MockEventBridgeAPI) DeactivateEventSourceRequest(arg0 *eventbridge.DeactivateEventSourceInput) (*request.Request, *eventbridge.DeactivateEventSourceOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeactivateEventSourceRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*eventbridge.DeactivateEventSourceOutput)
	return ret0, ret1
}

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

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

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

// DeauthorizeConnection mocks base method.
func (m *MockEventBridgeAPI) DeauthorizeConnection(arg0 *eventbridge.DeauthorizeConnectionInput) (*eventbridge.DeauthorizeConnectionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeauthorizeConnection", arg0)
	ret0, _ := ret[0].(*eventbridge.DeauthorizeConnectionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeauthorizeConnectionRequest mocks base method.
func (m *MockEventBridgeAPI) DeauthorizeConnectionRequest(arg0 *eventbridge.DeauthorizeConnectionInput) (*request.Request, *eventbridge.DeauthorizeConnectionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeauthorizeConnectionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*eventbridge.DeauthorizeConnectionOutput)
	return ret0, ret1
}

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

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

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

// DeleteApiDestination mocks base method.
func (m *MockEventBridgeAPI) DeleteApiDestination(arg0 *eventbridge.DeleteApiDestinationInput) (*eventbridge.DeleteApiDestinationOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteApiDestination", arg0)
	ret0, _ := ret[0].(*eventbridge.DeleteApiDestinationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteApiDestinationRequest mocks base method.
func (m *MockEventBridgeAPI) DeleteApiDestinationRequest(arg0 *eventbridge.DeleteApiDestinationInput) (*request.Request, *eventbridge.DeleteApiDestinationOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteApiDestinationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*eventbridge.DeleteApiDestinationOutput)
	return ret0, ret1
}

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

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

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

// DeleteArchive mocks base method.
func (m *MockEventBridgeAPI) DeleteArchive(arg0 *eventbridge.DeleteArchiveInput) (*eventbridge.DeleteArchiveOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteArchive", arg0)
	ret0, _ := ret[0].(*eventbridge.DeleteArchiveOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteArchiveRequest mocks base method.
func (m *MockEventBridgeAPI) DeleteArchiveRequest(arg0 *eventbridge.DeleteArchiveInput) (*request.Request, *eventbridge.DeleteArchiveOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteArchiveRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*eventbridge.DeleteArchiveOutput)
	return ret0, ret1
}

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

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

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

// DeleteConnection mocks base method.
func (m *MockEventBridgeAPI) DeleteConnection(arg0 *eventbridge.DeleteConnectionInput) (*eventbridge.DeleteConnectionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteConnection", arg0)
	ret0, _ := ret[0].(*eventbridge.DeleteConnectionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteConnectionRequest mocks base method.
func (m *MockEventBridgeAPI) DeleteConnectionRequest(arg0 *eventbridge.DeleteConnectionInput) (*request.Request, *eventbridge.DeleteConnectionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteConnectionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*eventbridge.DeleteConnectionOutput)
	return ret0, ret1
}

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

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

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

// DeleteEventBus mocks base method.
func (m *MockEventBridgeAPI) DeleteEventBus(arg0 *eventbridge.DeleteEventBusInput) (*eventbridge.DeleteEventBusOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteEventBus", arg0)
	ret0, _ := ret[0].(*eventbridge.DeleteEventBusOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteEventBusRequest mocks base method.
func (m *MockEventBridgeAPI) DeleteEventBusRequest(arg0 *eventbridge.DeleteEventBusInput) (*request.Request, *eventbridge.DeleteEventBusOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteEventBusRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*eventbridge.DeleteEventBusOutput)
	return ret0, ret1
}

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

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

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

// DeletePartnerEventSource mocks base method.
func (m *MockEventBridgeAPI) DeletePartnerEventSource(arg0 *eventbridge.DeletePartnerEventSourceInput) (*eventbridge.DeletePartnerEventSourceOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeletePartnerEventSource", arg0)
	ret0, _ := ret[0].(*eventbridge.DeletePartnerEventSourceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeletePartnerEventSourceRequest mocks base method.
func (m *MockEventBridgeAPI) DeletePartnerEventSourceRequest(arg0 *eventbridge.DeletePartnerEventSourceInput) (*request.Request, *eventbridge.DeletePartnerEventSourceOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeletePartnerEventSourceRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*eventbridge.DeletePartnerEventSourceOutput)
	return ret0, ret1
}

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

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

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

// DeleteRule mocks base method.
func (m *MockEventBridgeAPI) DeleteRule(arg0 *eventbridge.DeleteRuleInput) (*eventbridge.DeleteRuleOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteRule", arg0)
	ret0, _ := ret[0].(*eventbridge.DeleteRuleOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteRuleRequest mocks base method.
func (m *MockEventBridgeAPI) DeleteRuleRequest(arg0 *eventbridge.DeleteRuleInput) (*request.Request, *eventbridge.DeleteRuleOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteRuleRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*eventbridge.DeleteRuleOutput)
	return ret0, ret1
}

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

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

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

// DescribeApiDestination mocks base method.
func (m *MockEventBridgeAPI) DescribeApiDestination(arg0 *eventbridge.DescribeApiDestinationInput) (*eventbridge.DescribeApiDestinationOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeApiDestination", arg0)
	ret0, _ := ret[0].(*eventbridge.DescribeApiDestinationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeApiDestinationRequest mocks base method.
func (m *MockEventBridgeAPI) DescribeApiDestinationRequest(arg0 *eventbridge.DescribeApiDestinationInput) (*request.Request, *eventbridge.DescribeApiDestinationOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeApiDestinationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*eventbridge.DescribeApiDestinationOutput)
	return ret0, ret1
}

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

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

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

// DescribeArchive mocks base method.
func (m *MockEventBridgeAPI) DescribeArchive(arg0 *eventbridge.DescribeArchiveInput) (*eventbridge.DescribeArchiveOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeArchive", arg0)
	ret0, _ := ret[0].(*eventbridge.DescribeArchiveOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeArchiveRequest mocks base method.
func (m *MockEventBridgeAPI) DescribeArchiveRequest(arg0 *eventbridge.DescribeArchiveInput) (*request.Request, *eventbridge.DescribeArchiveOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeArchiveRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*eventbridge.DescribeArchiveOutput)
	return ret0, ret1
}

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

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

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

// DescribeConnection mocks base method.
func (m *MockEventBridgeAPI) DescribeConnection(arg0 *eventbridge.DescribeConnectionInput) (*eventbridge.DescribeConnectionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeConnection", arg0)
	ret0, _ := ret[0].(*eventbridge.DescribeConnectionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeConnectionRequest mocks base method.
func (m *MockEventBridgeAPI) DescribeConnectionRequest(arg0 *eventbridge.DescribeConnectionInput) (*request.Request, *eventbridge.DescribeConnectionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeConnectionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*eventbridge.DescribeConnectionOutput)
	return ret0, ret1
}

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

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

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

// DescribeEventBus mocks base method.
func (m *MockEventBridgeAPI) DescribeEventBus(arg0 *eventbridge.DescribeEventBusInput) (*eventbridge.DescribeEventBusOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeEventBus", arg0)
	ret0, _ := ret[0].(*eventbridge.DescribeEventBusOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeEventBusRequest mocks base method.
func (m *MockEventBridgeAPI) DescribeEventBusRequest(arg0 *eventbridge.DescribeEventBusInput) (*request.Request, *eventbridge.DescribeEventBusOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeEventBusRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*eventbridge.DescribeEventBusOutput)
	return ret0, ret1
}

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

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

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

// DescribeEventSource mocks base method.
func (m *MockEventBridgeAPI) DescribeEventSource(arg0 *eventbridge.DescribeEventSourceInput) (*eventbridge.DescribeEventSourceOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeEventSource", arg0)
	ret0, _ := ret[0].(*eventbridge.DescribeEventSourceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeEventSourceRequest mocks base method.
func (m *MockEventBridgeAPI) DescribeEventSourceRequest(arg0 *eventbridge.DescribeEventSourceInput) (*request.Request, *eventbridge.DescribeEventSourceOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeEventSourceRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*eventbridge.DescribeEventSourceOutput)
	return ret0, ret1
}

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

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

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

// DescribePartnerEventSource mocks base method.
func (m *MockEventBridgeAPI) DescribePartnerEventSource(arg0 *eventbridge.DescribePartnerEventSourceInput) (*eventbridge.DescribePartnerEventSourceOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribePartnerEventSource", arg0)
	ret0, _ := ret[0].(*eventbridge.DescribePartnerEventSourceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribePartnerEventSourceRequest mocks base method.
func (m *MockEventBridgeAPI) DescribePartnerEventSourceRequest(arg0 *eventbridge.DescribePartnerEventSourceInput) (*request.Request, *eventbridge.DescribePartnerEventSourceOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribePartnerEventSourceRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*eventbridge.DescribePartnerEventSourceOutput)
	return ret0, ret1
}

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

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

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

// DescribeReplay mocks base method.
func (m *MockEventBridgeAPI) DescribeReplay(arg0 *eventbridge.DescribeReplayInput) (*eventbridge.DescribeReplayOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeReplay", arg0)
	ret0, _ := ret[0].(*eventbridge.DescribeReplayOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeReplayRequest mocks base method.
func (m *MockEventBridgeAPI) DescribeReplayRequest(arg0 *eventbridge.DescribeReplayInput) (*request.Request, *eventbridge.DescribeReplayOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeReplayRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*eventbridge.DescribeReplayOutput)
	return ret0, ret1
}

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

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

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

// DescribeRule mocks base method.
func (m *MockEventBridgeAPI) DescribeRule(arg0 *eventbridge.DescribeRuleInput) (*eventbridge.DescribeRuleOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeRule", arg0)
	ret0, _ := ret[0].(*eventbridge.DescribeRuleOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeRuleRequest mocks base method.
func (m *MockEventBridgeAPI) DescribeRuleRequest(arg0 *eventbridge.DescribeRuleInput) (*request.Request, *eventbridge.DescribeRuleOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeRuleRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*eventbridge.DescribeRuleOutput)
	return ret0, ret1
}

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

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

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

// DisableRule mocks base method.
func (m *MockEventBridgeAPI) DisableRule(arg0 *eventbridge.DisableRuleInput) (*eventbridge.DisableRuleOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DisableRule", arg0)
	ret0, _ := ret[0].(*eventbridge.DisableRuleOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DisableRuleRequest mocks base method.
func (m *MockEventBridgeAPI) DisableRuleRequest(arg0 *eventbridge.DisableRuleInput) (*request.Request, *eventbridge.DisableRuleOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DisableRuleRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*eventbridge.DisableRuleOutput)
	return ret0, ret1
}

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

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

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

// EnableRule mocks base method.
func (m *MockEventBridgeAPI) EnableRule(arg0 *eventbridge.EnableRuleInput) (*eventbridge.EnableRuleOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EnableRule", arg0)
	ret0, _ := ret[0].(*eventbridge.EnableRuleOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// EnableRuleRequest mocks base method.
func (m *MockEventBridgeAPI) EnableRuleRequest(arg0 *eventbridge.EnableRuleInput) (*request.Request, *eventbridge.EnableRuleOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EnableRuleRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*eventbridge.EnableRuleOutput)
	return ret0, ret1
}

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

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

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

// ListApiDestinations mocks base method.
func (m *MockEventBridgeAPI) ListApiDestinations(arg0 *eventbridge.ListApiDestinationsInput) (*eventbridge.ListApiDestinationsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListApiDestinations", arg0)
	ret0, _ := ret[0].(*eventbridge.ListApiDestinationsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListApiDestinationsRequest mocks base method.
func (m *MockEventBridgeAPI) ListApiDestinationsRequest(arg0 *eventbridge.ListApiDestinationsInput) (*request.Request, *eventbridge.ListApiDestinationsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListApiDestinationsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*eventbridge.ListApiDestinationsOutput)
	return ret0, ret1
}

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

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

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

// ListArchives mocks base method.
func (m *MockEventBridgeAPI) ListArchives(arg0 *eventbridge.ListArchivesInput) (*eventbridge.ListArchivesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListArchives", arg0)
	ret0, _ := ret[0].(*eventbridge.ListArchivesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListArchivesRequest mocks base method.
func (m *MockEventBridgeAPI) ListArchivesRequest(arg0 *eventbridge.ListArchivesInput) (*request.Request, *eventbridge.ListArchivesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListArchivesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*eventbridge.ListArchivesOutput)
	return ret0, ret1
}

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

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

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

// ListConnections mocks base method.
func (m *MockEventBridgeAPI) ListConnections(arg0 *eventbridge.ListConnectionsInput) (*eventbridge.ListConnectionsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListConnections", arg0)
	ret0, _ := ret[0].(*eventbridge.ListConnectionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListConnectionsRequest mocks base method.
func (m *MockEventBridgeAPI) ListConnectionsRequest(arg0 *eventbridge.ListConnectionsInput) (*request.Request, *eventbridge.ListConnectionsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListConnectionsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*eventbridge.ListConnectionsOutput)
	return ret0, ret1
}

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

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

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

// ListEventBuses mocks base method.
func (m *MockEventBridgeAPI) ListEventBuses(arg0 *eventbridge.ListEventBusesInput) (*eventbridge.ListEventBusesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListEventBuses", arg0)
	ret0, _ := ret[0].(*eventbridge.ListEventBusesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListEventBusesRequest mocks base method.
func (m *MockEventBridgeAPI) ListEventBusesRequest(arg0 *eventbridge.ListEventBusesInput) (*request.Request, *eventbridge.ListEventBusesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListEventBusesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*eventbridge.ListEventBusesOutput)
	return ret0, ret1
}

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

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

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

// ListEventSources mocks base method.
func (m *MockEventBridgeAPI) ListEventSources(arg0 *eventbridge.ListEventSourcesInput) (*eventbridge.ListEventSourcesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListEventSources", arg0)
	ret0, _ := ret[0].(*eventbridge.ListEventSourcesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListEventSourcesRequest mocks base method.
func (m *MockEventBridgeAPI) ListEventSourcesRequest(arg0 *eventbridge.ListEventSourcesInput) (*request.Request, *eventbridge.ListEventSourcesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListEventSourcesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*eventbridge.ListEventSourcesOutput)
	return ret0, ret1
}

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

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

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

// ListPartnerEventSourceAccounts mocks base method.
func (m *MockEventBridgeAPI) ListPartnerEventSourceAccounts(arg0 *eventbridge.ListPartnerEventSourceAccountsInput) (*eventbridge.ListPartnerEventSourceAccountsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListPartnerEventSourceAccounts", arg0)
	ret0, _ := ret[0].(*eventbridge.ListPartnerEventSourceAccountsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListPartnerEventSourceAccountsRequest mocks base method.
func (m *MockEventBridgeAPI) ListPartnerEventSourceAccountsRequest(arg0 *eventbridge.ListPartnerEventSourceAccountsInput) (*request.Request, *eventbridge.ListPartnerEventSourceAccountsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListPartnerEventSourceAccountsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*eventbridge.ListPartnerEventSourceAccountsOutput)
	return ret0, ret1
}

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

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

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

// ListPartnerEventSources mocks base method.
func (m *MockEventBridgeAPI) ListPartnerEventSources(arg0 *eventbridge.ListPartnerEventSourcesInput) (*eventbridge.ListPartnerEventSourcesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListPartnerEventSources", arg0)
	ret0, _ := ret[0].(*eventbridge.ListPartnerEventSourcesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListPartnerEventSourcesRequest mocks base method.
func (m *MockEventBridgeAPI) ListPartnerEventSourcesRequest(arg0 *eventbridge.ListPartnerEventSourcesInput) (*request.Request, *eventbridge.ListPartnerEventSourcesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListPartnerEventSourcesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*eventbridge.ListPartnerEventSourcesOutput)
	return ret0, ret1
}

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

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

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

// ListReplays mocks base method.
func (m *MockEventBridgeAPI) ListReplays(arg0 *eventbridge.ListReplaysInput) (*eventbridge.ListReplaysOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListReplays", arg0)
	ret0, _ := ret[0].(*eventbridge.ListReplaysOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListReplaysRequest mocks base method.
func (m *MockEventBridgeAPI) ListReplaysRequest(arg0 *eventbridge.ListReplaysInput) (*request.Request, *eventbridge.ListReplaysOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListReplaysRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*eventbridge.ListReplaysOutput)
	return ret0, ret1
}

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

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

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

// ListRuleNamesByTarget mocks base method.
func (m *MockEventBridgeAPI) ListRuleNamesByTarget(arg0 *eventbridge.ListRuleNamesByTargetInput) (*eventbridge.ListRuleNamesByTargetOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListRuleNamesByTarget", arg0)
	ret0, _ := ret[0].(*eventbridge.ListRuleNamesByTargetOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListRuleNamesByTargetRequest mocks base method.
func (m *MockEventBridgeAPI) ListRuleNamesByTargetRequest(arg0 *eventbridge.ListRuleNamesByTargetInput) (*request.Request, *eventbridge.ListRuleNamesByTargetOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListRuleNamesByTargetRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*eventbridge.ListRuleNamesByTargetOutput)
	return ret0, ret1
}

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

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

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

// ListRules mocks base method.
func (m *MockEventBridgeAPI) ListRules(arg0 *eventbridge.ListRulesInput) (*eventbridge.ListRulesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListRules", arg0)
	ret0, _ := ret[0].(*eventbridge.ListRulesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListRulesRequest mocks base method.
func (m *MockEventBridgeAPI) ListRulesRequest(arg0 *eventbridge.ListRulesInput) (*request.Request, *eventbridge.ListRulesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListRulesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*eventbridge.ListRulesOutput)
	return ret0, ret1
}

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

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

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

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

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

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

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

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

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

// ListTargetsByRule mocks base method.
func (m *MockEventBridgeAPI) ListTargetsByRule(arg0 *eventbridge.ListTargetsByRuleInput) (*eventbridge.ListTargetsByRuleOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListTargetsByRule", arg0)
	ret0, _ := ret[0].(*eventbridge.ListTargetsByRuleOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListTargetsByRuleRequest mocks base method.
func (m *MockEventBridgeAPI) ListTargetsByRuleRequest(arg0 *eventbridge.ListTargetsByRuleInput) (*request.Request, *eventbridge.ListTargetsByRuleOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListTargetsByRuleRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*eventbridge.ListTargetsByRuleOutput)
	return ret0, ret1
}

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

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

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

// PutEvents mocks base method.
func (m *MockEventBridgeAPI) PutEvents(arg0 *eventbridge.PutEventsInput) (*eventbridge.PutEventsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutEvents", arg0)
	ret0, _ := ret[0].(*eventbridge.PutEventsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// PutEventsRequest mocks base method.
func (m *MockEventBridgeAPI) PutEventsRequest(arg0 *eventbridge.PutEventsInput) (*request.Request, *eventbridge.PutEventsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutEventsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*eventbridge.PutEventsOutput)
	return ret0, ret1
}

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

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

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

// PutPartnerEvents mocks base method.
func (m *MockEventBridgeAPI) PutPartnerEvents(arg0 *eventbridge.PutPartnerEventsInput) (*eventbridge.PutPartnerEventsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutPartnerEvents", arg0)
	ret0, _ := ret[0].(*eventbridge.PutPartnerEventsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// PutPartnerEventsRequest mocks base method.
func (m *MockEventBridgeAPI) PutPartnerEventsRequest(arg0 *eventbridge.PutPartnerEventsInput) (*request.Request, *eventbridge.PutPartnerEventsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutPartnerEventsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*eventbridge.PutPartnerEventsOutput)
	return ret0, ret1
}

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

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

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

// PutPermission mocks base method.
func (m *MockEventBridgeAPI) PutPermission(arg0 *eventbridge.PutPermissionInput) (*eventbridge.PutPermissionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutPermission", arg0)
	ret0, _ := ret[0].(*eventbridge.PutPermissionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// PutPermissionRequest mocks base method.
func (m *MockEventBridgeAPI) PutPermissionRequest(arg0 *eventbridge.PutPermissionInput) (*request.Request, *eventbridge.PutPermissionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutPermissionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*eventbridge.PutPermissionOutput)
	return ret0, ret1
}

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

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

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

// PutRule mocks base method.
func (m *MockEventBridgeAPI) PutRule(arg0 *eventbridge.PutRuleInput) (*eventbridge.PutRuleOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutRule", arg0)
	ret0, _ := ret[0].(*eventbridge.PutRuleOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// PutRuleRequest mocks base method.
func (m *MockEventBridgeAPI) PutRuleRequest(arg0 *eventbridge.PutRuleInput) (*request.Request, *eventbridge.PutRuleOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutRuleRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*eventbridge.PutRuleOutput)
	return ret0, ret1
}

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

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

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

// PutTargets mocks base method.
func (m *MockEventBridgeAPI) PutTargets(arg0 *eventbridge.PutTargetsInput) (*eventbridge.PutTargetsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutTargets", arg0)
	ret0, _ := ret[0].(*eventbridge.PutTargetsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// PutTargetsRequest mocks base method.
func (m *MockEventBridgeAPI) PutTargetsRequest(arg0 *eventbridge.PutTargetsInput) (*request.Request, *eventbridge.PutTargetsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutTargetsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*eventbridge.PutTargetsOutput)
	return ret0, ret1
}

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

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

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

// RemovePermission mocks base method.
func (m *MockEventBridgeAPI) RemovePermission(arg0 *eventbridge.RemovePermissionInput) (*eventbridge.RemovePermissionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RemovePermission", arg0)
	ret0, _ := ret[0].(*eventbridge.RemovePermissionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RemovePermissionRequest mocks base method.
func (m *MockEventBridgeAPI) RemovePermissionRequest(arg0 *eventbridge.RemovePermissionInput) (*request.Request, *eventbridge.RemovePermissionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RemovePermissionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*eventbridge.RemovePermissionOutput)
	return ret0, ret1
}

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

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

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

// RemoveTargets mocks base method.
func (m *MockEventBridgeAPI) RemoveTargets(arg0 *eventbridge.RemoveTargetsInput) (*eventbridge.RemoveTargetsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RemoveTargets", arg0)
	ret0, _ := ret[0].(*eventbridge.RemoveTargetsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RemoveTargetsRequest mocks base method.
func (m *MockEventBridgeAPI) RemoveTargetsRequest(arg0 *eventbridge.RemoveTargetsInput) (*request.Request, *eventbridge.RemoveTargetsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RemoveTargetsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*eventbridge.RemoveTargetsOutput)
	return ret0, ret1
}

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

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

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

// StartReplay mocks base method.
func (m *MockEventBridgeAPI) StartReplay(arg0 *eventbridge.StartReplayInput) (*eventbridge.StartReplayOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StartReplay", arg0)
	ret0, _ := ret[0].(*eventbridge.StartReplayOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// StartReplayRequest mocks base method.
func (m *MockEventBridgeAPI) StartReplayRequest(arg0 *eventbridge.StartReplayInput) (*request.Request, *eventbridge.StartReplayOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StartReplayRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*eventbridge.StartReplayOutput)
	return ret0, ret1
}

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

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

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

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

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

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

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

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

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

// TestEventPattern mocks base method.
func (m *MockEventBridgeAPI) TestEventPattern(arg0 *eventbridge.TestEventPatternInput) (*eventbridge.TestEventPatternOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TestEventPattern", arg0)
	ret0, _ := ret[0].(*eventbridge.TestEventPatternOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// TestEventPatternRequest mocks base method.
func (m *MockEventBridgeAPI) TestEventPatternRequest(arg0 *eventbridge.TestEventPatternInput) (*request.Request, *eventbridge.TestEventPatternOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TestEventPatternRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*eventbridge.TestEventPatternOutput)
	return ret0, ret1
}

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

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

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

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

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

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

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

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

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

// UpdateApiDestination mocks base method.
func (m *MockEventBridgeAPI) UpdateApiDestination(arg0 *eventbridge.UpdateApiDestinationInput) (*eventbridge.UpdateApiDestinationOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateApiDestination", arg0)
	ret0, _ := ret[0].(*eventbridge.UpdateApiDestinationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateApiDestinationRequest mocks base method.
func (m *MockEventBridgeAPI) UpdateApiDestinationRequest(arg0 *eventbridge.UpdateApiDestinationInput) (*request.Request, *eventbridge.UpdateApiDestinationOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateApiDestinationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*eventbridge.UpdateApiDestinationOutput)
	return ret0, ret1
}

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

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

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

// UpdateArchive mocks base method.
func (m *MockEventBridgeAPI) UpdateArchive(arg0 *eventbridge.UpdateArchiveInput) (*eventbridge.UpdateArchiveOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateArchive", arg0)
	ret0, _ := ret[0].(*eventbridge.UpdateArchiveOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateArchiveRequest mocks base method.
func (m *MockEventBridgeAPI) UpdateArchiveRequest(arg0 *eventbridge.UpdateArchiveInput) (*request.Request, *eventbridge.UpdateArchiveOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateArchiveRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*eventbridge.UpdateArchiveOutput)
	return ret0, ret1
}

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

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

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

// UpdateConnection mocks base method.
func (m *MockEventBridgeAPI) UpdateConnection(arg0 *eventbridge.UpdateConnectionInput) (*eventbridge.UpdateConnectionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateConnection", arg0)
	ret0, _ := ret[0].(*eventbridge.UpdateConnectionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateConnectionRequest mocks base method.
func (m *MockEventBridgeAPI) UpdateConnectionRequest(arg0 *eventbridge.UpdateConnectionInput) (*request.Request, *eventbridge.UpdateConnectionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateConnectionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*eventbridge.UpdateConnectionOutput)
	return ret0, ret1
}

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

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

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