mock.go

// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/aws/aws-sdk-go/service/codestarconnections/codestarconnectionsiface (interfaces: CodeStarConnectionsAPI)

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

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

// MockCodeStarConnectionsAPI is a mock of CodeStarConnectionsAPI interface
type MockCodeStarConnectionsAPI struct {
	ctrl     *gomock.Controller
	recorder *MockCodeStarConnectionsAPIMockRecorder
}

// MockCodeStarConnectionsAPIMockRecorder is the mock recorder for MockCodeStarConnectionsAPI
type MockCodeStarConnectionsAPIMockRecorder struct {
	mock *MockCodeStarConnectionsAPI
}

// NewMockCodeStarConnectionsAPI creates a new mock instance
func NewMockCodeStarConnectionsAPI(ctrl *gomock.Controller) *MockCodeStarConnectionsAPI {
	mock := &MockCodeStarConnectionsAPI{ctrl: ctrl}
	mock.recorder = &MockCodeStarConnectionsAPIMockRecorder{mock}
	return mock
}

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

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

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

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

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

// CreateConnectionWithContext mocks base method
func (m *MockCodeStarConnectionsAPI) CreateConnectionWithContext(arg0 context.Context, arg1 *codestarconnections.CreateConnectionInput, arg2 ...request.Option) (*codestarconnections.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].(*codestarconnections.CreateConnectionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateHost mocks base method
func (m *MockCodeStarConnectionsAPI) CreateHost(arg0 *codestarconnections.CreateHostInput) (*codestarconnections.CreateHostOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateHost", arg0)
	ret0, _ := ret[0].(*codestarconnections.CreateHostOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateHostRequest mocks base method
func (m *MockCodeStarConnectionsAPI) CreateHostRequest(arg0 *codestarconnections.CreateHostInput) (*request.Request, *codestarconnections.CreateHostOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateHostRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*codestarconnections.CreateHostOutput)
	return ret0, ret1
}

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

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

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

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

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

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

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

// DeleteConnectionWithContext mocks base method
func (m *MockCodeStarConnectionsAPI) DeleteConnectionWithContext(arg0 context.Context, arg1 *codestarconnections.DeleteConnectionInput, arg2 ...request.Option) (*codestarconnections.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].(*codestarconnections.DeleteConnectionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteHost mocks base method
func (m *MockCodeStarConnectionsAPI) DeleteHost(arg0 *codestarconnections.DeleteHostInput) (*codestarconnections.DeleteHostOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteHost", arg0)
	ret0, _ := ret[0].(*codestarconnections.DeleteHostOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteHostRequest mocks base method
func (m *MockCodeStarConnectionsAPI) DeleteHostRequest(arg0 *codestarconnections.DeleteHostInput) (*request.Request, *codestarconnections.DeleteHostOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteHostRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*codestarconnections.DeleteHostOutput)
	return ret0, ret1
}

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

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

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

// GetConnection mocks base method
func (m *MockCodeStarConnectionsAPI) GetConnection(arg0 *codestarconnections.GetConnectionInput) (*codestarconnections.GetConnectionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetConnection", arg0)
	ret0, _ := ret[0].(*codestarconnections.GetConnectionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetConnectionRequest mocks base method
func (m *MockCodeStarConnectionsAPI) GetConnectionRequest(arg0 *codestarconnections.GetConnectionInput) (*request.Request, *codestarconnections.GetConnectionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetConnectionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*codestarconnections.GetConnectionOutput)
	return ret0, ret1
}

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

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

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

// GetHost mocks base method
func (m *MockCodeStarConnectionsAPI) GetHost(arg0 *codestarconnections.GetHostInput) (*codestarconnections.GetHostOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetHost", arg0)
	ret0, _ := ret[0].(*codestarconnections.GetHostOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetHostRequest mocks base method
func (m *MockCodeStarConnectionsAPI) GetHostRequest(arg0 *codestarconnections.GetHostInput) (*request.Request, *codestarconnections.GetHostOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetHostRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*codestarconnections.GetHostOutput)
	return ret0, ret1
}

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

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

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

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

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

// ListConnectionsPages mocks base method
func (m *MockCodeStarConnectionsAPI) ListConnectionsPages(arg0 *codestarconnections.ListConnectionsInput, arg1 func(*codestarconnections.ListConnectionsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListConnectionsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

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

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

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

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

// ListConnectionsWithContext mocks base method
func (m *MockCodeStarConnectionsAPI) ListConnectionsWithContext(arg0 context.Context, arg1 *codestarconnections.ListConnectionsInput, arg2 ...request.Option) (*codestarconnections.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].(*codestarconnections.ListConnectionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListHosts mocks base method
func (m *MockCodeStarConnectionsAPI) ListHosts(arg0 *codestarconnections.ListHostsInput) (*codestarconnections.ListHostsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListHosts", arg0)
	ret0, _ := ret[0].(*codestarconnections.ListHostsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListHostsPages mocks base method
func (m *MockCodeStarConnectionsAPI) ListHostsPages(arg0 *codestarconnections.ListHostsInput, arg1 func(*codestarconnections.ListHostsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListHostsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

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

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

// ListHostsRequest mocks base method
func (m *MockCodeStarConnectionsAPI) ListHostsRequest(arg0 *codestarconnections.ListHostsInput) (*request.Request, *codestarconnections.ListHostsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListHostsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*codestarconnections.ListHostsOutput)
	return ret0, ret1
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// UpdateHost mocks base method
func (m *MockCodeStarConnectionsAPI) UpdateHost(arg0 *codestarconnections.UpdateHostInput) (*codestarconnections.UpdateHostOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateHost", arg0)
	ret0, _ := ret[0].(*codestarconnections.UpdateHostOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateHostRequest mocks base method
func (m *MockCodeStarConnectionsAPI) UpdateHostRequest(arg0 *codestarconnections.UpdateHostInput) (*request.Request, *codestarconnections.UpdateHostOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateHostRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*codestarconnections.UpdateHostOutput)
	return ret0, ret1
}

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

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

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