mock.go

// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/aws/aws-sdk-go/service/codepipeline/codepipelineiface (interfaces: CodePipelineAPI)

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

import (
	context "context"
	reflect "reflect"

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

// MockCodePipelineAPI is a mock of CodePipelineAPI interface.
type MockCodePipelineAPI struct {
	ctrl     *gomock.Controller
	recorder *MockCodePipelineAPIMockRecorder
}

// MockCodePipelineAPIMockRecorder is the mock recorder for MockCodePipelineAPI.
type MockCodePipelineAPIMockRecorder struct {
	mock *MockCodePipelineAPI
}

// NewMockCodePipelineAPI creates a new mock instance.
func NewMockCodePipelineAPI(ctrl *gomock.Controller) *MockCodePipelineAPI {
	mock := &MockCodePipelineAPI{ctrl: ctrl}
	mock.recorder = &MockCodePipelineAPIMockRecorder{mock}
	return mock
}

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

// AcknowledgeJob mocks base method.
func (m *MockCodePipelineAPI) AcknowledgeJob(arg0 *codepipeline.AcknowledgeJobInput) (*codepipeline.AcknowledgeJobOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AcknowledgeJob", arg0)
	ret0, _ := ret[0].(*codepipeline.AcknowledgeJobOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// AcknowledgeJobRequest mocks base method.
func (m *MockCodePipelineAPI) AcknowledgeJobRequest(arg0 *codepipeline.AcknowledgeJobInput) (*request.Request, *codepipeline.AcknowledgeJobOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AcknowledgeJobRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*codepipeline.AcknowledgeJobOutput)
	return ret0, ret1
}

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

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

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

// AcknowledgeThirdPartyJob mocks base method.
func (m *MockCodePipelineAPI) AcknowledgeThirdPartyJob(arg0 *codepipeline.AcknowledgeThirdPartyJobInput) (*codepipeline.AcknowledgeThirdPartyJobOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AcknowledgeThirdPartyJob", arg0)
	ret0, _ := ret[0].(*codepipeline.AcknowledgeThirdPartyJobOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// AcknowledgeThirdPartyJobRequest mocks base method.
func (m *MockCodePipelineAPI) AcknowledgeThirdPartyJobRequest(arg0 *codepipeline.AcknowledgeThirdPartyJobInput) (*request.Request, *codepipeline.AcknowledgeThirdPartyJobOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AcknowledgeThirdPartyJobRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*codepipeline.AcknowledgeThirdPartyJobOutput)
	return ret0, ret1
}

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

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

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

// CreateCustomActionType mocks base method.
func (m *MockCodePipelineAPI) CreateCustomActionType(arg0 *codepipeline.CreateCustomActionTypeInput) (*codepipeline.CreateCustomActionTypeOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateCustomActionType", arg0)
	ret0, _ := ret[0].(*codepipeline.CreateCustomActionTypeOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateCustomActionTypeRequest mocks base method.
func (m *MockCodePipelineAPI) CreateCustomActionTypeRequest(arg0 *codepipeline.CreateCustomActionTypeInput) (*request.Request, *codepipeline.CreateCustomActionTypeOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateCustomActionTypeRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*codepipeline.CreateCustomActionTypeOutput)
	return ret0, ret1
}

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

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

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

// CreatePipeline mocks base method.
func (m *MockCodePipelineAPI) CreatePipeline(arg0 *codepipeline.CreatePipelineInput) (*codepipeline.CreatePipelineOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreatePipeline", arg0)
	ret0, _ := ret[0].(*codepipeline.CreatePipelineOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreatePipelineRequest mocks base method.
func (m *MockCodePipelineAPI) CreatePipelineRequest(arg0 *codepipeline.CreatePipelineInput) (*request.Request, *codepipeline.CreatePipelineOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreatePipelineRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*codepipeline.CreatePipelineOutput)
	return ret0, ret1
}

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

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

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

// DeleteCustomActionType mocks base method.
func (m *MockCodePipelineAPI) DeleteCustomActionType(arg0 *codepipeline.DeleteCustomActionTypeInput) (*codepipeline.DeleteCustomActionTypeOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteCustomActionType", arg0)
	ret0, _ := ret[0].(*codepipeline.DeleteCustomActionTypeOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteCustomActionTypeRequest mocks base method.
func (m *MockCodePipelineAPI) DeleteCustomActionTypeRequest(arg0 *codepipeline.DeleteCustomActionTypeInput) (*request.Request, *codepipeline.DeleteCustomActionTypeOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteCustomActionTypeRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*codepipeline.DeleteCustomActionTypeOutput)
	return ret0, ret1
}

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

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

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

// DeletePipeline mocks base method.
func (m *MockCodePipelineAPI) DeletePipeline(arg0 *codepipeline.DeletePipelineInput) (*codepipeline.DeletePipelineOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeletePipeline", arg0)
	ret0, _ := ret[0].(*codepipeline.DeletePipelineOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeletePipelineRequest mocks base method.
func (m *MockCodePipelineAPI) DeletePipelineRequest(arg0 *codepipeline.DeletePipelineInput) (*request.Request, *codepipeline.DeletePipelineOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeletePipelineRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*codepipeline.DeletePipelineOutput)
	return ret0, ret1
}

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

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

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

// DeleteWebhook mocks base method.
func (m *MockCodePipelineAPI) DeleteWebhook(arg0 *codepipeline.DeleteWebhookInput) (*codepipeline.DeleteWebhookOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteWebhook", arg0)
	ret0, _ := ret[0].(*codepipeline.DeleteWebhookOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteWebhookRequest mocks base method.
func (m *MockCodePipelineAPI) DeleteWebhookRequest(arg0 *codepipeline.DeleteWebhookInput) (*request.Request, *codepipeline.DeleteWebhookOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteWebhookRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*codepipeline.DeleteWebhookOutput)
	return ret0, ret1
}

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

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

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

// DeregisterWebhookWithThirdParty mocks base method.
func (m *MockCodePipelineAPI) DeregisterWebhookWithThirdParty(arg0 *codepipeline.DeregisterWebhookWithThirdPartyInput) (*codepipeline.DeregisterWebhookWithThirdPartyOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeregisterWebhookWithThirdParty", arg0)
	ret0, _ := ret[0].(*codepipeline.DeregisterWebhookWithThirdPartyOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeregisterWebhookWithThirdPartyRequest mocks base method.
func (m *MockCodePipelineAPI) DeregisterWebhookWithThirdPartyRequest(arg0 *codepipeline.DeregisterWebhookWithThirdPartyInput) (*request.Request, *codepipeline.DeregisterWebhookWithThirdPartyOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeregisterWebhookWithThirdPartyRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*codepipeline.DeregisterWebhookWithThirdPartyOutput)
	return ret0, ret1
}

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

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

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

// DisableStageTransition mocks base method.
func (m *MockCodePipelineAPI) DisableStageTransition(arg0 *codepipeline.DisableStageTransitionInput) (*codepipeline.DisableStageTransitionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DisableStageTransition", arg0)
	ret0, _ := ret[0].(*codepipeline.DisableStageTransitionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DisableStageTransitionRequest mocks base method.
func (m *MockCodePipelineAPI) DisableStageTransitionRequest(arg0 *codepipeline.DisableStageTransitionInput) (*request.Request, *codepipeline.DisableStageTransitionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DisableStageTransitionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*codepipeline.DisableStageTransitionOutput)
	return ret0, ret1
}

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

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

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

// EnableStageTransition mocks base method.
func (m *MockCodePipelineAPI) EnableStageTransition(arg0 *codepipeline.EnableStageTransitionInput) (*codepipeline.EnableStageTransitionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EnableStageTransition", arg0)
	ret0, _ := ret[0].(*codepipeline.EnableStageTransitionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// EnableStageTransitionRequest mocks base method.
func (m *MockCodePipelineAPI) EnableStageTransitionRequest(arg0 *codepipeline.EnableStageTransitionInput) (*request.Request, *codepipeline.EnableStageTransitionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EnableStageTransitionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*codepipeline.EnableStageTransitionOutput)
	return ret0, ret1
}

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

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

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

// GetActionType mocks base method.
func (m *MockCodePipelineAPI) GetActionType(arg0 *codepipeline.GetActionTypeInput) (*codepipeline.GetActionTypeOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetActionType", arg0)
	ret0, _ := ret[0].(*codepipeline.GetActionTypeOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetActionTypeRequest mocks base method.
func (m *MockCodePipelineAPI) GetActionTypeRequest(arg0 *codepipeline.GetActionTypeInput) (*request.Request, *codepipeline.GetActionTypeOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetActionTypeRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*codepipeline.GetActionTypeOutput)
	return ret0, ret1
}

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

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

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

// GetJobDetails mocks base method.
func (m *MockCodePipelineAPI) GetJobDetails(arg0 *codepipeline.GetJobDetailsInput) (*codepipeline.GetJobDetailsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetJobDetails", arg0)
	ret0, _ := ret[0].(*codepipeline.GetJobDetailsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetJobDetailsRequest mocks base method.
func (m *MockCodePipelineAPI) GetJobDetailsRequest(arg0 *codepipeline.GetJobDetailsInput) (*request.Request, *codepipeline.GetJobDetailsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetJobDetailsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*codepipeline.GetJobDetailsOutput)
	return ret0, ret1
}

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

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

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

// GetPipeline mocks base method.
func (m *MockCodePipelineAPI) GetPipeline(arg0 *codepipeline.GetPipelineInput) (*codepipeline.GetPipelineOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPipeline", arg0)
	ret0, _ := ret[0].(*codepipeline.GetPipelineOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetPipelineExecution mocks base method.
func (m *MockCodePipelineAPI) GetPipelineExecution(arg0 *codepipeline.GetPipelineExecutionInput) (*codepipeline.GetPipelineExecutionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPipelineExecution", arg0)
	ret0, _ := ret[0].(*codepipeline.GetPipelineExecutionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetPipelineExecutionRequest mocks base method.
func (m *MockCodePipelineAPI) GetPipelineExecutionRequest(arg0 *codepipeline.GetPipelineExecutionInput) (*request.Request, *codepipeline.GetPipelineExecutionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPipelineExecutionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*codepipeline.GetPipelineExecutionOutput)
	return ret0, ret1
}

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

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

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

// GetPipelineRequest mocks base method.
func (m *MockCodePipelineAPI) GetPipelineRequest(arg0 *codepipeline.GetPipelineInput) (*request.Request, *codepipeline.GetPipelineOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPipelineRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*codepipeline.GetPipelineOutput)
	return ret0, ret1
}

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

// GetPipelineState mocks base method.
func (m *MockCodePipelineAPI) GetPipelineState(arg0 *codepipeline.GetPipelineStateInput) (*codepipeline.GetPipelineStateOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPipelineState", arg0)
	ret0, _ := ret[0].(*codepipeline.GetPipelineStateOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetPipelineStateRequest mocks base method.
func (m *MockCodePipelineAPI) GetPipelineStateRequest(arg0 *codepipeline.GetPipelineStateInput) (*request.Request, *codepipeline.GetPipelineStateOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPipelineStateRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*codepipeline.GetPipelineStateOutput)
	return ret0, ret1
}

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

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

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

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

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

// GetThirdPartyJobDetails mocks base method.
func (m *MockCodePipelineAPI) GetThirdPartyJobDetails(arg0 *codepipeline.GetThirdPartyJobDetailsInput) (*codepipeline.GetThirdPartyJobDetailsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetThirdPartyJobDetails", arg0)
	ret0, _ := ret[0].(*codepipeline.GetThirdPartyJobDetailsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetThirdPartyJobDetailsRequest mocks base method.
func (m *MockCodePipelineAPI) GetThirdPartyJobDetailsRequest(arg0 *codepipeline.GetThirdPartyJobDetailsInput) (*request.Request, *codepipeline.GetThirdPartyJobDetailsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetThirdPartyJobDetailsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*codepipeline.GetThirdPartyJobDetailsOutput)
	return ret0, ret1
}

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

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

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

// ListActionExecutions mocks base method.
func (m *MockCodePipelineAPI) ListActionExecutions(arg0 *codepipeline.ListActionExecutionsInput) (*codepipeline.ListActionExecutionsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListActionExecutions", arg0)
	ret0, _ := ret[0].(*codepipeline.ListActionExecutionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListActionExecutionsPages mocks base method.
func (m *MockCodePipelineAPI) ListActionExecutionsPages(arg0 *codepipeline.ListActionExecutionsInput, arg1 func(*codepipeline.ListActionExecutionsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListActionExecutionsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListActionExecutionsPagesWithContext mocks base method.
func (m *MockCodePipelineAPI) ListActionExecutionsPagesWithContext(arg0 context.Context, arg1 *codepipeline.ListActionExecutionsInput, arg2 func(*codepipeline.ListActionExecutionsOutput, 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, "ListActionExecutionsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListActionExecutionsRequest mocks base method.
func (m *MockCodePipelineAPI) ListActionExecutionsRequest(arg0 *codepipeline.ListActionExecutionsInput) (*request.Request, *codepipeline.ListActionExecutionsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListActionExecutionsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*codepipeline.ListActionExecutionsOutput)
	return ret0, ret1
}

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

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

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

// ListActionTypes mocks base method.
func (m *MockCodePipelineAPI) ListActionTypes(arg0 *codepipeline.ListActionTypesInput) (*codepipeline.ListActionTypesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListActionTypes", arg0)
	ret0, _ := ret[0].(*codepipeline.ListActionTypesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListActionTypesPages mocks base method.
func (m *MockCodePipelineAPI) ListActionTypesPages(arg0 *codepipeline.ListActionTypesInput, arg1 func(*codepipeline.ListActionTypesOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListActionTypesPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListActionTypesPagesWithContext mocks base method.
func (m *MockCodePipelineAPI) ListActionTypesPagesWithContext(arg0 context.Context, arg1 *codepipeline.ListActionTypesInput, arg2 func(*codepipeline.ListActionTypesOutput, 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, "ListActionTypesPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListActionTypesRequest mocks base method.
func (m *MockCodePipelineAPI) ListActionTypesRequest(arg0 *codepipeline.ListActionTypesInput) (*request.Request, *codepipeline.ListActionTypesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListActionTypesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*codepipeline.ListActionTypesOutput)
	return ret0, ret1
}

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

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

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

// ListPipelineExecutions mocks base method.
func (m *MockCodePipelineAPI) ListPipelineExecutions(arg0 *codepipeline.ListPipelineExecutionsInput) (*codepipeline.ListPipelineExecutionsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListPipelineExecutions", arg0)
	ret0, _ := ret[0].(*codepipeline.ListPipelineExecutionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListPipelineExecutionsPages mocks base method.
func (m *MockCodePipelineAPI) ListPipelineExecutionsPages(arg0 *codepipeline.ListPipelineExecutionsInput, arg1 func(*codepipeline.ListPipelineExecutionsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListPipelineExecutionsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListPipelineExecutionsPagesWithContext mocks base method.
func (m *MockCodePipelineAPI) ListPipelineExecutionsPagesWithContext(arg0 context.Context, arg1 *codepipeline.ListPipelineExecutionsInput, arg2 func(*codepipeline.ListPipelineExecutionsOutput, 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, "ListPipelineExecutionsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListPipelineExecutionsRequest mocks base method.
func (m *MockCodePipelineAPI) ListPipelineExecutionsRequest(arg0 *codepipeline.ListPipelineExecutionsInput) (*request.Request, *codepipeline.ListPipelineExecutionsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListPipelineExecutionsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*codepipeline.ListPipelineExecutionsOutput)
	return ret0, ret1
}

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

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

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

// ListPipelines mocks base method.
func (m *MockCodePipelineAPI) ListPipelines(arg0 *codepipeline.ListPipelinesInput) (*codepipeline.ListPipelinesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListPipelines", arg0)
	ret0, _ := ret[0].(*codepipeline.ListPipelinesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListPipelinesPages mocks base method.
func (m *MockCodePipelineAPI) ListPipelinesPages(arg0 *codepipeline.ListPipelinesInput, arg1 func(*codepipeline.ListPipelinesOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListPipelinesPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListPipelinesPagesWithContext mocks base method.
func (m *MockCodePipelineAPI) ListPipelinesPagesWithContext(arg0 context.Context, arg1 *codepipeline.ListPipelinesInput, arg2 func(*codepipeline.ListPipelinesOutput, 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, "ListPipelinesPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListPipelinesRequest mocks base method.
func (m *MockCodePipelineAPI) ListPipelinesRequest(arg0 *codepipeline.ListPipelinesInput) (*request.Request, *codepipeline.ListPipelinesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListPipelinesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*codepipeline.ListPipelinesOutput)
	return ret0, ret1
}

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

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

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

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

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

// ListTagsForResourcePages mocks base method.
func (m *MockCodePipelineAPI) ListTagsForResourcePages(arg0 *codepipeline.ListTagsForResourceInput, arg1 func(*codepipeline.ListTagsForResourceOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListTagsForResourcePages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListTagsForResourcePagesWithContext mocks base method.
func (m *MockCodePipelineAPI) ListTagsForResourcePagesWithContext(arg0 context.Context, arg1 *codepipeline.ListTagsForResourceInput, arg2 func(*codepipeline.ListTagsForResourceOutput, 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, "ListTagsForResourcePagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

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

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

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

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

// ListWebhooks mocks base method.
func (m *MockCodePipelineAPI) ListWebhooks(arg0 *codepipeline.ListWebhooksInput) (*codepipeline.ListWebhooksOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListWebhooks", arg0)
	ret0, _ := ret[0].(*codepipeline.ListWebhooksOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListWebhooksPages mocks base method.
func (m *MockCodePipelineAPI) ListWebhooksPages(arg0 *codepipeline.ListWebhooksInput, arg1 func(*codepipeline.ListWebhooksOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListWebhooksPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListWebhooksPagesWithContext mocks base method.
func (m *MockCodePipelineAPI) ListWebhooksPagesWithContext(arg0 context.Context, arg1 *codepipeline.ListWebhooksInput, arg2 func(*codepipeline.ListWebhooksOutput, 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, "ListWebhooksPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListWebhooksRequest mocks base method.
func (m *MockCodePipelineAPI) ListWebhooksRequest(arg0 *codepipeline.ListWebhooksInput) (*request.Request, *codepipeline.ListWebhooksOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListWebhooksRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*codepipeline.ListWebhooksOutput)
	return ret0, ret1
}

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

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

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

// PollForJobs mocks base method.
func (m *MockCodePipelineAPI) PollForJobs(arg0 *codepipeline.PollForJobsInput) (*codepipeline.PollForJobsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PollForJobs", arg0)
	ret0, _ := ret[0].(*codepipeline.PollForJobsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// PollForJobsRequest mocks base method.
func (m *MockCodePipelineAPI) PollForJobsRequest(arg0 *codepipeline.PollForJobsInput) (*request.Request, *codepipeline.PollForJobsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PollForJobsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*codepipeline.PollForJobsOutput)
	return ret0, ret1
}

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

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

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

// PollForThirdPartyJobs mocks base method.
func (m *MockCodePipelineAPI) PollForThirdPartyJobs(arg0 *codepipeline.PollForThirdPartyJobsInput) (*codepipeline.PollForThirdPartyJobsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PollForThirdPartyJobs", arg0)
	ret0, _ := ret[0].(*codepipeline.PollForThirdPartyJobsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// PollForThirdPartyJobsRequest mocks base method.
func (m *MockCodePipelineAPI) PollForThirdPartyJobsRequest(arg0 *codepipeline.PollForThirdPartyJobsInput) (*request.Request, *codepipeline.PollForThirdPartyJobsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PollForThirdPartyJobsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*codepipeline.PollForThirdPartyJobsOutput)
	return ret0, ret1
}

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

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

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

// PutActionRevision mocks base method.
func (m *MockCodePipelineAPI) PutActionRevision(arg0 *codepipeline.PutActionRevisionInput) (*codepipeline.PutActionRevisionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutActionRevision", arg0)
	ret0, _ := ret[0].(*codepipeline.PutActionRevisionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// PutActionRevisionRequest mocks base method.
func (m *MockCodePipelineAPI) PutActionRevisionRequest(arg0 *codepipeline.PutActionRevisionInput) (*request.Request, *codepipeline.PutActionRevisionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutActionRevisionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*codepipeline.PutActionRevisionOutput)
	return ret0, ret1
}

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

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

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

// PutApprovalResult mocks base method.
func (m *MockCodePipelineAPI) PutApprovalResult(arg0 *codepipeline.PutApprovalResultInput) (*codepipeline.PutApprovalResultOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutApprovalResult", arg0)
	ret0, _ := ret[0].(*codepipeline.PutApprovalResultOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// PutApprovalResultRequest mocks base method.
func (m *MockCodePipelineAPI) PutApprovalResultRequest(arg0 *codepipeline.PutApprovalResultInput) (*request.Request, *codepipeline.PutApprovalResultOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutApprovalResultRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*codepipeline.PutApprovalResultOutput)
	return ret0, ret1
}

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

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

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

// PutJobFailureResult mocks base method.
func (m *MockCodePipelineAPI) PutJobFailureResult(arg0 *codepipeline.PutJobFailureResultInput) (*codepipeline.PutJobFailureResultOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutJobFailureResult", arg0)
	ret0, _ := ret[0].(*codepipeline.PutJobFailureResultOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// PutJobFailureResultRequest mocks base method.
func (m *MockCodePipelineAPI) PutJobFailureResultRequest(arg0 *codepipeline.PutJobFailureResultInput) (*request.Request, *codepipeline.PutJobFailureResultOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutJobFailureResultRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*codepipeline.PutJobFailureResultOutput)
	return ret0, ret1
}

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

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

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

// PutJobSuccessResult mocks base method.
func (m *MockCodePipelineAPI) PutJobSuccessResult(arg0 *codepipeline.PutJobSuccessResultInput) (*codepipeline.PutJobSuccessResultOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutJobSuccessResult", arg0)
	ret0, _ := ret[0].(*codepipeline.PutJobSuccessResultOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// PutJobSuccessResultRequest mocks base method.
func (m *MockCodePipelineAPI) PutJobSuccessResultRequest(arg0 *codepipeline.PutJobSuccessResultInput) (*request.Request, *codepipeline.PutJobSuccessResultOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutJobSuccessResultRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*codepipeline.PutJobSuccessResultOutput)
	return ret0, ret1
}

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

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

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

// PutThirdPartyJobFailureResult mocks base method.
func (m *MockCodePipelineAPI) PutThirdPartyJobFailureResult(arg0 *codepipeline.PutThirdPartyJobFailureResultInput) (*codepipeline.PutThirdPartyJobFailureResultOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutThirdPartyJobFailureResult", arg0)
	ret0, _ := ret[0].(*codepipeline.PutThirdPartyJobFailureResultOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// PutThirdPartyJobFailureResultRequest mocks base method.
func (m *MockCodePipelineAPI) PutThirdPartyJobFailureResultRequest(arg0 *codepipeline.PutThirdPartyJobFailureResultInput) (*request.Request, *codepipeline.PutThirdPartyJobFailureResultOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutThirdPartyJobFailureResultRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*codepipeline.PutThirdPartyJobFailureResultOutput)
	return ret0, ret1
}

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

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

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

// PutThirdPartyJobSuccessResult mocks base method.
func (m *MockCodePipelineAPI) PutThirdPartyJobSuccessResult(arg0 *codepipeline.PutThirdPartyJobSuccessResultInput) (*codepipeline.PutThirdPartyJobSuccessResultOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutThirdPartyJobSuccessResult", arg0)
	ret0, _ := ret[0].(*codepipeline.PutThirdPartyJobSuccessResultOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// PutThirdPartyJobSuccessResultRequest mocks base method.
func (m *MockCodePipelineAPI) PutThirdPartyJobSuccessResultRequest(arg0 *codepipeline.PutThirdPartyJobSuccessResultInput) (*request.Request, *codepipeline.PutThirdPartyJobSuccessResultOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutThirdPartyJobSuccessResultRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*codepipeline.PutThirdPartyJobSuccessResultOutput)
	return ret0, ret1
}

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

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

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

// PutWebhook mocks base method.
func (m *MockCodePipelineAPI) PutWebhook(arg0 *codepipeline.PutWebhookInput) (*codepipeline.PutWebhookOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutWebhook", arg0)
	ret0, _ := ret[0].(*codepipeline.PutWebhookOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// PutWebhookRequest mocks base method.
func (m *MockCodePipelineAPI) PutWebhookRequest(arg0 *codepipeline.PutWebhookInput) (*request.Request, *codepipeline.PutWebhookOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutWebhookRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*codepipeline.PutWebhookOutput)
	return ret0, ret1
}

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

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

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

// RegisterWebhookWithThirdParty mocks base method.
func (m *MockCodePipelineAPI) RegisterWebhookWithThirdParty(arg0 *codepipeline.RegisterWebhookWithThirdPartyInput) (*codepipeline.RegisterWebhookWithThirdPartyOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RegisterWebhookWithThirdParty", arg0)
	ret0, _ := ret[0].(*codepipeline.RegisterWebhookWithThirdPartyOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RegisterWebhookWithThirdPartyRequest mocks base method.
func (m *MockCodePipelineAPI) RegisterWebhookWithThirdPartyRequest(arg0 *codepipeline.RegisterWebhookWithThirdPartyInput) (*request.Request, *codepipeline.RegisterWebhookWithThirdPartyOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RegisterWebhookWithThirdPartyRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*codepipeline.RegisterWebhookWithThirdPartyOutput)
	return ret0, ret1
}

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

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

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

// RetryStageExecution mocks base method.
func (m *MockCodePipelineAPI) RetryStageExecution(arg0 *codepipeline.RetryStageExecutionInput) (*codepipeline.RetryStageExecutionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RetryStageExecution", arg0)
	ret0, _ := ret[0].(*codepipeline.RetryStageExecutionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RetryStageExecutionRequest mocks base method.
func (m *MockCodePipelineAPI) RetryStageExecutionRequest(arg0 *codepipeline.RetryStageExecutionInput) (*request.Request, *codepipeline.RetryStageExecutionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RetryStageExecutionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*codepipeline.RetryStageExecutionOutput)
	return ret0, ret1
}

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

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

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

// StartPipelineExecution mocks base method.
func (m *MockCodePipelineAPI) StartPipelineExecution(arg0 *codepipeline.StartPipelineExecutionInput) (*codepipeline.StartPipelineExecutionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StartPipelineExecution", arg0)
	ret0, _ := ret[0].(*codepipeline.StartPipelineExecutionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// StartPipelineExecutionRequest mocks base method.
func (m *MockCodePipelineAPI) StartPipelineExecutionRequest(arg0 *codepipeline.StartPipelineExecutionInput) (*request.Request, *codepipeline.StartPipelineExecutionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StartPipelineExecutionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*codepipeline.StartPipelineExecutionOutput)
	return ret0, ret1
}

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

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

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

// StopPipelineExecution mocks base method.
func (m *MockCodePipelineAPI) StopPipelineExecution(arg0 *codepipeline.StopPipelineExecutionInput) (*codepipeline.StopPipelineExecutionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StopPipelineExecution", arg0)
	ret0, _ := ret[0].(*codepipeline.StopPipelineExecutionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// StopPipelineExecutionRequest mocks base method.
func (m *MockCodePipelineAPI) StopPipelineExecutionRequest(arg0 *codepipeline.StopPipelineExecutionInput) (*request.Request, *codepipeline.StopPipelineExecutionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StopPipelineExecutionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*codepipeline.StopPipelineExecutionOutput)
	return ret0, ret1
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// UpdateActionType mocks base method.
func (m *MockCodePipelineAPI) UpdateActionType(arg0 *codepipeline.UpdateActionTypeInput) (*codepipeline.UpdateActionTypeOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateActionType", arg0)
	ret0, _ := ret[0].(*codepipeline.UpdateActionTypeOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateActionTypeRequest mocks base method.
func (m *MockCodePipelineAPI) UpdateActionTypeRequest(arg0 *codepipeline.UpdateActionTypeInput) (*request.Request, *codepipeline.UpdateActionTypeOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateActionTypeRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*codepipeline.UpdateActionTypeOutput)
	return ret0, ret1
}

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

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

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

// UpdatePipeline mocks base method.
func (m *MockCodePipelineAPI) UpdatePipeline(arg0 *codepipeline.UpdatePipelineInput) (*codepipeline.UpdatePipelineOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdatePipeline", arg0)
	ret0, _ := ret[0].(*codepipeline.UpdatePipelineOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdatePipelineRequest mocks base method.
func (m *MockCodePipelineAPI) UpdatePipelineRequest(arg0 *codepipeline.UpdatePipelineInput) (*request.Request, *codepipeline.UpdatePipelineOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdatePipelineRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*codepipeline.UpdatePipelineOutput)
	return ret0, ret1
}

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

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

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