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

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

import (
	reflect "reflect"

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

// MockSageMakerAPI is a mock of SageMakerAPI interface.
type MockSageMakerAPI struct {
	ctrl     *gomock.Controller
	recorder *MockSageMakerAPIMockRecorder
}

// MockSageMakerAPIMockRecorder is the mock recorder for MockSageMakerAPI.
type MockSageMakerAPIMockRecorder struct {
	mock *MockSageMakerAPI
}

// NewMockSageMakerAPI creates a new mock instance.
func NewMockSageMakerAPI(ctrl *gomock.Controller) *MockSageMakerAPI {
	mock := &MockSageMakerAPI{ctrl: ctrl}
	mock.recorder = &MockSageMakerAPIMockRecorder{mock}
	return mock
}

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

// AddAssociation mocks base method.
func (m *MockSageMakerAPI) AddAssociation(arg0 *sagemaker.AddAssociationInput) (*sagemaker.AddAssociationOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddAssociation", arg0)
	ret0, _ := ret[0].(*sagemaker.AddAssociationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// AddAssociationRequest mocks base method.
func (m *MockSageMakerAPI) AddAssociationRequest(arg0 *sagemaker.AddAssociationInput) (*request.Request, *sagemaker.AddAssociationOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddAssociationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.AddAssociationOutput)
	return ret0, ret1
}

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

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

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

// AddTags mocks base method.
func (m *MockSageMakerAPI) AddTags(arg0 *sagemaker.AddTagsInput) (*sagemaker.AddTagsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddTags", arg0)
	ret0, _ := ret[0].(*sagemaker.AddTagsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// AddTagsRequest mocks base method.
func (m *MockSageMakerAPI) AddTagsRequest(arg0 *sagemaker.AddTagsInput) (*request.Request, *sagemaker.AddTagsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddTagsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.AddTagsOutput)
	return ret0, ret1
}

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

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

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

// AssociateTrialComponent mocks base method.
func (m *MockSageMakerAPI) AssociateTrialComponent(arg0 *sagemaker.AssociateTrialComponentInput) (*sagemaker.AssociateTrialComponentOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AssociateTrialComponent", arg0)
	ret0, _ := ret[0].(*sagemaker.AssociateTrialComponentOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// AssociateTrialComponentRequest mocks base method.
func (m *MockSageMakerAPI) AssociateTrialComponentRequest(arg0 *sagemaker.AssociateTrialComponentInput) (*request.Request, *sagemaker.AssociateTrialComponentOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AssociateTrialComponentRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.AssociateTrialComponentOutput)
	return ret0, ret1
}

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

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

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

// BatchDescribeModelPackage mocks base method.
func (m *MockSageMakerAPI) BatchDescribeModelPackage(arg0 *sagemaker.BatchDescribeModelPackageInput) (*sagemaker.BatchDescribeModelPackageOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BatchDescribeModelPackage", arg0)
	ret0, _ := ret[0].(*sagemaker.BatchDescribeModelPackageOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// BatchDescribeModelPackageRequest mocks base method.
func (m *MockSageMakerAPI) BatchDescribeModelPackageRequest(arg0 *sagemaker.BatchDescribeModelPackageInput) (*request.Request, *sagemaker.BatchDescribeModelPackageOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BatchDescribeModelPackageRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.BatchDescribeModelPackageOutput)
	return ret0, ret1
}

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

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

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

// CreateAction mocks base method.
func (m *MockSageMakerAPI) CreateAction(arg0 *sagemaker.CreateActionInput) (*sagemaker.CreateActionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateAction", arg0)
	ret0, _ := ret[0].(*sagemaker.CreateActionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateActionRequest mocks base method.
func (m *MockSageMakerAPI) CreateActionRequest(arg0 *sagemaker.CreateActionInput) (*request.Request, *sagemaker.CreateActionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateActionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.CreateActionOutput)
	return ret0, ret1
}

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

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

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

// CreateAlgorithm mocks base method.
func (m *MockSageMakerAPI) CreateAlgorithm(arg0 *sagemaker.CreateAlgorithmInput) (*sagemaker.CreateAlgorithmOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateAlgorithm", arg0)
	ret0, _ := ret[0].(*sagemaker.CreateAlgorithmOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateAlgorithmRequest mocks base method.
func (m *MockSageMakerAPI) CreateAlgorithmRequest(arg0 *sagemaker.CreateAlgorithmInput) (*request.Request, *sagemaker.CreateAlgorithmOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateAlgorithmRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.CreateAlgorithmOutput)
	return ret0, ret1
}

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

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

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

// CreateApp mocks base method.
func (m *MockSageMakerAPI) CreateApp(arg0 *sagemaker.CreateAppInput) (*sagemaker.CreateAppOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateApp", arg0)
	ret0, _ := ret[0].(*sagemaker.CreateAppOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateAppImageConfig mocks base method.
func (m *MockSageMakerAPI) CreateAppImageConfig(arg0 *sagemaker.CreateAppImageConfigInput) (*sagemaker.CreateAppImageConfigOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateAppImageConfig", arg0)
	ret0, _ := ret[0].(*sagemaker.CreateAppImageConfigOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateAppImageConfigRequest mocks base method.
func (m *MockSageMakerAPI) CreateAppImageConfigRequest(arg0 *sagemaker.CreateAppImageConfigInput) (*request.Request, *sagemaker.CreateAppImageConfigOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateAppImageConfigRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.CreateAppImageConfigOutput)
	return ret0, ret1
}

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

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

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

// CreateAppRequest mocks base method.
func (m *MockSageMakerAPI) CreateAppRequest(arg0 *sagemaker.CreateAppInput) (*request.Request, *sagemaker.CreateAppOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateAppRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.CreateAppOutput)
	return ret0, ret1
}

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

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

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

// CreateArtifact mocks base method.
func (m *MockSageMakerAPI) CreateArtifact(arg0 *sagemaker.CreateArtifactInput) (*sagemaker.CreateArtifactOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateArtifact", arg0)
	ret0, _ := ret[0].(*sagemaker.CreateArtifactOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateArtifactRequest mocks base method.
func (m *MockSageMakerAPI) CreateArtifactRequest(arg0 *sagemaker.CreateArtifactInput) (*request.Request, *sagemaker.CreateArtifactOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateArtifactRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.CreateArtifactOutput)
	return ret0, ret1
}

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

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

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

// CreateAutoMLJob mocks base method.
func (m *MockSageMakerAPI) CreateAutoMLJob(arg0 *sagemaker.CreateAutoMLJobInput) (*sagemaker.CreateAutoMLJobOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateAutoMLJob", arg0)
	ret0, _ := ret[0].(*sagemaker.CreateAutoMLJobOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateAutoMLJobRequest mocks base method.
func (m *MockSageMakerAPI) CreateAutoMLJobRequest(arg0 *sagemaker.CreateAutoMLJobInput) (*request.Request, *sagemaker.CreateAutoMLJobOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateAutoMLJobRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.CreateAutoMLJobOutput)
	return ret0, ret1
}

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

// CreateAutoMLJobV2 mocks base method.
func (m *MockSageMakerAPI) CreateAutoMLJobV2(arg0 *sagemaker.CreateAutoMLJobV2Input) (*sagemaker.CreateAutoMLJobV2Output, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateAutoMLJobV2", arg0)
	ret0, _ := ret[0].(*sagemaker.CreateAutoMLJobV2Output)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateAutoMLJobV2Request mocks base method.
func (m *MockSageMakerAPI) CreateAutoMLJobV2Request(arg0 *sagemaker.CreateAutoMLJobV2Input) (*request.Request, *sagemaker.CreateAutoMLJobV2Output) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateAutoMLJobV2Request", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.CreateAutoMLJobV2Output)
	return ret0, ret1
}

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

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

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

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

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

// CreateCluster mocks base method.
func (m *MockSageMakerAPI) CreateCluster(arg0 *sagemaker.CreateClusterInput) (*sagemaker.CreateClusterOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateCluster", arg0)
	ret0, _ := ret[0].(*sagemaker.CreateClusterOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateClusterRequest mocks base method.
func (m *MockSageMakerAPI) CreateClusterRequest(arg0 *sagemaker.CreateClusterInput) (*request.Request, *sagemaker.CreateClusterOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateClusterRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.CreateClusterOutput)
	return ret0, ret1
}

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

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

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

// CreateCodeRepository mocks base method.
func (m *MockSageMakerAPI) CreateCodeRepository(arg0 *sagemaker.CreateCodeRepositoryInput) (*sagemaker.CreateCodeRepositoryOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateCodeRepository", arg0)
	ret0, _ := ret[0].(*sagemaker.CreateCodeRepositoryOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateCodeRepositoryRequest mocks base method.
func (m *MockSageMakerAPI) CreateCodeRepositoryRequest(arg0 *sagemaker.CreateCodeRepositoryInput) (*request.Request, *sagemaker.CreateCodeRepositoryOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateCodeRepositoryRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.CreateCodeRepositoryOutput)
	return ret0, ret1
}

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

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

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

// CreateCompilationJob mocks base method.
func (m *MockSageMakerAPI) CreateCompilationJob(arg0 *sagemaker.CreateCompilationJobInput) (*sagemaker.CreateCompilationJobOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateCompilationJob", arg0)
	ret0, _ := ret[0].(*sagemaker.CreateCompilationJobOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateCompilationJobRequest mocks base method.
func (m *MockSageMakerAPI) CreateCompilationJobRequest(arg0 *sagemaker.CreateCompilationJobInput) (*request.Request, *sagemaker.CreateCompilationJobOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateCompilationJobRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.CreateCompilationJobOutput)
	return ret0, ret1
}

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

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

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

// CreateContext mocks base method.
func (m *MockSageMakerAPI) CreateContext(arg0 *sagemaker.CreateContextInput) (*sagemaker.CreateContextOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateContext", arg0)
	ret0, _ := ret[0].(*sagemaker.CreateContextOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateContextRequest mocks base method.
func (m *MockSageMakerAPI) CreateContextRequest(arg0 *sagemaker.CreateContextInput) (*request.Request, *sagemaker.CreateContextOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateContextRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.CreateContextOutput)
	return ret0, ret1
}

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

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

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

// CreateDataQualityJobDefinition mocks base method.
func (m *MockSageMakerAPI) CreateDataQualityJobDefinition(arg0 *sagemaker.CreateDataQualityJobDefinitionInput) (*sagemaker.CreateDataQualityJobDefinitionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateDataQualityJobDefinition", arg0)
	ret0, _ := ret[0].(*sagemaker.CreateDataQualityJobDefinitionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateDataQualityJobDefinitionRequest mocks base method.
func (m *MockSageMakerAPI) CreateDataQualityJobDefinitionRequest(arg0 *sagemaker.CreateDataQualityJobDefinitionInput) (*request.Request, *sagemaker.CreateDataQualityJobDefinitionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateDataQualityJobDefinitionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.CreateDataQualityJobDefinitionOutput)
	return ret0, ret1
}

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

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

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

// CreateDeviceFleet mocks base method.
func (m *MockSageMakerAPI) CreateDeviceFleet(arg0 *sagemaker.CreateDeviceFleetInput) (*sagemaker.CreateDeviceFleetOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateDeviceFleet", arg0)
	ret0, _ := ret[0].(*sagemaker.CreateDeviceFleetOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateDeviceFleetRequest mocks base method.
func (m *MockSageMakerAPI) CreateDeviceFleetRequest(arg0 *sagemaker.CreateDeviceFleetInput) (*request.Request, *sagemaker.CreateDeviceFleetOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateDeviceFleetRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.CreateDeviceFleetOutput)
	return ret0, ret1
}

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

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

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

// CreateDomain mocks base method.
func (m *MockSageMakerAPI) CreateDomain(arg0 *sagemaker.CreateDomainInput) (*sagemaker.CreateDomainOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateDomain", arg0)
	ret0, _ := ret[0].(*sagemaker.CreateDomainOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateDomainRequest mocks base method.
func (m *MockSageMakerAPI) CreateDomainRequest(arg0 *sagemaker.CreateDomainInput) (*request.Request, *sagemaker.CreateDomainOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateDomainRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.CreateDomainOutput)
	return ret0, ret1
}

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

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

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

// CreateEdgeDeploymentPlan mocks base method.
func (m *MockSageMakerAPI) CreateEdgeDeploymentPlan(arg0 *sagemaker.CreateEdgeDeploymentPlanInput) (*sagemaker.CreateEdgeDeploymentPlanOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateEdgeDeploymentPlan", arg0)
	ret0, _ := ret[0].(*sagemaker.CreateEdgeDeploymentPlanOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateEdgeDeploymentPlanRequest mocks base method.
func (m *MockSageMakerAPI) CreateEdgeDeploymentPlanRequest(arg0 *sagemaker.CreateEdgeDeploymentPlanInput) (*request.Request, *sagemaker.CreateEdgeDeploymentPlanOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateEdgeDeploymentPlanRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.CreateEdgeDeploymentPlanOutput)
	return ret0, ret1
}

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

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

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

// CreateEdgeDeploymentStage mocks base method.
func (m *MockSageMakerAPI) CreateEdgeDeploymentStage(arg0 *sagemaker.CreateEdgeDeploymentStageInput) (*sagemaker.CreateEdgeDeploymentStageOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateEdgeDeploymentStage", arg0)
	ret0, _ := ret[0].(*sagemaker.CreateEdgeDeploymentStageOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateEdgeDeploymentStageRequest mocks base method.
func (m *MockSageMakerAPI) CreateEdgeDeploymentStageRequest(arg0 *sagemaker.CreateEdgeDeploymentStageInput) (*request.Request, *sagemaker.CreateEdgeDeploymentStageOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateEdgeDeploymentStageRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.CreateEdgeDeploymentStageOutput)
	return ret0, ret1
}

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

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

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

// CreateEdgePackagingJob mocks base method.
func (m *MockSageMakerAPI) CreateEdgePackagingJob(arg0 *sagemaker.CreateEdgePackagingJobInput) (*sagemaker.CreateEdgePackagingJobOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateEdgePackagingJob", arg0)
	ret0, _ := ret[0].(*sagemaker.CreateEdgePackagingJobOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateEdgePackagingJobRequest mocks base method.
func (m *MockSageMakerAPI) CreateEdgePackagingJobRequest(arg0 *sagemaker.CreateEdgePackagingJobInput) (*request.Request, *sagemaker.CreateEdgePackagingJobOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateEdgePackagingJobRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.CreateEdgePackagingJobOutput)
	return ret0, ret1
}

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

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

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

// CreateEndpoint mocks base method.
func (m *MockSageMakerAPI) CreateEndpoint(arg0 *sagemaker.CreateEndpointInput) (*sagemaker.CreateEndpointOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateEndpoint", arg0)
	ret0, _ := ret[0].(*sagemaker.CreateEndpointOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateEndpointConfig mocks base method.
func (m *MockSageMakerAPI) CreateEndpointConfig(arg0 *sagemaker.CreateEndpointConfigInput) (*sagemaker.CreateEndpointConfigOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateEndpointConfig", arg0)
	ret0, _ := ret[0].(*sagemaker.CreateEndpointConfigOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateEndpointConfigRequest mocks base method.
func (m *MockSageMakerAPI) CreateEndpointConfigRequest(arg0 *sagemaker.CreateEndpointConfigInput) (*request.Request, *sagemaker.CreateEndpointConfigOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateEndpointConfigRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.CreateEndpointConfigOutput)
	return ret0, ret1
}

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

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

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

// CreateEndpointRequest mocks base method.
func (m *MockSageMakerAPI) CreateEndpointRequest(arg0 *sagemaker.CreateEndpointInput) (*request.Request, *sagemaker.CreateEndpointOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateEndpointRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.CreateEndpointOutput)
	return ret0, ret1
}

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

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

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

// CreateExperiment mocks base method.
func (m *MockSageMakerAPI) CreateExperiment(arg0 *sagemaker.CreateExperimentInput) (*sagemaker.CreateExperimentOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateExperiment", arg0)
	ret0, _ := ret[0].(*sagemaker.CreateExperimentOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateExperimentRequest mocks base method.
func (m *MockSageMakerAPI) CreateExperimentRequest(arg0 *sagemaker.CreateExperimentInput) (*request.Request, *sagemaker.CreateExperimentOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateExperimentRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.CreateExperimentOutput)
	return ret0, ret1
}

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

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

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

// CreateFeatureGroup mocks base method.
func (m *MockSageMakerAPI) CreateFeatureGroup(arg0 *sagemaker.CreateFeatureGroupInput) (*sagemaker.CreateFeatureGroupOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateFeatureGroup", arg0)
	ret0, _ := ret[0].(*sagemaker.CreateFeatureGroupOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateFeatureGroupRequest mocks base method.
func (m *MockSageMakerAPI) CreateFeatureGroupRequest(arg0 *sagemaker.CreateFeatureGroupInput) (*request.Request, *sagemaker.CreateFeatureGroupOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateFeatureGroupRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.CreateFeatureGroupOutput)
	return ret0, ret1
}

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

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

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

// CreateFlowDefinition mocks base method.
func (m *MockSageMakerAPI) CreateFlowDefinition(arg0 *sagemaker.CreateFlowDefinitionInput) (*sagemaker.CreateFlowDefinitionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateFlowDefinition", arg0)
	ret0, _ := ret[0].(*sagemaker.CreateFlowDefinitionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateFlowDefinitionRequest mocks base method.
func (m *MockSageMakerAPI) CreateFlowDefinitionRequest(arg0 *sagemaker.CreateFlowDefinitionInput) (*request.Request, *sagemaker.CreateFlowDefinitionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateFlowDefinitionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.CreateFlowDefinitionOutput)
	return ret0, ret1
}

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

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

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

// CreateHub mocks base method.
func (m *MockSageMakerAPI) CreateHub(arg0 *sagemaker.CreateHubInput) (*sagemaker.CreateHubOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateHub", arg0)
	ret0, _ := ret[0].(*sagemaker.CreateHubOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateHubContentReference mocks base method.
func (m *MockSageMakerAPI) CreateHubContentReference(arg0 *sagemaker.CreateHubContentReferenceInput) (*sagemaker.CreateHubContentReferenceOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateHubContentReference", arg0)
	ret0, _ := ret[0].(*sagemaker.CreateHubContentReferenceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateHubContentReferenceRequest mocks base method.
func (m *MockSageMakerAPI) CreateHubContentReferenceRequest(arg0 *sagemaker.CreateHubContentReferenceInput) (*request.Request, *sagemaker.CreateHubContentReferenceOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateHubContentReferenceRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.CreateHubContentReferenceOutput)
	return ret0, ret1
}

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

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

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

// CreateHubRequest mocks base method.
func (m *MockSageMakerAPI) CreateHubRequest(arg0 *sagemaker.CreateHubInput) (*request.Request, *sagemaker.CreateHubOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateHubRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.CreateHubOutput)
	return ret0, ret1
}

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

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

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

// CreateHumanTaskUi mocks base method.
func (m *MockSageMakerAPI) CreateHumanTaskUi(arg0 *sagemaker.CreateHumanTaskUiInput) (*sagemaker.CreateHumanTaskUiOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateHumanTaskUi", arg0)
	ret0, _ := ret[0].(*sagemaker.CreateHumanTaskUiOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateHumanTaskUiRequest mocks base method.
func (m *MockSageMakerAPI) CreateHumanTaskUiRequest(arg0 *sagemaker.CreateHumanTaskUiInput) (*request.Request, *sagemaker.CreateHumanTaskUiOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateHumanTaskUiRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.CreateHumanTaskUiOutput)
	return ret0, ret1
}

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

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

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

// CreateHyperParameterTuningJob mocks base method.
func (m *MockSageMakerAPI) CreateHyperParameterTuningJob(arg0 *sagemaker.CreateHyperParameterTuningJobInput) (*sagemaker.CreateHyperParameterTuningJobOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateHyperParameterTuningJob", arg0)
	ret0, _ := ret[0].(*sagemaker.CreateHyperParameterTuningJobOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateHyperParameterTuningJobRequest mocks base method.
func (m *MockSageMakerAPI) CreateHyperParameterTuningJobRequest(arg0 *sagemaker.CreateHyperParameterTuningJobInput) (*request.Request, *sagemaker.CreateHyperParameterTuningJobOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateHyperParameterTuningJobRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.CreateHyperParameterTuningJobOutput)
	return ret0, ret1
}

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

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

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

// CreateImage mocks base method.
func (m *MockSageMakerAPI) CreateImage(arg0 *sagemaker.CreateImageInput) (*sagemaker.CreateImageOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateImage", arg0)
	ret0, _ := ret[0].(*sagemaker.CreateImageOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateImageRequest mocks base method.
func (m *MockSageMakerAPI) CreateImageRequest(arg0 *sagemaker.CreateImageInput) (*request.Request, *sagemaker.CreateImageOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateImageRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.CreateImageOutput)
	return ret0, ret1
}

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

// CreateImageVersion mocks base method.
func (m *MockSageMakerAPI) CreateImageVersion(arg0 *sagemaker.CreateImageVersionInput) (*sagemaker.CreateImageVersionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateImageVersion", arg0)
	ret0, _ := ret[0].(*sagemaker.CreateImageVersionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateImageVersionRequest mocks base method.
func (m *MockSageMakerAPI) CreateImageVersionRequest(arg0 *sagemaker.CreateImageVersionInput) (*request.Request, *sagemaker.CreateImageVersionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateImageVersionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.CreateImageVersionOutput)
	return ret0, ret1
}

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

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

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

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

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

// CreateInferenceComponent mocks base method.
func (m *MockSageMakerAPI) CreateInferenceComponent(arg0 *sagemaker.CreateInferenceComponentInput) (*sagemaker.CreateInferenceComponentOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateInferenceComponent", arg0)
	ret0, _ := ret[0].(*sagemaker.CreateInferenceComponentOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateInferenceComponentRequest mocks base method.
func (m *MockSageMakerAPI) CreateInferenceComponentRequest(arg0 *sagemaker.CreateInferenceComponentInput) (*request.Request, *sagemaker.CreateInferenceComponentOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateInferenceComponentRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.CreateInferenceComponentOutput)
	return ret0, ret1
}

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

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

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

// CreateInferenceExperiment mocks base method.
func (m *MockSageMakerAPI) CreateInferenceExperiment(arg0 *sagemaker.CreateInferenceExperimentInput) (*sagemaker.CreateInferenceExperimentOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateInferenceExperiment", arg0)
	ret0, _ := ret[0].(*sagemaker.CreateInferenceExperimentOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateInferenceExperimentRequest mocks base method.
func (m *MockSageMakerAPI) CreateInferenceExperimentRequest(arg0 *sagemaker.CreateInferenceExperimentInput) (*request.Request, *sagemaker.CreateInferenceExperimentOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateInferenceExperimentRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.CreateInferenceExperimentOutput)
	return ret0, ret1
}

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

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

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

// CreateInferenceRecommendationsJob mocks base method.
func (m *MockSageMakerAPI) CreateInferenceRecommendationsJob(arg0 *sagemaker.CreateInferenceRecommendationsJobInput) (*sagemaker.CreateInferenceRecommendationsJobOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateInferenceRecommendationsJob", arg0)
	ret0, _ := ret[0].(*sagemaker.CreateInferenceRecommendationsJobOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateInferenceRecommendationsJobRequest mocks base method.
func (m *MockSageMakerAPI) CreateInferenceRecommendationsJobRequest(arg0 *sagemaker.CreateInferenceRecommendationsJobInput) (*request.Request, *sagemaker.CreateInferenceRecommendationsJobOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateInferenceRecommendationsJobRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.CreateInferenceRecommendationsJobOutput)
	return ret0, ret1
}

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

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

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

// CreateLabelingJob mocks base method.
func (m *MockSageMakerAPI) CreateLabelingJob(arg0 *sagemaker.CreateLabelingJobInput) (*sagemaker.CreateLabelingJobOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateLabelingJob", arg0)
	ret0, _ := ret[0].(*sagemaker.CreateLabelingJobOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateLabelingJobRequest mocks base method.
func (m *MockSageMakerAPI) CreateLabelingJobRequest(arg0 *sagemaker.CreateLabelingJobInput) (*request.Request, *sagemaker.CreateLabelingJobOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateLabelingJobRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.CreateLabelingJobOutput)
	return ret0, ret1
}

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

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

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

// CreateMlflowTrackingServer mocks base method.
func (m *MockSageMakerAPI) CreateMlflowTrackingServer(arg0 *sagemaker.CreateMlflowTrackingServerInput) (*sagemaker.CreateMlflowTrackingServerOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateMlflowTrackingServer", arg0)
	ret0, _ := ret[0].(*sagemaker.CreateMlflowTrackingServerOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateMlflowTrackingServerRequest mocks base method.
func (m *MockSageMakerAPI) CreateMlflowTrackingServerRequest(arg0 *sagemaker.CreateMlflowTrackingServerInput) (*request.Request, *sagemaker.CreateMlflowTrackingServerOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateMlflowTrackingServerRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.CreateMlflowTrackingServerOutput)
	return ret0, ret1
}

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

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

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

// CreateModel mocks base method.
func (m *MockSageMakerAPI) CreateModel(arg0 *sagemaker.CreateModelInput) (*sagemaker.CreateModelOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateModel", arg0)
	ret0, _ := ret[0].(*sagemaker.CreateModelOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateModelBiasJobDefinition mocks base method.
func (m *MockSageMakerAPI) CreateModelBiasJobDefinition(arg0 *sagemaker.CreateModelBiasJobDefinitionInput) (*sagemaker.CreateModelBiasJobDefinitionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateModelBiasJobDefinition", arg0)
	ret0, _ := ret[0].(*sagemaker.CreateModelBiasJobDefinitionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateModelBiasJobDefinitionRequest mocks base method.
func (m *MockSageMakerAPI) CreateModelBiasJobDefinitionRequest(arg0 *sagemaker.CreateModelBiasJobDefinitionInput) (*request.Request, *sagemaker.CreateModelBiasJobDefinitionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateModelBiasJobDefinitionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.CreateModelBiasJobDefinitionOutput)
	return ret0, ret1
}

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

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

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

// CreateModelCard mocks base method.
func (m *MockSageMakerAPI) CreateModelCard(arg0 *sagemaker.CreateModelCardInput) (*sagemaker.CreateModelCardOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateModelCard", arg0)
	ret0, _ := ret[0].(*sagemaker.CreateModelCardOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateModelCardExportJob mocks base method.
func (m *MockSageMakerAPI) CreateModelCardExportJob(arg0 *sagemaker.CreateModelCardExportJobInput) (*sagemaker.CreateModelCardExportJobOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateModelCardExportJob", arg0)
	ret0, _ := ret[0].(*sagemaker.CreateModelCardExportJobOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateModelCardExportJobRequest mocks base method.
func (m *MockSageMakerAPI) CreateModelCardExportJobRequest(arg0 *sagemaker.CreateModelCardExportJobInput) (*request.Request, *sagemaker.CreateModelCardExportJobOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateModelCardExportJobRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.CreateModelCardExportJobOutput)
	return ret0, ret1
}

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

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

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

// CreateModelCardRequest mocks base method.
func (m *MockSageMakerAPI) CreateModelCardRequest(arg0 *sagemaker.CreateModelCardInput) (*request.Request, *sagemaker.CreateModelCardOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateModelCardRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.CreateModelCardOutput)
	return ret0, ret1
}

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

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

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

// CreateModelExplainabilityJobDefinition mocks base method.
func (m *MockSageMakerAPI) CreateModelExplainabilityJobDefinition(arg0 *sagemaker.CreateModelExplainabilityJobDefinitionInput) (*sagemaker.CreateModelExplainabilityJobDefinitionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateModelExplainabilityJobDefinition", arg0)
	ret0, _ := ret[0].(*sagemaker.CreateModelExplainabilityJobDefinitionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateModelExplainabilityJobDefinitionRequest mocks base method.
func (m *MockSageMakerAPI) CreateModelExplainabilityJobDefinitionRequest(arg0 *sagemaker.CreateModelExplainabilityJobDefinitionInput) (*request.Request, *sagemaker.CreateModelExplainabilityJobDefinitionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateModelExplainabilityJobDefinitionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.CreateModelExplainabilityJobDefinitionOutput)
	return ret0, ret1
}

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

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

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

// CreateModelPackage mocks base method.
func (m *MockSageMakerAPI) CreateModelPackage(arg0 *sagemaker.CreateModelPackageInput) (*sagemaker.CreateModelPackageOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateModelPackage", arg0)
	ret0, _ := ret[0].(*sagemaker.CreateModelPackageOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateModelPackageGroup mocks base method.
func (m *MockSageMakerAPI) CreateModelPackageGroup(arg0 *sagemaker.CreateModelPackageGroupInput) (*sagemaker.CreateModelPackageGroupOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateModelPackageGroup", arg0)
	ret0, _ := ret[0].(*sagemaker.CreateModelPackageGroupOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateModelPackageGroupRequest mocks base method.
func (m *MockSageMakerAPI) CreateModelPackageGroupRequest(arg0 *sagemaker.CreateModelPackageGroupInput) (*request.Request, *sagemaker.CreateModelPackageGroupOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateModelPackageGroupRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.CreateModelPackageGroupOutput)
	return ret0, ret1
}

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

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

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

// CreateModelPackageRequest mocks base method.
func (m *MockSageMakerAPI) CreateModelPackageRequest(arg0 *sagemaker.CreateModelPackageInput) (*request.Request, *sagemaker.CreateModelPackageOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateModelPackageRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.CreateModelPackageOutput)
	return ret0, ret1
}

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

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

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

// CreateModelQualityJobDefinition mocks base method.
func (m *MockSageMakerAPI) CreateModelQualityJobDefinition(arg0 *sagemaker.CreateModelQualityJobDefinitionInput) (*sagemaker.CreateModelQualityJobDefinitionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateModelQualityJobDefinition", arg0)
	ret0, _ := ret[0].(*sagemaker.CreateModelQualityJobDefinitionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateModelQualityJobDefinitionRequest mocks base method.
func (m *MockSageMakerAPI) CreateModelQualityJobDefinitionRequest(arg0 *sagemaker.CreateModelQualityJobDefinitionInput) (*request.Request, *sagemaker.CreateModelQualityJobDefinitionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateModelQualityJobDefinitionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.CreateModelQualityJobDefinitionOutput)
	return ret0, ret1
}

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

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

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

// CreateModelRequest mocks base method.
func (m *MockSageMakerAPI) CreateModelRequest(arg0 *sagemaker.CreateModelInput) (*request.Request, *sagemaker.CreateModelOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateModelRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.CreateModelOutput)
	return ret0, ret1
}

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

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

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

// CreateMonitoringSchedule mocks base method.
func (m *MockSageMakerAPI) CreateMonitoringSchedule(arg0 *sagemaker.CreateMonitoringScheduleInput) (*sagemaker.CreateMonitoringScheduleOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateMonitoringSchedule", arg0)
	ret0, _ := ret[0].(*sagemaker.CreateMonitoringScheduleOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateMonitoringScheduleRequest mocks base method.
func (m *MockSageMakerAPI) CreateMonitoringScheduleRequest(arg0 *sagemaker.CreateMonitoringScheduleInput) (*request.Request, *sagemaker.CreateMonitoringScheduleOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateMonitoringScheduleRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.CreateMonitoringScheduleOutput)
	return ret0, ret1
}

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

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

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

// CreateNotebookInstance mocks base method.
func (m *MockSageMakerAPI) CreateNotebookInstance(arg0 *sagemaker.CreateNotebookInstanceInput) (*sagemaker.CreateNotebookInstanceOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateNotebookInstance", arg0)
	ret0, _ := ret[0].(*sagemaker.CreateNotebookInstanceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateNotebookInstanceLifecycleConfig mocks base method.
func (m *MockSageMakerAPI) CreateNotebookInstanceLifecycleConfig(arg0 *sagemaker.CreateNotebookInstanceLifecycleConfigInput) (*sagemaker.CreateNotebookInstanceLifecycleConfigOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateNotebookInstanceLifecycleConfig", arg0)
	ret0, _ := ret[0].(*sagemaker.CreateNotebookInstanceLifecycleConfigOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateNotebookInstanceLifecycleConfigRequest mocks base method.
func (m *MockSageMakerAPI) CreateNotebookInstanceLifecycleConfigRequest(arg0 *sagemaker.CreateNotebookInstanceLifecycleConfigInput) (*request.Request, *sagemaker.CreateNotebookInstanceLifecycleConfigOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateNotebookInstanceLifecycleConfigRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.CreateNotebookInstanceLifecycleConfigOutput)
	return ret0, ret1
}

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

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

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

// CreateNotebookInstanceRequest mocks base method.
func (m *MockSageMakerAPI) CreateNotebookInstanceRequest(arg0 *sagemaker.CreateNotebookInstanceInput) (*request.Request, *sagemaker.CreateNotebookInstanceOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateNotebookInstanceRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.CreateNotebookInstanceOutput)
	return ret0, ret1
}

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

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

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

// CreateOptimizationJob mocks base method.
func (m *MockSageMakerAPI) CreateOptimizationJob(arg0 *sagemaker.CreateOptimizationJobInput) (*sagemaker.CreateOptimizationJobOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateOptimizationJob", arg0)
	ret0, _ := ret[0].(*sagemaker.CreateOptimizationJobOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateOptimizationJobRequest mocks base method.
func (m *MockSageMakerAPI) CreateOptimizationJobRequest(arg0 *sagemaker.CreateOptimizationJobInput) (*request.Request, *sagemaker.CreateOptimizationJobOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateOptimizationJobRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.CreateOptimizationJobOutput)
	return ret0, ret1
}

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

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

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

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

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

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

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

// CreatePipelineWithContext mocks base method.
func (m *MockSageMakerAPI) CreatePipelineWithContext(arg0 aws.Context, arg1 *sagemaker.CreatePipelineInput, arg2 ...request.Option) (*sagemaker.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].(*sagemaker.CreatePipelineOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreatePresignedDomainUrl mocks base method.
func (m *MockSageMakerAPI) CreatePresignedDomainUrl(arg0 *sagemaker.CreatePresignedDomainUrlInput) (*sagemaker.CreatePresignedDomainUrlOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreatePresignedDomainUrl", arg0)
	ret0, _ := ret[0].(*sagemaker.CreatePresignedDomainUrlOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreatePresignedDomainUrlRequest mocks base method.
func (m *MockSageMakerAPI) CreatePresignedDomainUrlRequest(arg0 *sagemaker.CreatePresignedDomainUrlInput) (*request.Request, *sagemaker.CreatePresignedDomainUrlOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreatePresignedDomainUrlRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.CreatePresignedDomainUrlOutput)
	return ret0, ret1
}

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

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

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

// CreatePresignedMlflowTrackingServerUrl mocks base method.
func (m *MockSageMakerAPI) CreatePresignedMlflowTrackingServerUrl(arg0 *sagemaker.CreatePresignedMlflowTrackingServerUrlInput) (*sagemaker.CreatePresignedMlflowTrackingServerUrlOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreatePresignedMlflowTrackingServerUrl", arg0)
	ret0, _ := ret[0].(*sagemaker.CreatePresignedMlflowTrackingServerUrlOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreatePresignedMlflowTrackingServerUrlRequest mocks base method.
func (m *MockSageMakerAPI) CreatePresignedMlflowTrackingServerUrlRequest(arg0 *sagemaker.CreatePresignedMlflowTrackingServerUrlInput) (*request.Request, *sagemaker.CreatePresignedMlflowTrackingServerUrlOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreatePresignedMlflowTrackingServerUrlRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.CreatePresignedMlflowTrackingServerUrlOutput)
	return ret0, ret1
}

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

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

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

// CreatePresignedNotebookInstanceUrl mocks base method.
func (m *MockSageMakerAPI) CreatePresignedNotebookInstanceUrl(arg0 *sagemaker.CreatePresignedNotebookInstanceUrlInput) (*sagemaker.CreatePresignedNotebookInstanceUrlOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreatePresignedNotebookInstanceUrl", arg0)
	ret0, _ := ret[0].(*sagemaker.CreatePresignedNotebookInstanceUrlOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreatePresignedNotebookInstanceUrlRequest mocks base method.
func (m *MockSageMakerAPI) CreatePresignedNotebookInstanceUrlRequest(arg0 *sagemaker.CreatePresignedNotebookInstanceUrlInput) (*request.Request, *sagemaker.CreatePresignedNotebookInstanceUrlOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreatePresignedNotebookInstanceUrlRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.CreatePresignedNotebookInstanceUrlOutput)
	return ret0, ret1
}

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

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

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

// CreateProcessingJob mocks base method.
func (m *MockSageMakerAPI) CreateProcessingJob(arg0 *sagemaker.CreateProcessingJobInput) (*sagemaker.CreateProcessingJobOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateProcessingJob", arg0)
	ret0, _ := ret[0].(*sagemaker.CreateProcessingJobOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateProcessingJobRequest mocks base method.
func (m *MockSageMakerAPI) CreateProcessingJobRequest(arg0 *sagemaker.CreateProcessingJobInput) (*request.Request, *sagemaker.CreateProcessingJobOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateProcessingJobRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.CreateProcessingJobOutput)
	return ret0, ret1
}

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

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

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

// CreateProject mocks base method.
func (m *MockSageMakerAPI) CreateProject(arg0 *sagemaker.CreateProjectInput) (*sagemaker.CreateProjectOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateProject", arg0)
	ret0, _ := ret[0].(*sagemaker.CreateProjectOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateProjectRequest mocks base method.
func (m *MockSageMakerAPI) CreateProjectRequest(arg0 *sagemaker.CreateProjectInput) (*request.Request, *sagemaker.CreateProjectOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateProjectRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.CreateProjectOutput)
	return ret0, ret1
}

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

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

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

// CreateSpace mocks base method.
func (m *MockSageMakerAPI) CreateSpace(arg0 *sagemaker.CreateSpaceInput) (*sagemaker.CreateSpaceOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateSpace", arg0)
	ret0, _ := ret[0].(*sagemaker.CreateSpaceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateSpaceRequest mocks base method.
func (m *MockSageMakerAPI) CreateSpaceRequest(arg0 *sagemaker.CreateSpaceInput) (*request.Request, *sagemaker.CreateSpaceOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateSpaceRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.CreateSpaceOutput)
	return ret0, ret1
}

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

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

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

// CreateStudioLifecycleConfig mocks base method.
func (m *MockSageMakerAPI) CreateStudioLifecycleConfig(arg0 *sagemaker.CreateStudioLifecycleConfigInput) (*sagemaker.CreateStudioLifecycleConfigOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateStudioLifecycleConfig", arg0)
	ret0, _ := ret[0].(*sagemaker.CreateStudioLifecycleConfigOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateStudioLifecycleConfigRequest mocks base method.
func (m *MockSageMakerAPI) CreateStudioLifecycleConfigRequest(arg0 *sagemaker.CreateStudioLifecycleConfigInput) (*request.Request, *sagemaker.CreateStudioLifecycleConfigOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateStudioLifecycleConfigRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.CreateStudioLifecycleConfigOutput)
	return ret0, ret1
}

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

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

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

// CreateTrainingJob mocks base method.
func (m *MockSageMakerAPI) CreateTrainingJob(arg0 *sagemaker.CreateTrainingJobInput) (*sagemaker.CreateTrainingJobOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateTrainingJob", arg0)
	ret0, _ := ret[0].(*sagemaker.CreateTrainingJobOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateTrainingJobRequest mocks base method.
func (m *MockSageMakerAPI) CreateTrainingJobRequest(arg0 *sagemaker.CreateTrainingJobInput) (*request.Request, *sagemaker.CreateTrainingJobOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateTrainingJobRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.CreateTrainingJobOutput)
	return ret0, ret1
}

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

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

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

// CreateTransformJob mocks base method.
func (m *MockSageMakerAPI) CreateTransformJob(arg0 *sagemaker.CreateTransformJobInput) (*sagemaker.CreateTransformJobOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateTransformJob", arg0)
	ret0, _ := ret[0].(*sagemaker.CreateTransformJobOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateTransformJobRequest mocks base method.
func (m *MockSageMakerAPI) CreateTransformJobRequest(arg0 *sagemaker.CreateTransformJobInput) (*request.Request, *sagemaker.CreateTransformJobOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateTransformJobRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.CreateTransformJobOutput)
	return ret0, ret1
}

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

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

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

// CreateTrial mocks base method.
func (m *MockSageMakerAPI) CreateTrial(arg0 *sagemaker.CreateTrialInput) (*sagemaker.CreateTrialOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateTrial", arg0)
	ret0, _ := ret[0].(*sagemaker.CreateTrialOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateTrialComponent mocks base method.
func (m *MockSageMakerAPI) CreateTrialComponent(arg0 *sagemaker.CreateTrialComponentInput) (*sagemaker.CreateTrialComponentOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateTrialComponent", arg0)
	ret0, _ := ret[0].(*sagemaker.CreateTrialComponentOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateTrialComponentRequest mocks base method.
func (m *MockSageMakerAPI) CreateTrialComponentRequest(arg0 *sagemaker.CreateTrialComponentInput) (*request.Request, *sagemaker.CreateTrialComponentOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateTrialComponentRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.CreateTrialComponentOutput)
	return ret0, ret1
}

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

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

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

// CreateTrialRequest mocks base method.
func (m *MockSageMakerAPI) CreateTrialRequest(arg0 *sagemaker.CreateTrialInput) (*request.Request, *sagemaker.CreateTrialOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateTrialRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.CreateTrialOutput)
	return ret0, ret1
}

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

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

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

// CreateUserProfile mocks base method.
func (m *MockSageMakerAPI) CreateUserProfile(arg0 *sagemaker.CreateUserProfileInput) (*sagemaker.CreateUserProfileOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateUserProfile", arg0)
	ret0, _ := ret[0].(*sagemaker.CreateUserProfileOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateUserProfileRequest mocks base method.
func (m *MockSageMakerAPI) CreateUserProfileRequest(arg0 *sagemaker.CreateUserProfileInput) (*request.Request, *sagemaker.CreateUserProfileOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateUserProfileRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.CreateUserProfileOutput)
	return ret0, ret1
}

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

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

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

// CreateWorkforce mocks base method.
func (m *MockSageMakerAPI) CreateWorkforce(arg0 *sagemaker.CreateWorkforceInput) (*sagemaker.CreateWorkforceOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateWorkforce", arg0)
	ret0, _ := ret[0].(*sagemaker.CreateWorkforceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateWorkforceRequest mocks base method.
func (m *MockSageMakerAPI) CreateWorkforceRequest(arg0 *sagemaker.CreateWorkforceInput) (*request.Request, *sagemaker.CreateWorkforceOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateWorkforceRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.CreateWorkforceOutput)
	return ret0, ret1
}

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

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

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

// CreateWorkteam mocks base method.
func (m *MockSageMakerAPI) CreateWorkteam(arg0 *sagemaker.CreateWorkteamInput) (*sagemaker.CreateWorkteamOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateWorkteam", arg0)
	ret0, _ := ret[0].(*sagemaker.CreateWorkteamOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateWorkteamRequest mocks base method.
func (m *MockSageMakerAPI) CreateWorkteamRequest(arg0 *sagemaker.CreateWorkteamInput) (*request.Request, *sagemaker.CreateWorkteamOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateWorkteamRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.CreateWorkteamOutput)
	return ret0, ret1
}

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

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

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

// DeleteAction mocks base method.
func (m *MockSageMakerAPI) DeleteAction(arg0 *sagemaker.DeleteActionInput) (*sagemaker.DeleteActionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteAction", arg0)
	ret0, _ := ret[0].(*sagemaker.DeleteActionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteActionRequest mocks base method.
func (m *MockSageMakerAPI) DeleteActionRequest(arg0 *sagemaker.DeleteActionInput) (*request.Request, *sagemaker.DeleteActionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteActionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.DeleteActionOutput)
	return ret0, ret1
}

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

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

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

// DeleteAlgorithm mocks base method.
func (m *MockSageMakerAPI) DeleteAlgorithm(arg0 *sagemaker.DeleteAlgorithmInput) (*sagemaker.DeleteAlgorithmOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteAlgorithm", arg0)
	ret0, _ := ret[0].(*sagemaker.DeleteAlgorithmOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteAlgorithmRequest mocks base method.
func (m *MockSageMakerAPI) DeleteAlgorithmRequest(arg0 *sagemaker.DeleteAlgorithmInput) (*request.Request, *sagemaker.DeleteAlgorithmOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteAlgorithmRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.DeleteAlgorithmOutput)
	return ret0, ret1
}

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

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

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

// DeleteApp mocks base method.
func (m *MockSageMakerAPI) DeleteApp(arg0 *sagemaker.DeleteAppInput) (*sagemaker.DeleteAppOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteApp", arg0)
	ret0, _ := ret[0].(*sagemaker.DeleteAppOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteAppImageConfig mocks base method.
func (m *MockSageMakerAPI) DeleteAppImageConfig(arg0 *sagemaker.DeleteAppImageConfigInput) (*sagemaker.DeleteAppImageConfigOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteAppImageConfig", arg0)
	ret0, _ := ret[0].(*sagemaker.DeleteAppImageConfigOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteAppImageConfigRequest mocks base method.
func (m *MockSageMakerAPI) DeleteAppImageConfigRequest(arg0 *sagemaker.DeleteAppImageConfigInput) (*request.Request, *sagemaker.DeleteAppImageConfigOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteAppImageConfigRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.DeleteAppImageConfigOutput)
	return ret0, ret1
}

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

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

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

// DeleteAppRequest mocks base method.
func (m *MockSageMakerAPI) DeleteAppRequest(arg0 *sagemaker.DeleteAppInput) (*request.Request, *sagemaker.DeleteAppOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteAppRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.DeleteAppOutput)
	return ret0, ret1
}

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

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

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

// DeleteArtifact mocks base method.
func (m *MockSageMakerAPI) DeleteArtifact(arg0 *sagemaker.DeleteArtifactInput) (*sagemaker.DeleteArtifactOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteArtifact", arg0)
	ret0, _ := ret[0].(*sagemaker.DeleteArtifactOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteArtifactRequest mocks base method.
func (m *MockSageMakerAPI) DeleteArtifactRequest(arg0 *sagemaker.DeleteArtifactInput) (*request.Request, *sagemaker.DeleteArtifactOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteArtifactRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.DeleteArtifactOutput)
	return ret0, ret1
}

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

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

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

// DeleteAssociation mocks base method.
func (m *MockSageMakerAPI) DeleteAssociation(arg0 *sagemaker.DeleteAssociationInput) (*sagemaker.DeleteAssociationOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteAssociation", arg0)
	ret0, _ := ret[0].(*sagemaker.DeleteAssociationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteAssociationRequest mocks base method.
func (m *MockSageMakerAPI) DeleteAssociationRequest(arg0 *sagemaker.DeleteAssociationInput) (*request.Request, *sagemaker.DeleteAssociationOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteAssociationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.DeleteAssociationOutput)
	return ret0, ret1
}

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

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

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

// DeleteCluster mocks base method.
func (m *MockSageMakerAPI) DeleteCluster(arg0 *sagemaker.DeleteClusterInput) (*sagemaker.DeleteClusterOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteCluster", arg0)
	ret0, _ := ret[0].(*sagemaker.DeleteClusterOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteClusterRequest mocks base method.
func (m *MockSageMakerAPI) DeleteClusterRequest(arg0 *sagemaker.DeleteClusterInput) (*request.Request, *sagemaker.DeleteClusterOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteClusterRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.DeleteClusterOutput)
	return ret0, ret1
}

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

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

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

// DeleteCodeRepository mocks base method.
func (m *MockSageMakerAPI) DeleteCodeRepository(arg0 *sagemaker.DeleteCodeRepositoryInput) (*sagemaker.DeleteCodeRepositoryOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteCodeRepository", arg0)
	ret0, _ := ret[0].(*sagemaker.DeleteCodeRepositoryOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteCodeRepositoryRequest mocks base method.
func (m *MockSageMakerAPI) DeleteCodeRepositoryRequest(arg0 *sagemaker.DeleteCodeRepositoryInput) (*request.Request, *sagemaker.DeleteCodeRepositoryOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteCodeRepositoryRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.DeleteCodeRepositoryOutput)
	return ret0, ret1
}

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

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

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

// DeleteCompilationJob mocks base method.
func (m *MockSageMakerAPI) DeleteCompilationJob(arg0 *sagemaker.DeleteCompilationJobInput) (*sagemaker.DeleteCompilationJobOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteCompilationJob", arg0)
	ret0, _ := ret[0].(*sagemaker.DeleteCompilationJobOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteCompilationJobRequest mocks base method.
func (m *MockSageMakerAPI) DeleteCompilationJobRequest(arg0 *sagemaker.DeleteCompilationJobInput) (*request.Request, *sagemaker.DeleteCompilationJobOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteCompilationJobRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.DeleteCompilationJobOutput)
	return ret0, ret1
}

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

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

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

// DeleteContext mocks base method.
func (m *MockSageMakerAPI) DeleteContext(arg0 *sagemaker.DeleteContextInput) (*sagemaker.DeleteContextOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteContext", arg0)
	ret0, _ := ret[0].(*sagemaker.DeleteContextOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteContextRequest mocks base method.
func (m *MockSageMakerAPI) DeleteContextRequest(arg0 *sagemaker.DeleteContextInput) (*request.Request, *sagemaker.DeleteContextOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteContextRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.DeleteContextOutput)
	return ret0, ret1
}

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

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

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

// DeleteDataQualityJobDefinition mocks base method.
func (m *MockSageMakerAPI) DeleteDataQualityJobDefinition(arg0 *sagemaker.DeleteDataQualityJobDefinitionInput) (*sagemaker.DeleteDataQualityJobDefinitionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteDataQualityJobDefinition", arg0)
	ret0, _ := ret[0].(*sagemaker.DeleteDataQualityJobDefinitionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteDataQualityJobDefinitionRequest mocks base method.
func (m *MockSageMakerAPI) DeleteDataQualityJobDefinitionRequest(arg0 *sagemaker.DeleteDataQualityJobDefinitionInput) (*request.Request, *sagemaker.DeleteDataQualityJobDefinitionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteDataQualityJobDefinitionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.DeleteDataQualityJobDefinitionOutput)
	return ret0, ret1
}

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

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

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

// DeleteDeviceFleet mocks base method.
func (m *MockSageMakerAPI) DeleteDeviceFleet(arg0 *sagemaker.DeleteDeviceFleetInput) (*sagemaker.DeleteDeviceFleetOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteDeviceFleet", arg0)
	ret0, _ := ret[0].(*sagemaker.DeleteDeviceFleetOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteDeviceFleetRequest mocks base method.
func (m *MockSageMakerAPI) DeleteDeviceFleetRequest(arg0 *sagemaker.DeleteDeviceFleetInput) (*request.Request, *sagemaker.DeleteDeviceFleetOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteDeviceFleetRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.DeleteDeviceFleetOutput)
	return ret0, ret1
}

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

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

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

// DeleteDomain mocks base method.
func (m *MockSageMakerAPI) DeleteDomain(arg0 *sagemaker.DeleteDomainInput) (*sagemaker.DeleteDomainOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteDomain", arg0)
	ret0, _ := ret[0].(*sagemaker.DeleteDomainOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteDomainRequest mocks base method.
func (m *MockSageMakerAPI) DeleteDomainRequest(arg0 *sagemaker.DeleteDomainInput) (*request.Request, *sagemaker.DeleteDomainOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteDomainRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.DeleteDomainOutput)
	return ret0, ret1
}

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

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

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

// DeleteEdgeDeploymentPlan mocks base method.
func (m *MockSageMakerAPI) DeleteEdgeDeploymentPlan(arg0 *sagemaker.DeleteEdgeDeploymentPlanInput) (*sagemaker.DeleteEdgeDeploymentPlanOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteEdgeDeploymentPlan", arg0)
	ret0, _ := ret[0].(*sagemaker.DeleteEdgeDeploymentPlanOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteEdgeDeploymentPlanRequest mocks base method.
func (m *MockSageMakerAPI) DeleteEdgeDeploymentPlanRequest(arg0 *sagemaker.DeleteEdgeDeploymentPlanInput) (*request.Request, *sagemaker.DeleteEdgeDeploymentPlanOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteEdgeDeploymentPlanRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.DeleteEdgeDeploymentPlanOutput)
	return ret0, ret1
}

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

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

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

// DeleteEdgeDeploymentStage mocks base method.
func (m *MockSageMakerAPI) DeleteEdgeDeploymentStage(arg0 *sagemaker.DeleteEdgeDeploymentStageInput) (*sagemaker.DeleteEdgeDeploymentStageOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteEdgeDeploymentStage", arg0)
	ret0, _ := ret[0].(*sagemaker.DeleteEdgeDeploymentStageOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteEdgeDeploymentStageRequest mocks base method.
func (m *MockSageMakerAPI) DeleteEdgeDeploymentStageRequest(arg0 *sagemaker.DeleteEdgeDeploymentStageInput) (*request.Request, *sagemaker.DeleteEdgeDeploymentStageOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteEdgeDeploymentStageRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.DeleteEdgeDeploymentStageOutput)
	return ret0, ret1
}

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

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

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

// DeleteEndpoint mocks base method.
func (m *MockSageMakerAPI) DeleteEndpoint(arg0 *sagemaker.DeleteEndpointInput) (*sagemaker.DeleteEndpointOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteEndpoint", arg0)
	ret0, _ := ret[0].(*sagemaker.DeleteEndpointOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteEndpointConfig mocks base method.
func (m *MockSageMakerAPI) DeleteEndpointConfig(arg0 *sagemaker.DeleteEndpointConfigInput) (*sagemaker.DeleteEndpointConfigOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteEndpointConfig", arg0)
	ret0, _ := ret[0].(*sagemaker.DeleteEndpointConfigOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteEndpointConfigRequest mocks base method.
func (m *MockSageMakerAPI) DeleteEndpointConfigRequest(arg0 *sagemaker.DeleteEndpointConfigInput) (*request.Request, *sagemaker.DeleteEndpointConfigOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteEndpointConfigRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.DeleteEndpointConfigOutput)
	return ret0, ret1
}

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

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

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

// DeleteEndpointRequest mocks base method.
func (m *MockSageMakerAPI) DeleteEndpointRequest(arg0 *sagemaker.DeleteEndpointInput) (*request.Request, *sagemaker.DeleteEndpointOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteEndpointRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.DeleteEndpointOutput)
	return ret0, ret1
}

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

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

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

// DeleteExperiment mocks base method.
func (m *MockSageMakerAPI) DeleteExperiment(arg0 *sagemaker.DeleteExperimentInput) (*sagemaker.DeleteExperimentOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteExperiment", arg0)
	ret0, _ := ret[0].(*sagemaker.DeleteExperimentOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteExperimentRequest mocks base method.
func (m *MockSageMakerAPI) DeleteExperimentRequest(arg0 *sagemaker.DeleteExperimentInput) (*request.Request, *sagemaker.DeleteExperimentOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteExperimentRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.DeleteExperimentOutput)
	return ret0, ret1
}

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

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

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

// DeleteFeatureGroup mocks base method.
func (m *MockSageMakerAPI) DeleteFeatureGroup(arg0 *sagemaker.DeleteFeatureGroupInput) (*sagemaker.DeleteFeatureGroupOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteFeatureGroup", arg0)
	ret0, _ := ret[0].(*sagemaker.DeleteFeatureGroupOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteFeatureGroupRequest mocks base method.
func (m *MockSageMakerAPI) DeleteFeatureGroupRequest(arg0 *sagemaker.DeleteFeatureGroupInput) (*request.Request, *sagemaker.DeleteFeatureGroupOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteFeatureGroupRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.DeleteFeatureGroupOutput)
	return ret0, ret1
}

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

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

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

// DeleteFlowDefinition mocks base method.
func (m *MockSageMakerAPI) DeleteFlowDefinition(arg0 *sagemaker.DeleteFlowDefinitionInput) (*sagemaker.DeleteFlowDefinitionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteFlowDefinition", arg0)
	ret0, _ := ret[0].(*sagemaker.DeleteFlowDefinitionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteFlowDefinitionRequest mocks base method.
func (m *MockSageMakerAPI) DeleteFlowDefinitionRequest(arg0 *sagemaker.DeleteFlowDefinitionInput) (*request.Request, *sagemaker.DeleteFlowDefinitionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteFlowDefinitionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.DeleteFlowDefinitionOutput)
	return ret0, ret1
}

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

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

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

// DeleteHub mocks base method.
func (m *MockSageMakerAPI) DeleteHub(arg0 *sagemaker.DeleteHubInput) (*sagemaker.DeleteHubOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteHub", arg0)
	ret0, _ := ret[0].(*sagemaker.DeleteHubOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteHubContent mocks base method.
func (m *MockSageMakerAPI) DeleteHubContent(arg0 *sagemaker.DeleteHubContentInput) (*sagemaker.DeleteHubContentOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteHubContent", arg0)
	ret0, _ := ret[0].(*sagemaker.DeleteHubContentOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteHubContentReference mocks base method.
func (m *MockSageMakerAPI) DeleteHubContentReference(arg0 *sagemaker.DeleteHubContentReferenceInput) (*sagemaker.DeleteHubContentReferenceOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteHubContentReference", arg0)
	ret0, _ := ret[0].(*sagemaker.DeleteHubContentReferenceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteHubContentReferenceRequest mocks base method.
func (m *MockSageMakerAPI) DeleteHubContentReferenceRequest(arg0 *sagemaker.DeleteHubContentReferenceInput) (*request.Request, *sagemaker.DeleteHubContentReferenceOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteHubContentReferenceRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.DeleteHubContentReferenceOutput)
	return ret0, ret1
}

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

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

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

// DeleteHubContentRequest mocks base method.
func (m *MockSageMakerAPI) DeleteHubContentRequest(arg0 *sagemaker.DeleteHubContentInput) (*request.Request, *sagemaker.DeleteHubContentOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteHubContentRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.DeleteHubContentOutput)
	return ret0, ret1
}

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

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

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

// DeleteHubRequest mocks base method.
func (m *MockSageMakerAPI) DeleteHubRequest(arg0 *sagemaker.DeleteHubInput) (*request.Request, *sagemaker.DeleteHubOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteHubRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.DeleteHubOutput)
	return ret0, ret1
}

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

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

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

// DeleteHumanTaskUi mocks base method.
func (m *MockSageMakerAPI) DeleteHumanTaskUi(arg0 *sagemaker.DeleteHumanTaskUiInput) (*sagemaker.DeleteHumanTaskUiOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteHumanTaskUi", arg0)
	ret0, _ := ret[0].(*sagemaker.DeleteHumanTaskUiOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteHumanTaskUiRequest mocks base method.
func (m *MockSageMakerAPI) DeleteHumanTaskUiRequest(arg0 *sagemaker.DeleteHumanTaskUiInput) (*request.Request, *sagemaker.DeleteHumanTaskUiOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteHumanTaskUiRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.DeleteHumanTaskUiOutput)
	return ret0, ret1
}

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

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

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

// DeleteHyperParameterTuningJob mocks base method.
func (m *MockSageMakerAPI) DeleteHyperParameterTuningJob(arg0 *sagemaker.DeleteHyperParameterTuningJobInput) (*sagemaker.DeleteHyperParameterTuningJobOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteHyperParameterTuningJob", arg0)
	ret0, _ := ret[0].(*sagemaker.DeleteHyperParameterTuningJobOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteHyperParameterTuningJobRequest mocks base method.
func (m *MockSageMakerAPI) DeleteHyperParameterTuningJobRequest(arg0 *sagemaker.DeleteHyperParameterTuningJobInput) (*request.Request, *sagemaker.DeleteHyperParameterTuningJobOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteHyperParameterTuningJobRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.DeleteHyperParameterTuningJobOutput)
	return ret0, ret1
}

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

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

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

// DeleteImage mocks base method.
func (m *MockSageMakerAPI) DeleteImage(arg0 *sagemaker.DeleteImageInput) (*sagemaker.DeleteImageOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteImage", arg0)
	ret0, _ := ret[0].(*sagemaker.DeleteImageOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteImageRequest mocks base method.
func (m *MockSageMakerAPI) DeleteImageRequest(arg0 *sagemaker.DeleteImageInput) (*request.Request, *sagemaker.DeleteImageOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteImageRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.DeleteImageOutput)
	return ret0, ret1
}

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

// DeleteImageVersion mocks base method.
func (m *MockSageMakerAPI) DeleteImageVersion(arg0 *sagemaker.DeleteImageVersionInput) (*sagemaker.DeleteImageVersionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteImageVersion", arg0)
	ret0, _ := ret[0].(*sagemaker.DeleteImageVersionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteImageVersionRequest mocks base method.
func (m *MockSageMakerAPI) DeleteImageVersionRequest(arg0 *sagemaker.DeleteImageVersionInput) (*request.Request, *sagemaker.DeleteImageVersionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteImageVersionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.DeleteImageVersionOutput)
	return ret0, ret1
}

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

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

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

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

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

// DeleteInferenceComponent mocks base method.
func (m *MockSageMakerAPI) DeleteInferenceComponent(arg0 *sagemaker.DeleteInferenceComponentInput) (*sagemaker.DeleteInferenceComponentOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteInferenceComponent", arg0)
	ret0, _ := ret[0].(*sagemaker.DeleteInferenceComponentOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteInferenceComponentRequest mocks base method.
func (m *MockSageMakerAPI) DeleteInferenceComponentRequest(arg0 *sagemaker.DeleteInferenceComponentInput) (*request.Request, *sagemaker.DeleteInferenceComponentOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteInferenceComponentRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.DeleteInferenceComponentOutput)
	return ret0, ret1
}

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

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

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

// DeleteInferenceExperiment mocks base method.
func (m *MockSageMakerAPI) DeleteInferenceExperiment(arg0 *sagemaker.DeleteInferenceExperimentInput) (*sagemaker.DeleteInferenceExperimentOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteInferenceExperiment", arg0)
	ret0, _ := ret[0].(*sagemaker.DeleteInferenceExperimentOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteInferenceExperimentRequest mocks base method.
func (m *MockSageMakerAPI) DeleteInferenceExperimentRequest(arg0 *sagemaker.DeleteInferenceExperimentInput) (*request.Request, *sagemaker.DeleteInferenceExperimentOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteInferenceExperimentRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.DeleteInferenceExperimentOutput)
	return ret0, ret1
}

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

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

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

// DeleteMlflowTrackingServer mocks base method.
func (m *MockSageMakerAPI) DeleteMlflowTrackingServer(arg0 *sagemaker.DeleteMlflowTrackingServerInput) (*sagemaker.DeleteMlflowTrackingServerOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteMlflowTrackingServer", arg0)
	ret0, _ := ret[0].(*sagemaker.DeleteMlflowTrackingServerOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteMlflowTrackingServerRequest mocks base method.
func (m *MockSageMakerAPI) DeleteMlflowTrackingServerRequest(arg0 *sagemaker.DeleteMlflowTrackingServerInput) (*request.Request, *sagemaker.DeleteMlflowTrackingServerOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteMlflowTrackingServerRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.DeleteMlflowTrackingServerOutput)
	return ret0, ret1
}

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

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

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

// DeleteModel mocks base method.
func (m *MockSageMakerAPI) DeleteModel(arg0 *sagemaker.DeleteModelInput) (*sagemaker.DeleteModelOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteModel", arg0)
	ret0, _ := ret[0].(*sagemaker.DeleteModelOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteModelBiasJobDefinition mocks base method.
func (m *MockSageMakerAPI) DeleteModelBiasJobDefinition(arg0 *sagemaker.DeleteModelBiasJobDefinitionInput) (*sagemaker.DeleteModelBiasJobDefinitionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteModelBiasJobDefinition", arg0)
	ret0, _ := ret[0].(*sagemaker.DeleteModelBiasJobDefinitionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteModelBiasJobDefinitionRequest mocks base method.
func (m *MockSageMakerAPI) DeleteModelBiasJobDefinitionRequest(arg0 *sagemaker.DeleteModelBiasJobDefinitionInput) (*request.Request, *sagemaker.DeleteModelBiasJobDefinitionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteModelBiasJobDefinitionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.DeleteModelBiasJobDefinitionOutput)
	return ret0, ret1
}

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

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

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

// DeleteModelCard mocks base method.
func (m *MockSageMakerAPI) DeleteModelCard(arg0 *sagemaker.DeleteModelCardInput) (*sagemaker.DeleteModelCardOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteModelCard", arg0)
	ret0, _ := ret[0].(*sagemaker.DeleteModelCardOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteModelCardRequest mocks base method.
func (m *MockSageMakerAPI) DeleteModelCardRequest(arg0 *sagemaker.DeleteModelCardInput) (*request.Request, *sagemaker.DeleteModelCardOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteModelCardRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.DeleteModelCardOutput)
	return ret0, ret1
}

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

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

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

// DeleteModelExplainabilityJobDefinition mocks base method.
func (m *MockSageMakerAPI) DeleteModelExplainabilityJobDefinition(arg0 *sagemaker.DeleteModelExplainabilityJobDefinitionInput) (*sagemaker.DeleteModelExplainabilityJobDefinitionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteModelExplainabilityJobDefinition", arg0)
	ret0, _ := ret[0].(*sagemaker.DeleteModelExplainabilityJobDefinitionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteModelExplainabilityJobDefinitionRequest mocks base method.
func (m *MockSageMakerAPI) DeleteModelExplainabilityJobDefinitionRequest(arg0 *sagemaker.DeleteModelExplainabilityJobDefinitionInput) (*request.Request, *sagemaker.DeleteModelExplainabilityJobDefinitionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteModelExplainabilityJobDefinitionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.DeleteModelExplainabilityJobDefinitionOutput)
	return ret0, ret1
}

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

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

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

// DeleteModelPackage mocks base method.
func (m *MockSageMakerAPI) DeleteModelPackage(arg0 *sagemaker.DeleteModelPackageInput) (*sagemaker.DeleteModelPackageOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteModelPackage", arg0)
	ret0, _ := ret[0].(*sagemaker.DeleteModelPackageOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteModelPackageGroup mocks base method.
func (m *MockSageMakerAPI) DeleteModelPackageGroup(arg0 *sagemaker.DeleteModelPackageGroupInput) (*sagemaker.DeleteModelPackageGroupOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteModelPackageGroup", arg0)
	ret0, _ := ret[0].(*sagemaker.DeleteModelPackageGroupOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteModelPackageGroupPolicy mocks base method.
func (m *MockSageMakerAPI) DeleteModelPackageGroupPolicy(arg0 *sagemaker.DeleteModelPackageGroupPolicyInput) (*sagemaker.DeleteModelPackageGroupPolicyOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteModelPackageGroupPolicy", arg0)
	ret0, _ := ret[0].(*sagemaker.DeleteModelPackageGroupPolicyOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteModelPackageGroupPolicyRequest mocks base method.
func (m *MockSageMakerAPI) DeleteModelPackageGroupPolicyRequest(arg0 *sagemaker.DeleteModelPackageGroupPolicyInput) (*request.Request, *sagemaker.DeleteModelPackageGroupPolicyOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteModelPackageGroupPolicyRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.DeleteModelPackageGroupPolicyOutput)
	return ret0, ret1
}

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

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

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

// DeleteModelPackageGroupRequest mocks base method.
func (m *MockSageMakerAPI) DeleteModelPackageGroupRequest(arg0 *sagemaker.DeleteModelPackageGroupInput) (*request.Request, *sagemaker.DeleteModelPackageGroupOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteModelPackageGroupRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.DeleteModelPackageGroupOutput)
	return ret0, ret1
}

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

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

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

// DeleteModelPackageRequest mocks base method.
func (m *MockSageMakerAPI) DeleteModelPackageRequest(arg0 *sagemaker.DeleteModelPackageInput) (*request.Request, *sagemaker.DeleteModelPackageOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteModelPackageRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.DeleteModelPackageOutput)
	return ret0, ret1
}

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

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

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

// DeleteModelQualityJobDefinition mocks base method.
func (m *MockSageMakerAPI) DeleteModelQualityJobDefinition(arg0 *sagemaker.DeleteModelQualityJobDefinitionInput) (*sagemaker.DeleteModelQualityJobDefinitionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteModelQualityJobDefinition", arg0)
	ret0, _ := ret[0].(*sagemaker.DeleteModelQualityJobDefinitionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteModelQualityJobDefinitionRequest mocks base method.
func (m *MockSageMakerAPI) DeleteModelQualityJobDefinitionRequest(arg0 *sagemaker.DeleteModelQualityJobDefinitionInput) (*request.Request, *sagemaker.DeleteModelQualityJobDefinitionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteModelQualityJobDefinitionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.DeleteModelQualityJobDefinitionOutput)
	return ret0, ret1
}

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

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

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

// DeleteModelRequest mocks base method.
func (m *MockSageMakerAPI) DeleteModelRequest(arg0 *sagemaker.DeleteModelInput) (*request.Request, *sagemaker.DeleteModelOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteModelRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.DeleteModelOutput)
	return ret0, ret1
}

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

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

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

// DeleteMonitoringSchedule mocks base method.
func (m *MockSageMakerAPI) DeleteMonitoringSchedule(arg0 *sagemaker.DeleteMonitoringScheduleInput) (*sagemaker.DeleteMonitoringScheduleOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteMonitoringSchedule", arg0)
	ret0, _ := ret[0].(*sagemaker.DeleteMonitoringScheduleOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteMonitoringScheduleRequest mocks base method.
func (m *MockSageMakerAPI) DeleteMonitoringScheduleRequest(arg0 *sagemaker.DeleteMonitoringScheduleInput) (*request.Request, *sagemaker.DeleteMonitoringScheduleOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteMonitoringScheduleRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.DeleteMonitoringScheduleOutput)
	return ret0, ret1
}

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

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

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

// DeleteNotebookInstance mocks base method.
func (m *MockSageMakerAPI) DeleteNotebookInstance(arg0 *sagemaker.DeleteNotebookInstanceInput) (*sagemaker.DeleteNotebookInstanceOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteNotebookInstance", arg0)
	ret0, _ := ret[0].(*sagemaker.DeleteNotebookInstanceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteNotebookInstanceLifecycleConfig mocks base method.
func (m *MockSageMakerAPI) DeleteNotebookInstanceLifecycleConfig(arg0 *sagemaker.DeleteNotebookInstanceLifecycleConfigInput) (*sagemaker.DeleteNotebookInstanceLifecycleConfigOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteNotebookInstanceLifecycleConfig", arg0)
	ret0, _ := ret[0].(*sagemaker.DeleteNotebookInstanceLifecycleConfigOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteNotebookInstanceLifecycleConfigRequest mocks base method.
func (m *MockSageMakerAPI) DeleteNotebookInstanceLifecycleConfigRequest(arg0 *sagemaker.DeleteNotebookInstanceLifecycleConfigInput) (*request.Request, *sagemaker.DeleteNotebookInstanceLifecycleConfigOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteNotebookInstanceLifecycleConfigRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.DeleteNotebookInstanceLifecycleConfigOutput)
	return ret0, ret1
}

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

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

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

// DeleteNotebookInstanceRequest mocks base method.
func (m *MockSageMakerAPI) DeleteNotebookInstanceRequest(arg0 *sagemaker.DeleteNotebookInstanceInput) (*request.Request, *sagemaker.DeleteNotebookInstanceOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteNotebookInstanceRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.DeleteNotebookInstanceOutput)
	return ret0, ret1
}

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

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

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

// DeleteOptimizationJob mocks base method.
func (m *MockSageMakerAPI) DeleteOptimizationJob(arg0 *sagemaker.DeleteOptimizationJobInput) (*sagemaker.DeleteOptimizationJobOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteOptimizationJob", arg0)
	ret0, _ := ret[0].(*sagemaker.DeleteOptimizationJobOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteOptimizationJobRequest mocks base method.
func (m *MockSageMakerAPI) DeleteOptimizationJobRequest(arg0 *sagemaker.DeleteOptimizationJobInput) (*request.Request, *sagemaker.DeleteOptimizationJobOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteOptimizationJobRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.DeleteOptimizationJobOutput)
	return ret0, ret1
}

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

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

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

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

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

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

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

// DeletePipelineWithContext mocks base method.
func (m *MockSageMakerAPI) DeletePipelineWithContext(arg0 aws.Context, arg1 *sagemaker.DeletePipelineInput, arg2 ...request.Option) (*sagemaker.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].(*sagemaker.DeletePipelineOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteProject mocks base method.
func (m *MockSageMakerAPI) DeleteProject(arg0 *sagemaker.DeleteProjectInput) (*sagemaker.DeleteProjectOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteProject", arg0)
	ret0, _ := ret[0].(*sagemaker.DeleteProjectOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteProjectRequest mocks base method.
func (m *MockSageMakerAPI) DeleteProjectRequest(arg0 *sagemaker.DeleteProjectInput) (*request.Request, *sagemaker.DeleteProjectOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteProjectRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.DeleteProjectOutput)
	return ret0, ret1
}

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

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

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

// DeleteSpace mocks base method.
func (m *MockSageMakerAPI) DeleteSpace(arg0 *sagemaker.DeleteSpaceInput) (*sagemaker.DeleteSpaceOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteSpace", arg0)
	ret0, _ := ret[0].(*sagemaker.DeleteSpaceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteSpaceRequest mocks base method.
func (m *MockSageMakerAPI) DeleteSpaceRequest(arg0 *sagemaker.DeleteSpaceInput) (*request.Request, *sagemaker.DeleteSpaceOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteSpaceRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.DeleteSpaceOutput)
	return ret0, ret1
}

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

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

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

// DeleteStudioLifecycleConfig mocks base method.
func (m *MockSageMakerAPI) DeleteStudioLifecycleConfig(arg0 *sagemaker.DeleteStudioLifecycleConfigInput) (*sagemaker.DeleteStudioLifecycleConfigOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteStudioLifecycleConfig", arg0)
	ret0, _ := ret[0].(*sagemaker.DeleteStudioLifecycleConfigOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteStudioLifecycleConfigRequest mocks base method.
func (m *MockSageMakerAPI) DeleteStudioLifecycleConfigRequest(arg0 *sagemaker.DeleteStudioLifecycleConfigInput) (*request.Request, *sagemaker.DeleteStudioLifecycleConfigOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteStudioLifecycleConfigRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.DeleteStudioLifecycleConfigOutput)
	return ret0, ret1
}

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

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

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

// DeleteTags mocks base method.
func (m *MockSageMakerAPI) DeleteTags(arg0 *sagemaker.DeleteTagsInput) (*sagemaker.DeleteTagsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteTags", arg0)
	ret0, _ := ret[0].(*sagemaker.DeleteTagsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteTagsRequest mocks base method.
func (m *MockSageMakerAPI) DeleteTagsRequest(arg0 *sagemaker.DeleteTagsInput) (*request.Request, *sagemaker.DeleteTagsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteTagsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.DeleteTagsOutput)
	return ret0, ret1
}

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

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

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

// DeleteTrial mocks base method.
func (m *MockSageMakerAPI) DeleteTrial(arg0 *sagemaker.DeleteTrialInput) (*sagemaker.DeleteTrialOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteTrial", arg0)
	ret0, _ := ret[0].(*sagemaker.DeleteTrialOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteTrialComponent mocks base method.
func (m *MockSageMakerAPI) DeleteTrialComponent(arg0 *sagemaker.DeleteTrialComponentInput) (*sagemaker.DeleteTrialComponentOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteTrialComponent", arg0)
	ret0, _ := ret[0].(*sagemaker.DeleteTrialComponentOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteTrialComponentRequest mocks base method.
func (m *MockSageMakerAPI) DeleteTrialComponentRequest(arg0 *sagemaker.DeleteTrialComponentInput) (*request.Request, *sagemaker.DeleteTrialComponentOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteTrialComponentRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.DeleteTrialComponentOutput)
	return ret0, ret1
}

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

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

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

// DeleteTrialRequest mocks base method.
func (m *MockSageMakerAPI) DeleteTrialRequest(arg0 *sagemaker.DeleteTrialInput) (*request.Request, *sagemaker.DeleteTrialOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteTrialRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.DeleteTrialOutput)
	return ret0, ret1
}

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

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

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

// DeleteUserProfile mocks base method.
func (m *MockSageMakerAPI) DeleteUserProfile(arg0 *sagemaker.DeleteUserProfileInput) (*sagemaker.DeleteUserProfileOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteUserProfile", arg0)
	ret0, _ := ret[0].(*sagemaker.DeleteUserProfileOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteUserProfileRequest mocks base method.
func (m *MockSageMakerAPI) DeleteUserProfileRequest(arg0 *sagemaker.DeleteUserProfileInput) (*request.Request, *sagemaker.DeleteUserProfileOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteUserProfileRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.DeleteUserProfileOutput)
	return ret0, ret1
}

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

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

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

// DeleteWorkforce mocks base method.
func (m *MockSageMakerAPI) DeleteWorkforce(arg0 *sagemaker.DeleteWorkforceInput) (*sagemaker.DeleteWorkforceOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteWorkforce", arg0)
	ret0, _ := ret[0].(*sagemaker.DeleteWorkforceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteWorkforceRequest mocks base method.
func (m *MockSageMakerAPI) DeleteWorkforceRequest(arg0 *sagemaker.DeleteWorkforceInput) (*request.Request, *sagemaker.DeleteWorkforceOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteWorkforceRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.DeleteWorkforceOutput)
	return ret0, ret1
}

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

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

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

// DeleteWorkteam mocks base method.
func (m *MockSageMakerAPI) DeleteWorkteam(arg0 *sagemaker.DeleteWorkteamInput) (*sagemaker.DeleteWorkteamOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteWorkteam", arg0)
	ret0, _ := ret[0].(*sagemaker.DeleteWorkteamOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteWorkteamRequest mocks base method.
func (m *MockSageMakerAPI) DeleteWorkteamRequest(arg0 *sagemaker.DeleteWorkteamInput) (*request.Request, *sagemaker.DeleteWorkteamOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteWorkteamRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.DeleteWorkteamOutput)
	return ret0, ret1
}

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

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

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

// DeregisterDevices mocks base method.
func (m *MockSageMakerAPI) DeregisterDevices(arg0 *sagemaker.DeregisterDevicesInput) (*sagemaker.DeregisterDevicesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeregisterDevices", arg0)
	ret0, _ := ret[0].(*sagemaker.DeregisterDevicesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeregisterDevicesRequest mocks base method.
func (m *MockSageMakerAPI) DeregisterDevicesRequest(arg0 *sagemaker.DeregisterDevicesInput) (*request.Request, *sagemaker.DeregisterDevicesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeregisterDevicesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.DeregisterDevicesOutput)
	return ret0, ret1
}

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

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

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

// DescribeAction mocks base method.
func (m *MockSageMakerAPI) DescribeAction(arg0 *sagemaker.DescribeActionInput) (*sagemaker.DescribeActionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeAction", arg0)
	ret0, _ := ret[0].(*sagemaker.DescribeActionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeActionRequest mocks base method.
func (m *MockSageMakerAPI) DescribeActionRequest(arg0 *sagemaker.DescribeActionInput) (*request.Request, *sagemaker.DescribeActionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeActionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.DescribeActionOutput)
	return ret0, ret1
}

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

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

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

// DescribeAlgorithm mocks base method.
func (m *MockSageMakerAPI) DescribeAlgorithm(arg0 *sagemaker.DescribeAlgorithmInput) (*sagemaker.DescribeAlgorithmOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeAlgorithm", arg0)
	ret0, _ := ret[0].(*sagemaker.DescribeAlgorithmOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeAlgorithmRequest mocks base method.
func (m *MockSageMakerAPI) DescribeAlgorithmRequest(arg0 *sagemaker.DescribeAlgorithmInput) (*request.Request, *sagemaker.DescribeAlgorithmOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeAlgorithmRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.DescribeAlgorithmOutput)
	return ret0, ret1
}

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

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

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

// DescribeApp mocks base method.
func (m *MockSageMakerAPI) DescribeApp(arg0 *sagemaker.DescribeAppInput) (*sagemaker.DescribeAppOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeApp", arg0)
	ret0, _ := ret[0].(*sagemaker.DescribeAppOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeAppImageConfig mocks base method.
func (m *MockSageMakerAPI) DescribeAppImageConfig(arg0 *sagemaker.DescribeAppImageConfigInput) (*sagemaker.DescribeAppImageConfigOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeAppImageConfig", arg0)
	ret0, _ := ret[0].(*sagemaker.DescribeAppImageConfigOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeAppImageConfigRequest mocks base method.
func (m *MockSageMakerAPI) DescribeAppImageConfigRequest(arg0 *sagemaker.DescribeAppImageConfigInput) (*request.Request, *sagemaker.DescribeAppImageConfigOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeAppImageConfigRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.DescribeAppImageConfigOutput)
	return ret0, ret1
}

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

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

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

// DescribeAppRequest mocks base method.
func (m *MockSageMakerAPI) DescribeAppRequest(arg0 *sagemaker.DescribeAppInput) (*request.Request, *sagemaker.DescribeAppOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeAppRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.DescribeAppOutput)
	return ret0, ret1
}

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

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

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

// DescribeArtifact mocks base method.
func (m *MockSageMakerAPI) DescribeArtifact(arg0 *sagemaker.DescribeArtifactInput) (*sagemaker.DescribeArtifactOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeArtifact", arg0)
	ret0, _ := ret[0].(*sagemaker.DescribeArtifactOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeArtifactRequest mocks base method.
func (m *MockSageMakerAPI) DescribeArtifactRequest(arg0 *sagemaker.DescribeArtifactInput) (*request.Request, *sagemaker.DescribeArtifactOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeArtifactRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.DescribeArtifactOutput)
	return ret0, ret1
}

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

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

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

// DescribeAutoMLJob mocks base method.
func (m *MockSageMakerAPI) DescribeAutoMLJob(arg0 *sagemaker.DescribeAutoMLJobInput) (*sagemaker.DescribeAutoMLJobOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeAutoMLJob", arg0)
	ret0, _ := ret[0].(*sagemaker.DescribeAutoMLJobOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeAutoMLJobRequest mocks base method.
func (m *MockSageMakerAPI) DescribeAutoMLJobRequest(arg0 *sagemaker.DescribeAutoMLJobInput) (*request.Request, *sagemaker.DescribeAutoMLJobOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeAutoMLJobRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.DescribeAutoMLJobOutput)
	return ret0, ret1
}

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

// DescribeAutoMLJobV2 mocks base method.
func (m *MockSageMakerAPI) DescribeAutoMLJobV2(arg0 *sagemaker.DescribeAutoMLJobV2Input) (*sagemaker.DescribeAutoMLJobV2Output, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeAutoMLJobV2", arg0)
	ret0, _ := ret[0].(*sagemaker.DescribeAutoMLJobV2Output)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeAutoMLJobV2Request mocks base method.
func (m *MockSageMakerAPI) DescribeAutoMLJobV2Request(arg0 *sagemaker.DescribeAutoMLJobV2Input) (*request.Request, *sagemaker.DescribeAutoMLJobV2Output) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeAutoMLJobV2Request", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.DescribeAutoMLJobV2Output)
	return ret0, ret1
}

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

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

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

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

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

// DescribeCluster mocks base method.
func (m *MockSageMakerAPI) DescribeCluster(arg0 *sagemaker.DescribeClusterInput) (*sagemaker.DescribeClusterOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeCluster", arg0)
	ret0, _ := ret[0].(*sagemaker.DescribeClusterOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeClusterNode mocks base method.
func (m *MockSageMakerAPI) DescribeClusterNode(arg0 *sagemaker.DescribeClusterNodeInput) (*sagemaker.DescribeClusterNodeOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeClusterNode", arg0)
	ret0, _ := ret[0].(*sagemaker.DescribeClusterNodeOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeClusterNodeRequest mocks base method.
func (m *MockSageMakerAPI) DescribeClusterNodeRequest(arg0 *sagemaker.DescribeClusterNodeInput) (*request.Request, *sagemaker.DescribeClusterNodeOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeClusterNodeRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.DescribeClusterNodeOutput)
	return ret0, ret1
}

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

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

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

// DescribeClusterRequest mocks base method.
func (m *MockSageMakerAPI) DescribeClusterRequest(arg0 *sagemaker.DescribeClusterInput) (*request.Request, *sagemaker.DescribeClusterOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeClusterRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.DescribeClusterOutput)
	return ret0, ret1
}

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

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

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

// DescribeCodeRepository mocks base method.
func (m *MockSageMakerAPI) DescribeCodeRepository(arg0 *sagemaker.DescribeCodeRepositoryInput) (*sagemaker.DescribeCodeRepositoryOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeCodeRepository", arg0)
	ret0, _ := ret[0].(*sagemaker.DescribeCodeRepositoryOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeCodeRepositoryRequest mocks base method.
func (m *MockSageMakerAPI) DescribeCodeRepositoryRequest(arg0 *sagemaker.DescribeCodeRepositoryInput) (*request.Request, *sagemaker.DescribeCodeRepositoryOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeCodeRepositoryRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.DescribeCodeRepositoryOutput)
	return ret0, ret1
}

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

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

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

// DescribeCompilationJob mocks base method.
func (m *MockSageMakerAPI) DescribeCompilationJob(arg0 *sagemaker.DescribeCompilationJobInput) (*sagemaker.DescribeCompilationJobOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeCompilationJob", arg0)
	ret0, _ := ret[0].(*sagemaker.DescribeCompilationJobOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeCompilationJobRequest mocks base method.
func (m *MockSageMakerAPI) DescribeCompilationJobRequest(arg0 *sagemaker.DescribeCompilationJobInput) (*request.Request, *sagemaker.DescribeCompilationJobOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeCompilationJobRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.DescribeCompilationJobOutput)
	return ret0, ret1
}

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

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

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

// DescribeContext mocks base method.
func (m *MockSageMakerAPI) DescribeContext(arg0 *sagemaker.DescribeContextInput) (*sagemaker.DescribeContextOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeContext", arg0)
	ret0, _ := ret[0].(*sagemaker.DescribeContextOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeContextRequest mocks base method.
func (m *MockSageMakerAPI) DescribeContextRequest(arg0 *sagemaker.DescribeContextInput) (*request.Request, *sagemaker.DescribeContextOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeContextRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.DescribeContextOutput)
	return ret0, ret1
}

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

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

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

// DescribeDataQualityJobDefinition mocks base method.
func (m *MockSageMakerAPI) DescribeDataQualityJobDefinition(arg0 *sagemaker.DescribeDataQualityJobDefinitionInput) (*sagemaker.DescribeDataQualityJobDefinitionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeDataQualityJobDefinition", arg0)
	ret0, _ := ret[0].(*sagemaker.DescribeDataQualityJobDefinitionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeDataQualityJobDefinitionRequest mocks base method.
func (m *MockSageMakerAPI) DescribeDataQualityJobDefinitionRequest(arg0 *sagemaker.DescribeDataQualityJobDefinitionInput) (*request.Request, *sagemaker.DescribeDataQualityJobDefinitionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeDataQualityJobDefinitionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.DescribeDataQualityJobDefinitionOutput)
	return ret0, ret1
}

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

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

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

// DescribeDevice mocks base method.
func (m *MockSageMakerAPI) DescribeDevice(arg0 *sagemaker.DescribeDeviceInput) (*sagemaker.DescribeDeviceOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeDevice", arg0)
	ret0, _ := ret[0].(*sagemaker.DescribeDeviceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeDeviceFleet mocks base method.
func (m *MockSageMakerAPI) DescribeDeviceFleet(arg0 *sagemaker.DescribeDeviceFleetInput) (*sagemaker.DescribeDeviceFleetOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeDeviceFleet", arg0)
	ret0, _ := ret[0].(*sagemaker.DescribeDeviceFleetOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeDeviceFleetRequest mocks base method.
func (m *MockSageMakerAPI) DescribeDeviceFleetRequest(arg0 *sagemaker.DescribeDeviceFleetInput) (*request.Request, *sagemaker.DescribeDeviceFleetOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeDeviceFleetRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.DescribeDeviceFleetOutput)
	return ret0, ret1
}

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

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

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

// DescribeDeviceRequest mocks base method.
func (m *MockSageMakerAPI) DescribeDeviceRequest(arg0 *sagemaker.DescribeDeviceInput) (*request.Request, *sagemaker.DescribeDeviceOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeDeviceRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.DescribeDeviceOutput)
	return ret0, ret1
}

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

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

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

// DescribeDomain mocks base method.
func (m *MockSageMakerAPI) DescribeDomain(arg0 *sagemaker.DescribeDomainInput) (*sagemaker.DescribeDomainOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeDomain", arg0)
	ret0, _ := ret[0].(*sagemaker.DescribeDomainOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeDomainRequest mocks base method.
func (m *MockSageMakerAPI) DescribeDomainRequest(arg0 *sagemaker.DescribeDomainInput) (*request.Request, *sagemaker.DescribeDomainOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeDomainRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.DescribeDomainOutput)
	return ret0, ret1
}

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

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

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

// DescribeEdgeDeploymentPlan mocks base method.
func (m *MockSageMakerAPI) DescribeEdgeDeploymentPlan(arg0 *sagemaker.DescribeEdgeDeploymentPlanInput) (*sagemaker.DescribeEdgeDeploymentPlanOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeEdgeDeploymentPlan", arg0)
	ret0, _ := ret[0].(*sagemaker.DescribeEdgeDeploymentPlanOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeEdgeDeploymentPlanRequest mocks base method.
func (m *MockSageMakerAPI) DescribeEdgeDeploymentPlanRequest(arg0 *sagemaker.DescribeEdgeDeploymentPlanInput) (*request.Request, *sagemaker.DescribeEdgeDeploymentPlanOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeEdgeDeploymentPlanRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.DescribeEdgeDeploymentPlanOutput)
	return ret0, ret1
}

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

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

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

// DescribeEdgePackagingJob mocks base method.
func (m *MockSageMakerAPI) DescribeEdgePackagingJob(arg0 *sagemaker.DescribeEdgePackagingJobInput) (*sagemaker.DescribeEdgePackagingJobOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeEdgePackagingJob", arg0)
	ret0, _ := ret[0].(*sagemaker.DescribeEdgePackagingJobOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeEdgePackagingJobRequest mocks base method.
func (m *MockSageMakerAPI) DescribeEdgePackagingJobRequest(arg0 *sagemaker.DescribeEdgePackagingJobInput) (*request.Request, *sagemaker.DescribeEdgePackagingJobOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeEdgePackagingJobRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.DescribeEdgePackagingJobOutput)
	return ret0, ret1
}

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

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

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

// DescribeEndpoint mocks base method.
func (m *MockSageMakerAPI) DescribeEndpoint(arg0 *sagemaker.DescribeEndpointInput) (*sagemaker.DescribeEndpointOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeEndpoint", arg0)
	ret0, _ := ret[0].(*sagemaker.DescribeEndpointOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeEndpointConfig mocks base method.
func (m *MockSageMakerAPI) DescribeEndpointConfig(arg0 *sagemaker.DescribeEndpointConfigInput) (*sagemaker.DescribeEndpointConfigOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeEndpointConfig", arg0)
	ret0, _ := ret[0].(*sagemaker.DescribeEndpointConfigOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeEndpointConfigRequest mocks base method.
func (m *MockSageMakerAPI) DescribeEndpointConfigRequest(arg0 *sagemaker.DescribeEndpointConfigInput) (*request.Request, *sagemaker.DescribeEndpointConfigOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeEndpointConfigRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.DescribeEndpointConfigOutput)
	return ret0, ret1
}

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

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

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

// DescribeEndpointRequest mocks base method.
func (m *MockSageMakerAPI) DescribeEndpointRequest(arg0 *sagemaker.DescribeEndpointInput) (*request.Request, *sagemaker.DescribeEndpointOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeEndpointRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.DescribeEndpointOutput)
	return ret0, ret1
}

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

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

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

// DescribeExperiment mocks base method.
func (m *MockSageMakerAPI) DescribeExperiment(arg0 *sagemaker.DescribeExperimentInput) (*sagemaker.DescribeExperimentOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeExperiment", arg0)
	ret0, _ := ret[0].(*sagemaker.DescribeExperimentOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeExperimentRequest mocks base method.
func (m *MockSageMakerAPI) DescribeExperimentRequest(arg0 *sagemaker.DescribeExperimentInput) (*request.Request, *sagemaker.DescribeExperimentOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeExperimentRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.DescribeExperimentOutput)
	return ret0, ret1
}

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

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

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

// DescribeFeatureGroup mocks base method.
func (m *MockSageMakerAPI) DescribeFeatureGroup(arg0 *sagemaker.DescribeFeatureGroupInput) (*sagemaker.DescribeFeatureGroupOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeFeatureGroup", arg0)
	ret0, _ := ret[0].(*sagemaker.DescribeFeatureGroupOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeFeatureGroupRequest mocks base method.
func (m *MockSageMakerAPI) DescribeFeatureGroupRequest(arg0 *sagemaker.DescribeFeatureGroupInput) (*request.Request, *sagemaker.DescribeFeatureGroupOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeFeatureGroupRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.DescribeFeatureGroupOutput)
	return ret0, ret1
}

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

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

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

// DescribeFeatureMetadata mocks base method.
func (m *MockSageMakerAPI) DescribeFeatureMetadata(arg0 *sagemaker.DescribeFeatureMetadataInput) (*sagemaker.DescribeFeatureMetadataOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeFeatureMetadata", arg0)
	ret0, _ := ret[0].(*sagemaker.DescribeFeatureMetadataOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeFeatureMetadataRequest mocks base method.
func (m *MockSageMakerAPI) DescribeFeatureMetadataRequest(arg0 *sagemaker.DescribeFeatureMetadataInput) (*request.Request, *sagemaker.DescribeFeatureMetadataOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeFeatureMetadataRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.DescribeFeatureMetadataOutput)
	return ret0, ret1
}

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

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

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

// DescribeFlowDefinition mocks base method.
func (m *MockSageMakerAPI) DescribeFlowDefinition(arg0 *sagemaker.DescribeFlowDefinitionInput) (*sagemaker.DescribeFlowDefinitionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeFlowDefinition", arg0)
	ret0, _ := ret[0].(*sagemaker.DescribeFlowDefinitionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeFlowDefinitionRequest mocks base method.
func (m *MockSageMakerAPI) DescribeFlowDefinitionRequest(arg0 *sagemaker.DescribeFlowDefinitionInput) (*request.Request, *sagemaker.DescribeFlowDefinitionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeFlowDefinitionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.DescribeFlowDefinitionOutput)
	return ret0, ret1
}

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

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

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

// DescribeHub mocks base method.
func (m *MockSageMakerAPI) DescribeHub(arg0 *sagemaker.DescribeHubInput) (*sagemaker.DescribeHubOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeHub", arg0)
	ret0, _ := ret[0].(*sagemaker.DescribeHubOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeHubContent mocks base method.
func (m *MockSageMakerAPI) DescribeHubContent(arg0 *sagemaker.DescribeHubContentInput) (*sagemaker.DescribeHubContentOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeHubContent", arg0)
	ret0, _ := ret[0].(*sagemaker.DescribeHubContentOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeHubContentRequest mocks base method.
func (m *MockSageMakerAPI) DescribeHubContentRequest(arg0 *sagemaker.DescribeHubContentInput) (*request.Request, *sagemaker.DescribeHubContentOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeHubContentRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.DescribeHubContentOutput)
	return ret0, ret1
}

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

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

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

// DescribeHubRequest mocks base method.
func (m *MockSageMakerAPI) DescribeHubRequest(arg0 *sagemaker.DescribeHubInput) (*request.Request, *sagemaker.DescribeHubOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeHubRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.DescribeHubOutput)
	return ret0, ret1
}

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

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

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

// DescribeHumanTaskUi mocks base method.
func (m *MockSageMakerAPI) DescribeHumanTaskUi(arg0 *sagemaker.DescribeHumanTaskUiInput) (*sagemaker.DescribeHumanTaskUiOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeHumanTaskUi", arg0)
	ret0, _ := ret[0].(*sagemaker.DescribeHumanTaskUiOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeHumanTaskUiRequest mocks base method.
func (m *MockSageMakerAPI) DescribeHumanTaskUiRequest(arg0 *sagemaker.DescribeHumanTaskUiInput) (*request.Request, *sagemaker.DescribeHumanTaskUiOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeHumanTaskUiRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.DescribeHumanTaskUiOutput)
	return ret0, ret1
}

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

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

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

// DescribeHyperParameterTuningJob mocks base method.
func (m *MockSageMakerAPI) DescribeHyperParameterTuningJob(arg0 *sagemaker.DescribeHyperParameterTuningJobInput) (*sagemaker.DescribeHyperParameterTuningJobOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeHyperParameterTuningJob", arg0)
	ret0, _ := ret[0].(*sagemaker.DescribeHyperParameterTuningJobOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeHyperParameterTuningJobRequest mocks base method.
func (m *MockSageMakerAPI) DescribeHyperParameterTuningJobRequest(arg0 *sagemaker.DescribeHyperParameterTuningJobInput) (*request.Request, *sagemaker.DescribeHyperParameterTuningJobOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeHyperParameterTuningJobRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.DescribeHyperParameterTuningJobOutput)
	return ret0, ret1
}

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

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

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

// DescribeImage mocks base method.
func (m *MockSageMakerAPI) DescribeImage(arg0 *sagemaker.DescribeImageInput) (*sagemaker.DescribeImageOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeImage", arg0)
	ret0, _ := ret[0].(*sagemaker.DescribeImageOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeImageRequest mocks base method.
func (m *MockSageMakerAPI) DescribeImageRequest(arg0 *sagemaker.DescribeImageInput) (*request.Request, *sagemaker.DescribeImageOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeImageRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.DescribeImageOutput)
	return ret0, ret1
}

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

// DescribeImageVersion mocks base method.
func (m *MockSageMakerAPI) DescribeImageVersion(arg0 *sagemaker.DescribeImageVersionInput) (*sagemaker.DescribeImageVersionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeImageVersion", arg0)
	ret0, _ := ret[0].(*sagemaker.DescribeImageVersionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeImageVersionRequest mocks base method.
func (m *MockSageMakerAPI) DescribeImageVersionRequest(arg0 *sagemaker.DescribeImageVersionInput) (*request.Request, *sagemaker.DescribeImageVersionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeImageVersionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.DescribeImageVersionOutput)
	return ret0, ret1
}

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

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

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

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

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

// DescribeInferenceComponent mocks base method.
func (m *MockSageMakerAPI) DescribeInferenceComponent(arg0 *sagemaker.DescribeInferenceComponentInput) (*sagemaker.DescribeInferenceComponentOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeInferenceComponent", arg0)
	ret0, _ := ret[0].(*sagemaker.DescribeInferenceComponentOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeInferenceComponentRequest mocks base method.
func (m *MockSageMakerAPI) DescribeInferenceComponentRequest(arg0 *sagemaker.DescribeInferenceComponentInput) (*request.Request, *sagemaker.DescribeInferenceComponentOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeInferenceComponentRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.DescribeInferenceComponentOutput)
	return ret0, ret1
}

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

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

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

// DescribeInferenceExperiment mocks base method.
func (m *MockSageMakerAPI) DescribeInferenceExperiment(arg0 *sagemaker.DescribeInferenceExperimentInput) (*sagemaker.DescribeInferenceExperimentOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeInferenceExperiment", arg0)
	ret0, _ := ret[0].(*sagemaker.DescribeInferenceExperimentOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeInferenceExperimentRequest mocks base method.
func (m *MockSageMakerAPI) DescribeInferenceExperimentRequest(arg0 *sagemaker.DescribeInferenceExperimentInput) (*request.Request, *sagemaker.DescribeInferenceExperimentOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeInferenceExperimentRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.DescribeInferenceExperimentOutput)
	return ret0, ret1
}

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

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

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

// DescribeInferenceRecommendationsJob mocks base method.
func (m *MockSageMakerAPI) DescribeInferenceRecommendationsJob(arg0 *sagemaker.DescribeInferenceRecommendationsJobInput) (*sagemaker.DescribeInferenceRecommendationsJobOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeInferenceRecommendationsJob", arg0)
	ret0, _ := ret[0].(*sagemaker.DescribeInferenceRecommendationsJobOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeInferenceRecommendationsJobRequest mocks base method.
func (m *MockSageMakerAPI) DescribeInferenceRecommendationsJobRequest(arg0 *sagemaker.DescribeInferenceRecommendationsJobInput) (*request.Request, *sagemaker.DescribeInferenceRecommendationsJobOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeInferenceRecommendationsJobRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.DescribeInferenceRecommendationsJobOutput)
	return ret0, ret1
}

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

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

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

// DescribeLabelingJob mocks base method.
func (m *MockSageMakerAPI) DescribeLabelingJob(arg0 *sagemaker.DescribeLabelingJobInput) (*sagemaker.DescribeLabelingJobOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeLabelingJob", arg0)
	ret0, _ := ret[0].(*sagemaker.DescribeLabelingJobOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeLabelingJobRequest mocks base method.
func (m *MockSageMakerAPI) DescribeLabelingJobRequest(arg0 *sagemaker.DescribeLabelingJobInput) (*request.Request, *sagemaker.DescribeLabelingJobOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeLabelingJobRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.DescribeLabelingJobOutput)
	return ret0, ret1
}

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

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

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

// DescribeLineageGroup mocks base method.
func (m *MockSageMakerAPI) DescribeLineageGroup(arg0 *sagemaker.DescribeLineageGroupInput) (*sagemaker.DescribeLineageGroupOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeLineageGroup", arg0)
	ret0, _ := ret[0].(*sagemaker.DescribeLineageGroupOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeLineageGroupRequest mocks base method.
func (m *MockSageMakerAPI) DescribeLineageGroupRequest(arg0 *sagemaker.DescribeLineageGroupInput) (*request.Request, *sagemaker.DescribeLineageGroupOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeLineageGroupRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.DescribeLineageGroupOutput)
	return ret0, ret1
}

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

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

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

// DescribeMlflowTrackingServer mocks base method.
func (m *MockSageMakerAPI) DescribeMlflowTrackingServer(arg0 *sagemaker.DescribeMlflowTrackingServerInput) (*sagemaker.DescribeMlflowTrackingServerOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeMlflowTrackingServer", arg0)
	ret0, _ := ret[0].(*sagemaker.DescribeMlflowTrackingServerOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeMlflowTrackingServerRequest mocks base method.
func (m *MockSageMakerAPI) DescribeMlflowTrackingServerRequest(arg0 *sagemaker.DescribeMlflowTrackingServerInput) (*request.Request, *sagemaker.DescribeMlflowTrackingServerOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeMlflowTrackingServerRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.DescribeMlflowTrackingServerOutput)
	return ret0, ret1
}

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

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

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

// DescribeModel mocks base method.
func (m *MockSageMakerAPI) DescribeModel(arg0 *sagemaker.DescribeModelInput) (*sagemaker.DescribeModelOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeModel", arg0)
	ret0, _ := ret[0].(*sagemaker.DescribeModelOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeModelBiasJobDefinition mocks base method.
func (m *MockSageMakerAPI) DescribeModelBiasJobDefinition(arg0 *sagemaker.DescribeModelBiasJobDefinitionInput) (*sagemaker.DescribeModelBiasJobDefinitionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeModelBiasJobDefinition", arg0)
	ret0, _ := ret[0].(*sagemaker.DescribeModelBiasJobDefinitionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeModelBiasJobDefinitionRequest mocks base method.
func (m *MockSageMakerAPI) DescribeModelBiasJobDefinitionRequest(arg0 *sagemaker.DescribeModelBiasJobDefinitionInput) (*request.Request, *sagemaker.DescribeModelBiasJobDefinitionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeModelBiasJobDefinitionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.DescribeModelBiasJobDefinitionOutput)
	return ret0, ret1
}

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

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

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

// DescribeModelCard mocks base method.
func (m *MockSageMakerAPI) DescribeModelCard(arg0 *sagemaker.DescribeModelCardInput) (*sagemaker.DescribeModelCardOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeModelCard", arg0)
	ret0, _ := ret[0].(*sagemaker.DescribeModelCardOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeModelCardExportJob mocks base method.
func (m *MockSageMakerAPI) DescribeModelCardExportJob(arg0 *sagemaker.DescribeModelCardExportJobInput) (*sagemaker.DescribeModelCardExportJobOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeModelCardExportJob", arg0)
	ret0, _ := ret[0].(*sagemaker.DescribeModelCardExportJobOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeModelCardExportJobRequest mocks base method.
func (m *MockSageMakerAPI) DescribeModelCardExportJobRequest(arg0 *sagemaker.DescribeModelCardExportJobInput) (*request.Request, *sagemaker.DescribeModelCardExportJobOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeModelCardExportJobRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.DescribeModelCardExportJobOutput)
	return ret0, ret1
}

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

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

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

// DescribeModelCardRequest mocks base method.
func (m *MockSageMakerAPI) DescribeModelCardRequest(arg0 *sagemaker.DescribeModelCardInput) (*request.Request, *sagemaker.DescribeModelCardOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeModelCardRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.DescribeModelCardOutput)
	return ret0, ret1
}

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

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

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

// DescribeModelExplainabilityJobDefinition mocks base method.
func (m *MockSageMakerAPI) DescribeModelExplainabilityJobDefinition(arg0 *sagemaker.DescribeModelExplainabilityJobDefinitionInput) (*sagemaker.DescribeModelExplainabilityJobDefinitionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeModelExplainabilityJobDefinition", arg0)
	ret0, _ := ret[0].(*sagemaker.DescribeModelExplainabilityJobDefinitionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeModelExplainabilityJobDefinitionRequest mocks base method.
func (m *MockSageMakerAPI) DescribeModelExplainabilityJobDefinitionRequest(arg0 *sagemaker.DescribeModelExplainabilityJobDefinitionInput) (*request.Request, *sagemaker.DescribeModelExplainabilityJobDefinitionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeModelExplainabilityJobDefinitionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.DescribeModelExplainabilityJobDefinitionOutput)
	return ret0, ret1
}

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

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

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

// DescribeModelPackage mocks base method.
func (m *MockSageMakerAPI) DescribeModelPackage(arg0 *sagemaker.DescribeModelPackageInput) (*sagemaker.DescribeModelPackageOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeModelPackage", arg0)
	ret0, _ := ret[0].(*sagemaker.DescribeModelPackageOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeModelPackageGroup mocks base method.
func (m *MockSageMakerAPI) DescribeModelPackageGroup(arg0 *sagemaker.DescribeModelPackageGroupInput) (*sagemaker.DescribeModelPackageGroupOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeModelPackageGroup", arg0)
	ret0, _ := ret[0].(*sagemaker.DescribeModelPackageGroupOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeModelPackageGroupRequest mocks base method.
func (m *MockSageMakerAPI) DescribeModelPackageGroupRequest(arg0 *sagemaker.DescribeModelPackageGroupInput) (*request.Request, *sagemaker.DescribeModelPackageGroupOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeModelPackageGroupRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.DescribeModelPackageGroupOutput)
	return ret0, ret1
}

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

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

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

// DescribeModelPackageRequest mocks base method.
func (m *MockSageMakerAPI) DescribeModelPackageRequest(arg0 *sagemaker.DescribeModelPackageInput) (*request.Request, *sagemaker.DescribeModelPackageOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeModelPackageRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.DescribeModelPackageOutput)
	return ret0, ret1
}

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

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

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

// DescribeModelQualityJobDefinition mocks base method.
func (m *MockSageMakerAPI) DescribeModelQualityJobDefinition(arg0 *sagemaker.DescribeModelQualityJobDefinitionInput) (*sagemaker.DescribeModelQualityJobDefinitionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeModelQualityJobDefinition", arg0)
	ret0, _ := ret[0].(*sagemaker.DescribeModelQualityJobDefinitionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeModelQualityJobDefinitionRequest mocks base method.
func (m *MockSageMakerAPI) DescribeModelQualityJobDefinitionRequest(arg0 *sagemaker.DescribeModelQualityJobDefinitionInput) (*request.Request, *sagemaker.DescribeModelQualityJobDefinitionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeModelQualityJobDefinitionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.DescribeModelQualityJobDefinitionOutput)
	return ret0, ret1
}

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

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

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

// DescribeModelRequest mocks base method.
func (m *MockSageMakerAPI) DescribeModelRequest(arg0 *sagemaker.DescribeModelInput) (*request.Request, *sagemaker.DescribeModelOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeModelRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.DescribeModelOutput)
	return ret0, ret1
}

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

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

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

// DescribeMonitoringSchedule mocks base method.
func (m *MockSageMakerAPI) DescribeMonitoringSchedule(arg0 *sagemaker.DescribeMonitoringScheduleInput) (*sagemaker.DescribeMonitoringScheduleOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeMonitoringSchedule", arg0)
	ret0, _ := ret[0].(*sagemaker.DescribeMonitoringScheduleOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeMonitoringScheduleRequest mocks base method.
func (m *MockSageMakerAPI) DescribeMonitoringScheduleRequest(arg0 *sagemaker.DescribeMonitoringScheduleInput) (*request.Request, *sagemaker.DescribeMonitoringScheduleOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeMonitoringScheduleRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.DescribeMonitoringScheduleOutput)
	return ret0, ret1
}

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

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

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

// DescribeNotebookInstance mocks base method.
func (m *MockSageMakerAPI) DescribeNotebookInstance(arg0 *sagemaker.DescribeNotebookInstanceInput) (*sagemaker.DescribeNotebookInstanceOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeNotebookInstance", arg0)
	ret0, _ := ret[0].(*sagemaker.DescribeNotebookInstanceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeNotebookInstanceLifecycleConfig mocks base method.
func (m *MockSageMakerAPI) DescribeNotebookInstanceLifecycleConfig(arg0 *sagemaker.DescribeNotebookInstanceLifecycleConfigInput) (*sagemaker.DescribeNotebookInstanceLifecycleConfigOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeNotebookInstanceLifecycleConfig", arg0)
	ret0, _ := ret[0].(*sagemaker.DescribeNotebookInstanceLifecycleConfigOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeNotebookInstanceLifecycleConfigRequest mocks base method.
func (m *MockSageMakerAPI) DescribeNotebookInstanceLifecycleConfigRequest(arg0 *sagemaker.DescribeNotebookInstanceLifecycleConfigInput) (*request.Request, *sagemaker.DescribeNotebookInstanceLifecycleConfigOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeNotebookInstanceLifecycleConfigRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.DescribeNotebookInstanceLifecycleConfigOutput)
	return ret0, ret1
}

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

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

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

// DescribeNotebookInstanceRequest mocks base method.
func (m *MockSageMakerAPI) DescribeNotebookInstanceRequest(arg0 *sagemaker.DescribeNotebookInstanceInput) (*request.Request, *sagemaker.DescribeNotebookInstanceOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeNotebookInstanceRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.DescribeNotebookInstanceOutput)
	return ret0, ret1
}

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

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

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

// DescribeOptimizationJob mocks base method.
func (m *MockSageMakerAPI) DescribeOptimizationJob(arg0 *sagemaker.DescribeOptimizationJobInput) (*sagemaker.DescribeOptimizationJobOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeOptimizationJob", arg0)
	ret0, _ := ret[0].(*sagemaker.DescribeOptimizationJobOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeOptimizationJobRequest mocks base method.
func (m *MockSageMakerAPI) DescribeOptimizationJobRequest(arg0 *sagemaker.DescribeOptimizationJobInput) (*request.Request, *sagemaker.DescribeOptimizationJobOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeOptimizationJobRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.DescribeOptimizationJobOutput)
	return ret0, ret1
}

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

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

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

// DescribePipeline mocks base method.
func (m *MockSageMakerAPI) DescribePipeline(arg0 *sagemaker.DescribePipelineInput) (*sagemaker.DescribePipelineOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribePipeline", arg0)
	ret0, _ := ret[0].(*sagemaker.DescribePipelineOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribePipelineDefinitionForExecution mocks base method.
func (m *MockSageMakerAPI) DescribePipelineDefinitionForExecution(arg0 *sagemaker.DescribePipelineDefinitionForExecutionInput) (*sagemaker.DescribePipelineDefinitionForExecutionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribePipelineDefinitionForExecution", arg0)
	ret0, _ := ret[0].(*sagemaker.DescribePipelineDefinitionForExecutionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribePipelineDefinitionForExecutionRequest mocks base method.
func (m *MockSageMakerAPI) DescribePipelineDefinitionForExecutionRequest(arg0 *sagemaker.DescribePipelineDefinitionForExecutionInput) (*request.Request, *sagemaker.DescribePipelineDefinitionForExecutionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribePipelineDefinitionForExecutionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.DescribePipelineDefinitionForExecutionOutput)
	return ret0, ret1
}

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

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

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

// DescribePipelineExecution mocks base method.
func (m *MockSageMakerAPI) DescribePipelineExecution(arg0 *sagemaker.DescribePipelineExecutionInput) (*sagemaker.DescribePipelineExecutionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribePipelineExecution", arg0)
	ret0, _ := ret[0].(*sagemaker.DescribePipelineExecutionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribePipelineExecutionRequest mocks base method.
func (m *MockSageMakerAPI) DescribePipelineExecutionRequest(arg0 *sagemaker.DescribePipelineExecutionInput) (*request.Request, *sagemaker.DescribePipelineExecutionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribePipelineExecutionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.DescribePipelineExecutionOutput)
	return ret0, ret1
}

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

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

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

// DescribePipelineRequest mocks base method.
func (m *MockSageMakerAPI) DescribePipelineRequest(arg0 *sagemaker.DescribePipelineInput) (*request.Request, *sagemaker.DescribePipelineOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribePipelineRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.DescribePipelineOutput)
	return ret0, ret1
}

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

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

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

// DescribeProcessingJob mocks base method.
func (m *MockSageMakerAPI) DescribeProcessingJob(arg0 *sagemaker.DescribeProcessingJobInput) (*sagemaker.DescribeProcessingJobOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeProcessingJob", arg0)
	ret0, _ := ret[0].(*sagemaker.DescribeProcessingJobOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeProcessingJobRequest mocks base method.
func (m *MockSageMakerAPI) DescribeProcessingJobRequest(arg0 *sagemaker.DescribeProcessingJobInput) (*request.Request, *sagemaker.DescribeProcessingJobOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeProcessingJobRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.DescribeProcessingJobOutput)
	return ret0, ret1
}

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

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

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

// DescribeProject mocks base method.
func (m *MockSageMakerAPI) DescribeProject(arg0 *sagemaker.DescribeProjectInput) (*sagemaker.DescribeProjectOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeProject", arg0)
	ret0, _ := ret[0].(*sagemaker.DescribeProjectOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeProjectRequest mocks base method.
func (m *MockSageMakerAPI) DescribeProjectRequest(arg0 *sagemaker.DescribeProjectInput) (*request.Request, *sagemaker.DescribeProjectOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeProjectRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.DescribeProjectOutput)
	return ret0, ret1
}

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

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

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

// DescribeSpace mocks base method.
func (m *MockSageMakerAPI) DescribeSpace(arg0 *sagemaker.DescribeSpaceInput) (*sagemaker.DescribeSpaceOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeSpace", arg0)
	ret0, _ := ret[0].(*sagemaker.DescribeSpaceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeSpaceRequest mocks base method.
func (m *MockSageMakerAPI) DescribeSpaceRequest(arg0 *sagemaker.DescribeSpaceInput) (*request.Request, *sagemaker.DescribeSpaceOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeSpaceRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.DescribeSpaceOutput)
	return ret0, ret1
}

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

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

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

// DescribeStudioLifecycleConfig mocks base method.
func (m *MockSageMakerAPI) DescribeStudioLifecycleConfig(arg0 *sagemaker.DescribeStudioLifecycleConfigInput) (*sagemaker.DescribeStudioLifecycleConfigOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeStudioLifecycleConfig", arg0)
	ret0, _ := ret[0].(*sagemaker.DescribeStudioLifecycleConfigOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeStudioLifecycleConfigRequest mocks base method.
func (m *MockSageMakerAPI) DescribeStudioLifecycleConfigRequest(arg0 *sagemaker.DescribeStudioLifecycleConfigInput) (*request.Request, *sagemaker.DescribeStudioLifecycleConfigOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeStudioLifecycleConfigRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.DescribeStudioLifecycleConfigOutput)
	return ret0, ret1
}

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

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

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

// DescribeSubscribedWorkteam mocks base method.
func (m *MockSageMakerAPI) DescribeSubscribedWorkteam(arg0 *sagemaker.DescribeSubscribedWorkteamInput) (*sagemaker.DescribeSubscribedWorkteamOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeSubscribedWorkteam", arg0)
	ret0, _ := ret[0].(*sagemaker.DescribeSubscribedWorkteamOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeSubscribedWorkteamRequest mocks base method.
func (m *MockSageMakerAPI) DescribeSubscribedWorkteamRequest(arg0 *sagemaker.DescribeSubscribedWorkteamInput) (*request.Request, *sagemaker.DescribeSubscribedWorkteamOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeSubscribedWorkteamRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.DescribeSubscribedWorkteamOutput)
	return ret0, ret1
}

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

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

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

// DescribeTrainingJob mocks base method.
func (m *MockSageMakerAPI) DescribeTrainingJob(arg0 *sagemaker.DescribeTrainingJobInput) (*sagemaker.DescribeTrainingJobOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeTrainingJob", arg0)
	ret0, _ := ret[0].(*sagemaker.DescribeTrainingJobOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeTrainingJobRequest mocks base method.
func (m *MockSageMakerAPI) DescribeTrainingJobRequest(arg0 *sagemaker.DescribeTrainingJobInput) (*request.Request, *sagemaker.DescribeTrainingJobOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeTrainingJobRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.DescribeTrainingJobOutput)
	return ret0, ret1
}

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

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

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

// DescribeTransformJob mocks base method.
func (m *MockSageMakerAPI) DescribeTransformJob(arg0 *sagemaker.DescribeTransformJobInput) (*sagemaker.DescribeTransformJobOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeTransformJob", arg0)
	ret0, _ := ret[0].(*sagemaker.DescribeTransformJobOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeTransformJobRequest mocks base method.
func (m *MockSageMakerAPI) DescribeTransformJobRequest(arg0 *sagemaker.DescribeTransformJobInput) (*request.Request, *sagemaker.DescribeTransformJobOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeTransformJobRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.DescribeTransformJobOutput)
	return ret0, ret1
}

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

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

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

// DescribeTrial mocks base method.
func (m *MockSageMakerAPI) DescribeTrial(arg0 *sagemaker.DescribeTrialInput) (*sagemaker.DescribeTrialOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeTrial", arg0)
	ret0, _ := ret[0].(*sagemaker.DescribeTrialOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeTrialComponent mocks base method.
func (m *MockSageMakerAPI) DescribeTrialComponent(arg0 *sagemaker.DescribeTrialComponentInput) (*sagemaker.DescribeTrialComponentOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeTrialComponent", arg0)
	ret0, _ := ret[0].(*sagemaker.DescribeTrialComponentOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeTrialComponentRequest mocks base method.
func (m *MockSageMakerAPI) DescribeTrialComponentRequest(arg0 *sagemaker.DescribeTrialComponentInput) (*request.Request, *sagemaker.DescribeTrialComponentOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeTrialComponentRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.DescribeTrialComponentOutput)
	return ret0, ret1
}

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

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

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

// DescribeTrialRequest mocks base method.
func (m *MockSageMakerAPI) DescribeTrialRequest(arg0 *sagemaker.DescribeTrialInput) (*request.Request, *sagemaker.DescribeTrialOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeTrialRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.DescribeTrialOutput)
	return ret0, ret1
}

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

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

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

// DescribeUserProfile mocks base method.
func (m *MockSageMakerAPI) DescribeUserProfile(arg0 *sagemaker.DescribeUserProfileInput) (*sagemaker.DescribeUserProfileOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeUserProfile", arg0)
	ret0, _ := ret[0].(*sagemaker.DescribeUserProfileOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeUserProfileRequest mocks base method.
func (m *MockSageMakerAPI) DescribeUserProfileRequest(arg0 *sagemaker.DescribeUserProfileInput) (*request.Request, *sagemaker.DescribeUserProfileOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeUserProfileRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.DescribeUserProfileOutput)
	return ret0, ret1
}

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

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

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

// DescribeWorkforce mocks base method.
func (m *MockSageMakerAPI) DescribeWorkforce(arg0 *sagemaker.DescribeWorkforceInput) (*sagemaker.DescribeWorkforceOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeWorkforce", arg0)
	ret0, _ := ret[0].(*sagemaker.DescribeWorkforceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeWorkforceRequest mocks base method.
func (m *MockSageMakerAPI) DescribeWorkforceRequest(arg0 *sagemaker.DescribeWorkforceInput) (*request.Request, *sagemaker.DescribeWorkforceOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeWorkforceRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.DescribeWorkforceOutput)
	return ret0, ret1
}

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

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

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

// DescribeWorkteam mocks base method.
func (m *MockSageMakerAPI) DescribeWorkteam(arg0 *sagemaker.DescribeWorkteamInput) (*sagemaker.DescribeWorkteamOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeWorkteam", arg0)
	ret0, _ := ret[0].(*sagemaker.DescribeWorkteamOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeWorkteamRequest mocks base method.
func (m *MockSageMakerAPI) DescribeWorkteamRequest(arg0 *sagemaker.DescribeWorkteamInput) (*request.Request, *sagemaker.DescribeWorkteamOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeWorkteamRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.DescribeWorkteamOutput)
	return ret0, ret1
}

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

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

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

// DisableSagemakerServicecatalogPortfolio mocks base method.
func (m *MockSageMakerAPI) DisableSagemakerServicecatalogPortfolio(arg0 *sagemaker.DisableSagemakerServicecatalogPortfolioInput) (*sagemaker.DisableSagemakerServicecatalogPortfolioOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DisableSagemakerServicecatalogPortfolio", arg0)
	ret0, _ := ret[0].(*sagemaker.DisableSagemakerServicecatalogPortfolioOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DisableSagemakerServicecatalogPortfolioRequest mocks base method.
func (m *MockSageMakerAPI) DisableSagemakerServicecatalogPortfolioRequest(arg0 *sagemaker.DisableSagemakerServicecatalogPortfolioInput) (*request.Request, *sagemaker.DisableSagemakerServicecatalogPortfolioOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DisableSagemakerServicecatalogPortfolioRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.DisableSagemakerServicecatalogPortfolioOutput)
	return ret0, ret1
}

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

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

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

// DisassociateTrialComponent mocks base method.
func (m *MockSageMakerAPI) DisassociateTrialComponent(arg0 *sagemaker.DisassociateTrialComponentInput) (*sagemaker.DisassociateTrialComponentOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DisassociateTrialComponent", arg0)
	ret0, _ := ret[0].(*sagemaker.DisassociateTrialComponentOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DisassociateTrialComponentRequest mocks base method.
func (m *MockSageMakerAPI) DisassociateTrialComponentRequest(arg0 *sagemaker.DisassociateTrialComponentInput) (*request.Request, *sagemaker.DisassociateTrialComponentOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DisassociateTrialComponentRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.DisassociateTrialComponentOutput)
	return ret0, ret1
}

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

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

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

// EnableSagemakerServicecatalogPortfolio mocks base method.
func (m *MockSageMakerAPI) EnableSagemakerServicecatalogPortfolio(arg0 *sagemaker.EnableSagemakerServicecatalogPortfolioInput) (*sagemaker.EnableSagemakerServicecatalogPortfolioOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EnableSagemakerServicecatalogPortfolio", arg0)
	ret0, _ := ret[0].(*sagemaker.EnableSagemakerServicecatalogPortfolioOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// EnableSagemakerServicecatalogPortfolioRequest mocks base method.
func (m *MockSageMakerAPI) EnableSagemakerServicecatalogPortfolioRequest(arg0 *sagemaker.EnableSagemakerServicecatalogPortfolioInput) (*request.Request, *sagemaker.EnableSagemakerServicecatalogPortfolioOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EnableSagemakerServicecatalogPortfolioRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.EnableSagemakerServicecatalogPortfolioOutput)
	return ret0, ret1
}

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

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

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

// GetDeviceFleetReport mocks base method.
func (m *MockSageMakerAPI) GetDeviceFleetReport(arg0 *sagemaker.GetDeviceFleetReportInput) (*sagemaker.GetDeviceFleetReportOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetDeviceFleetReport", arg0)
	ret0, _ := ret[0].(*sagemaker.GetDeviceFleetReportOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetDeviceFleetReportRequest mocks base method.
func (m *MockSageMakerAPI) GetDeviceFleetReportRequest(arg0 *sagemaker.GetDeviceFleetReportInput) (*request.Request, *sagemaker.GetDeviceFleetReportOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetDeviceFleetReportRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.GetDeviceFleetReportOutput)
	return ret0, ret1
}

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

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

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

// GetLineageGroupPolicy mocks base method.
func (m *MockSageMakerAPI) GetLineageGroupPolicy(arg0 *sagemaker.GetLineageGroupPolicyInput) (*sagemaker.GetLineageGroupPolicyOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetLineageGroupPolicy", arg0)
	ret0, _ := ret[0].(*sagemaker.GetLineageGroupPolicyOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetLineageGroupPolicyRequest mocks base method.
func (m *MockSageMakerAPI) GetLineageGroupPolicyRequest(arg0 *sagemaker.GetLineageGroupPolicyInput) (*request.Request, *sagemaker.GetLineageGroupPolicyOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetLineageGroupPolicyRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.GetLineageGroupPolicyOutput)
	return ret0, ret1
}

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

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

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

// GetModelPackageGroupPolicy mocks base method.
func (m *MockSageMakerAPI) GetModelPackageGroupPolicy(arg0 *sagemaker.GetModelPackageGroupPolicyInput) (*sagemaker.GetModelPackageGroupPolicyOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetModelPackageGroupPolicy", arg0)
	ret0, _ := ret[0].(*sagemaker.GetModelPackageGroupPolicyOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetModelPackageGroupPolicyRequest mocks base method.
func (m *MockSageMakerAPI) GetModelPackageGroupPolicyRequest(arg0 *sagemaker.GetModelPackageGroupPolicyInput) (*request.Request, *sagemaker.GetModelPackageGroupPolicyOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetModelPackageGroupPolicyRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.GetModelPackageGroupPolicyOutput)
	return ret0, ret1
}

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

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

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

// GetSagemakerServicecatalogPortfolioStatus mocks base method.
func (m *MockSageMakerAPI) GetSagemakerServicecatalogPortfolioStatus(arg0 *sagemaker.GetSagemakerServicecatalogPortfolioStatusInput) (*sagemaker.GetSagemakerServicecatalogPortfolioStatusOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSagemakerServicecatalogPortfolioStatus", arg0)
	ret0, _ := ret[0].(*sagemaker.GetSagemakerServicecatalogPortfolioStatusOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetSagemakerServicecatalogPortfolioStatusRequest mocks base method.
func (m *MockSageMakerAPI) GetSagemakerServicecatalogPortfolioStatusRequest(arg0 *sagemaker.GetSagemakerServicecatalogPortfolioStatusInput) (*request.Request, *sagemaker.GetSagemakerServicecatalogPortfolioStatusOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSagemakerServicecatalogPortfolioStatusRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.GetSagemakerServicecatalogPortfolioStatusOutput)
	return ret0, ret1
}

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

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

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

// GetScalingConfigurationRecommendation mocks base method.
func (m *MockSageMakerAPI) GetScalingConfigurationRecommendation(arg0 *sagemaker.GetScalingConfigurationRecommendationInput) (*sagemaker.GetScalingConfigurationRecommendationOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetScalingConfigurationRecommendation", arg0)
	ret0, _ := ret[0].(*sagemaker.GetScalingConfigurationRecommendationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetScalingConfigurationRecommendationRequest mocks base method.
func (m *MockSageMakerAPI) GetScalingConfigurationRecommendationRequest(arg0 *sagemaker.GetScalingConfigurationRecommendationInput) (*request.Request, *sagemaker.GetScalingConfigurationRecommendationOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetScalingConfigurationRecommendationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.GetScalingConfigurationRecommendationOutput)
	return ret0, ret1
}

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

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

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

// GetSearchSuggestions mocks base method.
func (m *MockSageMakerAPI) GetSearchSuggestions(arg0 *sagemaker.GetSearchSuggestionsInput) (*sagemaker.GetSearchSuggestionsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSearchSuggestions", arg0)
	ret0, _ := ret[0].(*sagemaker.GetSearchSuggestionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetSearchSuggestionsRequest mocks base method.
func (m *MockSageMakerAPI) GetSearchSuggestionsRequest(arg0 *sagemaker.GetSearchSuggestionsInput) (*request.Request, *sagemaker.GetSearchSuggestionsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSearchSuggestionsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.GetSearchSuggestionsOutput)
	return ret0, ret1
}

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

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

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

// ImportHubContent mocks base method.
func (m *MockSageMakerAPI) ImportHubContent(arg0 *sagemaker.ImportHubContentInput) (*sagemaker.ImportHubContentOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ImportHubContent", arg0)
	ret0, _ := ret[0].(*sagemaker.ImportHubContentOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ImportHubContentRequest mocks base method.
func (m *MockSageMakerAPI) ImportHubContentRequest(arg0 *sagemaker.ImportHubContentInput) (*request.Request, *sagemaker.ImportHubContentOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ImportHubContentRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.ImportHubContentOutput)
	return ret0, ret1
}

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

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

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

// ListActions mocks base method.
func (m *MockSageMakerAPI) ListActions(arg0 *sagemaker.ListActionsInput) (*sagemaker.ListActionsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListActions", arg0)
	ret0, _ := ret[0].(*sagemaker.ListActionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListActionsPages mocks base method.
func (m *MockSageMakerAPI) ListActionsPages(arg0 *sagemaker.ListActionsInput, arg1 func(*sagemaker.ListActionsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListActionsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListActionsPagesWithContext mocks base method.
func (m *MockSageMakerAPI) ListActionsPagesWithContext(arg0 aws.Context, arg1 *sagemaker.ListActionsInput, arg2 func(*sagemaker.ListActionsOutput, 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, "ListActionsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListActionsRequest mocks base method.
func (m *MockSageMakerAPI) ListActionsRequest(arg0 *sagemaker.ListActionsInput) (*request.Request, *sagemaker.ListActionsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListActionsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.ListActionsOutput)
	return ret0, ret1
}

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

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

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

// ListAlgorithms mocks base method.
func (m *MockSageMakerAPI) ListAlgorithms(arg0 *sagemaker.ListAlgorithmsInput) (*sagemaker.ListAlgorithmsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListAlgorithms", arg0)
	ret0, _ := ret[0].(*sagemaker.ListAlgorithmsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListAlgorithmsPages mocks base method.
func (m *MockSageMakerAPI) ListAlgorithmsPages(arg0 *sagemaker.ListAlgorithmsInput, arg1 func(*sagemaker.ListAlgorithmsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListAlgorithmsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListAlgorithmsPagesWithContext mocks base method.
func (m *MockSageMakerAPI) ListAlgorithmsPagesWithContext(arg0 aws.Context, arg1 *sagemaker.ListAlgorithmsInput, arg2 func(*sagemaker.ListAlgorithmsOutput, 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, "ListAlgorithmsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListAlgorithmsRequest mocks base method.
func (m *MockSageMakerAPI) ListAlgorithmsRequest(arg0 *sagemaker.ListAlgorithmsInput) (*request.Request, *sagemaker.ListAlgorithmsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListAlgorithmsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.ListAlgorithmsOutput)
	return ret0, ret1
}

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

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

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

// ListAliases mocks base method.
func (m *MockSageMakerAPI) ListAliases(arg0 *sagemaker.ListAliasesInput) (*sagemaker.ListAliasesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListAliases", arg0)
	ret0, _ := ret[0].(*sagemaker.ListAliasesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListAliasesPages mocks base method.
func (m *MockSageMakerAPI) ListAliasesPages(arg0 *sagemaker.ListAliasesInput, arg1 func(*sagemaker.ListAliasesOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListAliasesPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListAliasesPagesWithContext mocks base method.
func (m *MockSageMakerAPI) ListAliasesPagesWithContext(arg0 aws.Context, arg1 *sagemaker.ListAliasesInput, arg2 func(*sagemaker.ListAliasesOutput, 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, "ListAliasesPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListAliasesRequest mocks base method.
func (m *MockSageMakerAPI) ListAliasesRequest(arg0 *sagemaker.ListAliasesInput) (*request.Request, *sagemaker.ListAliasesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListAliasesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.ListAliasesOutput)
	return ret0, ret1
}

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

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

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

// ListAppImageConfigs mocks base method.
func (m *MockSageMakerAPI) ListAppImageConfigs(arg0 *sagemaker.ListAppImageConfigsInput) (*sagemaker.ListAppImageConfigsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListAppImageConfigs", arg0)
	ret0, _ := ret[0].(*sagemaker.ListAppImageConfigsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListAppImageConfigsPages mocks base method.
func (m *MockSageMakerAPI) ListAppImageConfigsPages(arg0 *sagemaker.ListAppImageConfigsInput, arg1 func(*sagemaker.ListAppImageConfigsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListAppImageConfigsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListAppImageConfigsPagesWithContext mocks base method.
func (m *MockSageMakerAPI) ListAppImageConfigsPagesWithContext(arg0 aws.Context, arg1 *sagemaker.ListAppImageConfigsInput, arg2 func(*sagemaker.ListAppImageConfigsOutput, 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, "ListAppImageConfigsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListAppImageConfigsRequest mocks base method.
func (m *MockSageMakerAPI) ListAppImageConfigsRequest(arg0 *sagemaker.ListAppImageConfigsInput) (*request.Request, *sagemaker.ListAppImageConfigsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListAppImageConfigsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.ListAppImageConfigsOutput)
	return ret0, ret1
}

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

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

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

// ListApps mocks base method.
func (m *MockSageMakerAPI) ListApps(arg0 *sagemaker.ListAppsInput) (*sagemaker.ListAppsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListApps", arg0)
	ret0, _ := ret[0].(*sagemaker.ListAppsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListAppsPages mocks base method.
func (m *MockSageMakerAPI) ListAppsPages(arg0 *sagemaker.ListAppsInput, arg1 func(*sagemaker.ListAppsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListAppsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListAppsPagesWithContext mocks base method.
func (m *MockSageMakerAPI) ListAppsPagesWithContext(arg0 aws.Context, arg1 *sagemaker.ListAppsInput, arg2 func(*sagemaker.ListAppsOutput, 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, "ListAppsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListAppsRequest mocks base method.
func (m *MockSageMakerAPI) ListAppsRequest(arg0 *sagemaker.ListAppsInput) (*request.Request, *sagemaker.ListAppsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListAppsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.ListAppsOutput)
	return ret0, ret1
}

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

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

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

// ListArtifacts mocks base method.
func (m *MockSageMakerAPI) ListArtifacts(arg0 *sagemaker.ListArtifactsInput) (*sagemaker.ListArtifactsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListArtifacts", arg0)
	ret0, _ := ret[0].(*sagemaker.ListArtifactsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListArtifactsPages mocks base method.
func (m *MockSageMakerAPI) ListArtifactsPages(arg0 *sagemaker.ListArtifactsInput, arg1 func(*sagemaker.ListArtifactsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListArtifactsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListArtifactsPagesWithContext mocks base method.
func (m *MockSageMakerAPI) ListArtifactsPagesWithContext(arg0 aws.Context, arg1 *sagemaker.ListArtifactsInput, arg2 func(*sagemaker.ListArtifactsOutput, 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, "ListArtifactsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListArtifactsRequest mocks base method.
func (m *MockSageMakerAPI) ListArtifactsRequest(arg0 *sagemaker.ListArtifactsInput) (*request.Request, *sagemaker.ListArtifactsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListArtifactsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.ListArtifactsOutput)
	return ret0, ret1
}

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

// ListArtifactsWithContext mocks base method.
func (m *MockSageMakerAPI) ListArtifactsWithContext(arg0 aws.Context, arg1 *sagemaker.ListArtifactsInput, arg2 ...request.Option) (*sagemaker.ListArtifactsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListArtifactsWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.ListArtifactsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListArtifactsWithContext indicates an expected call of ListArtifactsWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListArtifactsWithContext(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, "ListArtifactsWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListArtifactsWithContext), varargs...)
}

// ListAssociations mocks base method.
func (m *MockSageMakerAPI) ListAssociations(arg0 *sagemaker.ListAssociationsInput) (*sagemaker.ListAssociationsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListAssociations", arg0)
	ret0, _ := ret[0].(*sagemaker.ListAssociationsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListAssociations indicates an expected call of ListAssociations.
func (mr *MockSageMakerAPIMockRecorder) ListAssociations(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAssociations", reflect.TypeOf((*MockSageMakerAPI)(nil).ListAssociations), arg0)
}

// ListAssociationsPages mocks base method.
func (m *MockSageMakerAPI) ListAssociationsPages(arg0 *sagemaker.ListAssociationsInput, arg1 func(*sagemaker.ListAssociationsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListAssociationsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListAssociationsPages indicates an expected call of ListAssociationsPages.
func (mr *MockSageMakerAPIMockRecorder) ListAssociationsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAssociationsPages", reflect.TypeOf((*MockSageMakerAPI)(nil).ListAssociationsPages), arg0, arg1)
}

// ListAssociationsPagesWithContext mocks base method.
func (m *MockSageMakerAPI) ListAssociationsPagesWithContext(arg0 aws.Context, arg1 *sagemaker.ListAssociationsInput, arg2 func(*sagemaker.ListAssociationsOutput, 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, "ListAssociationsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListAssociationsPagesWithContext indicates an expected call of ListAssociationsPagesWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListAssociationsPagesWithContext(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, "ListAssociationsPagesWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListAssociationsPagesWithContext), varargs...)
}

// ListAssociationsRequest mocks base method.
func (m *MockSageMakerAPI) ListAssociationsRequest(arg0 *sagemaker.ListAssociationsInput) (*request.Request, *sagemaker.ListAssociationsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListAssociationsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.ListAssociationsOutput)
	return ret0, ret1
}

// ListAssociationsRequest indicates an expected call of ListAssociationsRequest.
func (mr *MockSageMakerAPIMockRecorder) ListAssociationsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAssociationsRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).ListAssociationsRequest), arg0)
}

// ListAssociationsWithContext mocks base method.
func (m *MockSageMakerAPI) ListAssociationsWithContext(arg0 aws.Context, arg1 *sagemaker.ListAssociationsInput, arg2 ...request.Option) (*sagemaker.ListAssociationsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListAssociationsWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.ListAssociationsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListAssociationsWithContext indicates an expected call of ListAssociationsWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListAssociationsWithContext(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, "ListAssociationsWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListAssociationsWithContext), varargs...)
}

// ListAutoMLJobs mocks base method.
func (m *MockSageMakerAPI) ListAutoMLJobs(arg0 *sagemaker.ListAutoMLJobsInput) (*sagemaker.ListAutoMLJobsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListAutoMLJobs", arg0)
	ret0, _ := ret[0].(*sagemaker.ListAutoMLJobsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListAutoMLJobs indicates an expected call of ListAutoMLJobs.
func (mr *MockSageMakerAPIMockRecorder) ListAutoMLJobs(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAutoMLJobs", reflect.TypeOf((*MockSageMakerAPI)(nil).ListAutoMLJobs), arg0)
}

// ListAutoMLJobsPages mocks base method.
func (m *MockSageMakerAPI) ListAutoMLJobsPages(arg0 *sagemaker.ListAutoMLJobsInput, arg1 func(*sagemaker.ListAutoMLJobsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListAutoMLJobsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListAutoMLJobsPages indicates an expected call of ListAutoMLJobsPages.
func (mr *MockSageMakerAPIMockRecorder) ListAutoMLJobsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAutoMLJobsPages", reflect.TypeOf((*MockSageMakerAPI)(nil).ListAutoMLJobsPages), arg0, arg1)
}

// ListAutoMLJobsPagesWithContext mocks base method.
func (m *MockSageMakerAPI) ListAutoMLJobsPagesWithContext(arg0 aws.Context, arg1 *sagemaker.ListAutoMLJobsInput, arg2 func(*sagemaker.ListAutoMLJobsOutput, 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, "ListAutoMLJobsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListAutoMLJobsPagesWithContext indicates an expected call of ListAutoMLJobsPagesWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListAutoMLJobsPagesWithContext(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, "ListAutoMLJobsPagesWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListAutoMLJobsPagesWithContext), varargs...)
}

// ListAutoMLJobsRequest mocks base method.
func (m *MockSageMakerAPI) ListAutoMLJobsRequest(arg0 *sagemaker.ListAutoMLJobsInput) (*request.Request, *sagemaker.ListAutoMLJobsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListAutoMLJobsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.ListAutoMLJobsOutput)
	return ret0, ret1
}

// ListAutoMLJobsRequest indicates an expected call of ListAutoMLJobsRequest.
func (mr *MockSageMakerAPIMockRecorder) ListAutoMLJobsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAutoMLJobsRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).ListAutoMLJobsRequest), arg0)
}

// ListAutoMLJobsWithContext mocks base method.
func (m *MockSageMakerAPI) ListAutoMLJobsWithContext(arg0 aws.Context, arg1 *sagemaker.ListAutoMLJobsInput, arg2 ...request.Option) (*sagemaker.ListAutoMLJobsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListAutoMLJobsWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.ListAutoMLJobsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListAutoMLJobsWithContext indicates an expected call of ListAutoMLJobsWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListAutoMLJobsWithContext(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, "ListAutoMLJobsWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListAutoMLJobsWithContext), varargs...)
}

// ListCandidatesForAutoMLJob mocks base method.
func (m *MockSageMakerAPI) ListCandidatesForAutoMLJob(arg0 *sagemaker.ListCandidatesForAutoMLJobInput) (*sagemaker.ListCandidatesForAutoMLJobOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListCandidatesForAutoMLJob", arg0)
	ret0, _ := ret[0].(*sagemaker.ListCandidatesForAutoMLJobOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListCandidatesForAutoMLJob indicates an expected call of ListCandidatesForAutoMLJob.
func (mr *MockSageMakerAPIMockRecorder) ListCandidatesForAutoMLJob(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListCandidatesForAutoMLJob", reflect.TypeOf((*MockSageMakerAPI)(nil).ListCandidatesForAutoMLJob), arg0)
}

// ListCandidatesForAutoMLJobPages mocks base method.
func (m *MockSageMakerAPI) ListCandidatesForAutoMLJobPages(arg0 *sagemaker.ListCandidatesForAutoMLJobInput, arg1 func(*sagemaker.ListCandidatesForAutoMLJobOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListCandidatesForAutoMLJobPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListCandidatesForAutoMLJobPages indicates an expected call of ListCandidatesForAutoMLJobPages.
func (mr *MockSageMakerAPIMockRecorder) ListCandidatesForAutoMLJobPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListCandidatesForAutoMLJobPages", reflect.TypeOf((*MockSageMakerAPI)(nil).ListCandidatesForAutoMLJobPages), arg0, arg1)
}

// ListCandidatesForAutoMLJobPagesWithContext mocks base method.
func (m *MockSageMakerAPI) ListCandidatesForAutoMLJobPagesWithContext(arg0 aws.Context, arg1 *sagemaker.ListCandidatesForAutoMLJobInput, arg2 func(*sagemaker.ListCandidatesForAutoMLJobOutput, 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, "ListCandidatesForAutoMLJobPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListCandidatesForAutoMLJobPagesWithContext indicates an expected call of ListCandidatesForAutoMLJobPagesWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListCandidatesForAutoMLJobPagesWithContext(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, "ListCandidatesForAutoMLJobPagesWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListCandidatesForAutoMLJobPagesWithContext), varargs...)
}

// ListCandidatesForAutoMLJobRequest mocks base method.
func (m *MockSageMakerAPI) ListCandidatesForAutoMLJobRequest(arg0 *sagemaker.ListCandidatesForAutoMLJobInput) (*request.Request, *sagemaker.ListCandidatesForAutoMLJobOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListCandidatesForAutoMLJobRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.ListCandidatesForAutoMLJobOutput)
	return ret0, ret1
}

// ListCandidatesForAutoMLJobRequest indicates an expected call of ListCandidatesForAutoMLJobRequest.
func (mr *MockSageMakerAPIMockRecorder) ListCandidatesForAutoMLJobRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListCandidatesForAutoMLJobRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).ListCandidatesForAutoMLJobRequest), arg0)
}

// ListCandidatesForAutoMLJobWithContext mocks base method.
func (m *MockSageMakerAPI) ListCandidatesForAutoMLJobWithContext(arg0 aws.Context, arg1 *sagemaker.ListCandidatesForAutoMLJobInput, arg2 ...request.Option) (*sagemaker.ListCandidatesForAutoMLJobOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListCandidatesForAutoMLJobWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.ListCandidatesForAutoMLJobOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListCandidatesForAutoMLJobWithContext indicates an expected call of ListCandidatesForAutoMLJobWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListCandidatesForAutoMLJobWithContext(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, "ListCandidatesForAutoMLJobWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListCandidatesForAutoMLJobWithContext), varargs...)
}

// ListClusterNodes mocks base method.
func (m *MockSageMakerAPI) ListClusterNodes(arg0 *sagemaker.ListClusterNodesInput) (*sagemaker.ListClusterNodesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListClusterNodes", arg0)
	ret0, _ := ret[0].(*sagemaker.ListClusterNodesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListClusterNodes indicates an expected call of ListClusterNodes.
func (mr *MockSageMakerAPIMockRecorder) ListClusterNodes(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListClusterNodes", reflect.TypeOf((*MockSageMakerAPI)(nil).ListClusterNodes), arg0)
}

// ListClusterNodesPages mocks base method.
func (m *MockSageMakerAPI) ListClusterNodesPages(arg0 *sagemaker.ListClusterNodesInput, arg1 func(*sagemaker.ListClusterNodesOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListClusterNodesPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListClusterNodesPages indicates an expected call of ListClusterNodesPages.
func (mr *MockSageMakerAPIMockRecorder) ListClusterNodesPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListClusterNodesPages", reflect.TypeOf((*MockSageMakerAPI)(nil).ListClusterNodesPages), arg0, arg1)
}

// ListClusterNodesPagesWithContext mocks base method.
func (m *MockSageMakerAPI) ListClusterNodesPagesWithContext(arg0 aws.Context, arg1 *sagemaker.ListClusterNodesInput, arg2 func(*sagemaker.ListClusterNodesOutput, 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, "ListClusterNodesPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListClusterNodesPagesWithContext indicates an expected call of ListClusterNodesPagesWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListClusterNodesPagesWithContext(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, "ListClusterNodesPagesWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListClusterNodesPagesWithContext), varargs...)
}

// ListClusterNodesRequest mocks base method.
func (m *MockSageMakerAPI) ListClusterNodesRequest(arg0 *sagemaker.ListClusterNodesInput) (*request.Request, *sagemaker.ListClusterNodesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListClusterNodesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.ListClusterNodesOutput)
	return ret0, ret1
}

// ListClusterNodesRequest indicates an expected call of ListClusterNodesRequest.
func (mr *MockSageMakerAPIMockRecorder) ListClusterNodesRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListClusterNodesRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).ListClusterNodesRequest), arg0)
}

// ListClusterNodesWithContext mocks base method.
func (m *MockSageMakerAPI) ListClusterNodesWithContext(arg0 aws.Context, arg1 *sagemaker.ListClusterNodesInput, arg2 ...request.Option) (*sagemaker.ListClusterNodesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListClusterNodesWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.ListClusterNodesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListClusterNodesWithContext indicates an expected call of ListClusterNodesWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListClusterNodesWithContext(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, "ListClusterNodesWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListClusterNodesWithContext), varargs...)
}

// ListClusters mocks base method.
func (m *MockSageMakerAPI) ListClusters(arg0 *sagemaker.ListClustersInput) (*sagemaker.ListClustersOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListClusters", arg0)
	ret0, _ := ret[0].(*sagemaker.ListClustersOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListClusters indicates an expected call of ListClusters.
func (mr *MockSageMakerAPIMockRecorder) ListClusters(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListClusters", reflect.TypeOf((*MockSageMakerAPI)(nil).ListClusters), arg0)
}

// ListClustersPages mocks base method.
func (m *MockSageMakerAPI) ListClustersPages(arg0 *sagemaker.ListClustersInput, arg1 func(*sagemaker.ListClustersOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListClustersPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListClustersPages indicates an expected call of ListClustersPages.
func (mr *MockSageMakerAPIMockRecorder) ListClustersPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListClustersPages", reflect.TypeOf((*MockSageMakerAPI)(nil).ListClustersPages), arg0, arg1)
}

// ListClustersPagesWithContext mocks base method.
func (m *MockSageMakerAPI) ListClustersPagesWithContext(arg0 aws.Context, arg1 *sagemaker.ListClustersInput, arg2 func(*sagemaker.ListClustersOutput, 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, "ListClustersPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListClustersPagesWithContext indicates an expected call of ListClustersPagesWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListClustersPagesWithContext(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, "ListClustersPagesWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListClustersPagesWithContext), varargs...)
}

// ListClustersRequest mocks base method.
func (m *MockSageMakerAPI) ListClustersRequest(arg0 *sagemaker.ListClustersInput) (*request.Request, *sagemaker.ListClustersOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListClustersRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.ListClustersOutput)
	return ret0, ret1
}

// ListClustersRequest indicates an expected call of ListClustersRequest.
func (mr *MockSageMakerAPIMockRecorder) ListClustersRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListClustersRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).ListClustersRequest), arg0)
}

// ListClustersWithContext mocks base method.
func (m *MockSageMakerAPI) ListClustersWithContext(arg0 aws.Context, arg1 *sagemaker.ListClustersInput, arg2 ...request.Option) (*sagemaker.ListClustersOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListClustersWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.ListClustersOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListClustersWithContext indicates an expected call of ListClustersWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListClustersWithContext(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, "ListClustersWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListClustersWithContext), varargs...)
}

// ListCodeRepositories mocks base method.
func (m *MockSageMakerAPI) ListCodeRepositories(arg0 *sagemaker.ListCodeRepositoriesInput) (*sagemaker.ListCodeRepositoriesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListCodeRepositories", arg0)
	ret0, _ := ret[0].(*sagemaker.ListCodeRepositoriesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListCodeRepositories indicates an expected call of ListCodeRepositories.
func (mr *MockSageMakerAPIMockRecorder) ListCodeRepositories(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListCodeRepositories", reflect.TypeOf((*MockSageMakerAPI)(nil).ListCodeRepositories), arg0)
}

// ListCodeRepositoriesPages mocks base method.
func (m *MockSageMakerAPI) ListCodeRepositoriesPages(arg0 *sagemaker.ListCodeRepositoriesInput, arg1 func(*sagemaker.ListCodeRepositoriesOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListCodeRepositoriesPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListCodeRepositoriesPages indicates an expected call of ListCodeRepositoriesPages.
func (mr *MockSageMakerAPIMockRecorder) ListCodeRepositoriesPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListCodeRepositoriesPages", reflect.TypeOf((*MockSageMakerAPI)(nil).ListCodeRepositoriesPages), arg0, arg1)
}

// ListCodeRepositoriesPagesWithContext mocks base method.
func (m *MockSageMakerAPI) ListCodeRepositoriesPagesWithContext(arg0 aws.Context, arg1 *sagemaker.ListCodeRepositoriesInput, arg2 func(*sagemaker.ListCodeRepositoriesOutput, 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, "ListCodeRepositoriesPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListCodeRepositoriesPagesWithContext indicates an expected call of ListCodeRepositoriesPagesWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListCodeRepositoriesPagesWithContext(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, "ListCodeRepositoriesPagesWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListCodeRepositoriesPagesWithContext), varargs...)
}

// ListCodeRepositoriesRequest mocks base method.
func (m *MockSageMakerAPI) ListCodeRepositoriesRequest(arg0 *sagemaker.ListCodeRepositoriesInput) (*request.Request, *sagemaker.ListCodeRepositoriesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListCodeRepositoriesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.ListCodeRepositoriesOutput)
	return ret0, ret1
}

// ListCodeRepositoriesRequest indicates an expected call of ListCodeRepositoriesRequest.
func (mr *MockSageMakerAPIMockRecorder) ListCodeRepositoriesRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListCodeRepositoriesRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).ListCodeRepositoriesRequest), arg0)
}

// ListCodeRepositoriesWithContext mocks base method.
func (m *MockSageMakerAPI) ListCodeRepositoriesWithContext(arg0 aws.Context, arg1 *sagemaker.ListCodeRepositoriesInput, arg2 ...request.Option) (*sagemaker.ListCodeRepositoriesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListCodeRepositoriesWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.ListCodeRepositoriesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListCodeRepositoriesWithContext indicates an expected call of ListCodeRepositoriesWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListCodeRepositoriesWithContext(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, "ListCodeRepositoriesWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListCodeRepositoriesWithContext), varargs...)
}

// ListCompilationJobs mocks base method.
func (m *MockSageMakerAPI) ListCompilationJobs(arg0 *sagemaker.ListCompilationJobsInput) (*sagemaker.ListCompilationJobsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListCompilationJobs", arg0)
	ret0, _ := ret[0].(*sagemaker.ListCompilationJobsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListCompilationJobs indicates an expected call of ListCompilationJobs.
func (mr *MockSageMakerAPIMockRecorder) ListCompilationJobs(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListCompilationJobs", reflect.TypeOf((*MockSageMakerAPI)(nil).ListCompilationJobs), arg0)
}

// ListCompilationJobsPages mocks base method.
func (m *MockSageMakerAPI) ListCompilationJobsPages(arg0 *sagemaker.ListCompilationJobsInput, arg1 func(*sagemaker.ListCompilationJobsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListCompilationJobsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListCompilationJobsPages indicates an expected call of ListCompilationJobsPages.
func (mr *MockSageMakerAPIMockRecorder) ListCompilationJobsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListCompilationJobsPages", reflect.TypeOf((*MockSageMakerAPI)(nil).ListCompilationJobsPages), arg0, arg1)
}

// ListCompilationJobsPagesWithContext mocks base method.
func (m *MockSageMakerAPI) ListCompilationJobsPagesWithContext(arg0 aws.Context, arg1 *sagemaker.ListCompilationJobsInput, arg2 func(*sagemaker.ListCompilationJobsOutput, 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, "ListCompilationJobsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListCompilationJobsPagesWithContext indicates an expected call of ListCompilationJobsPagesWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListCompilationJobsPagesWithContext(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, "ListCompilationJobsPagesWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListCompilationJobsPagesWithContext), varargs...)
}

// ListCompilationJobsRequest mocks base method.
func (m *MockSageMakerAPI) ListCompilationJobsRequest(arg0 *sagemaker.ListCompilationJobsInput) (*request.Request, *sagemaker.ListCompilationJobsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListCompilationJobsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.ListCompilationJobsOutput)
	return ret0, ret1
}

// ListCompilationJobsRequest indicates an expected call of ListCompilationJobsRequest.
func (mr *MockSageMakerAPIMockRecorder) ListCompilationJobsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListCompilationJobsRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).ListCompilationJobsRequest), arg0)
}

// ListCompilationJobsWithContext mocks base method.
func (m *MockSageMakerAPI) ListCompilationJobsWithContext(arg0 aws.Context, arg1 *sagemaker.ListCompilationJobsInput, arg2 ...request.Option) (*sagemaker.ListCompilationJobsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListCompilationJobsWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.ListCompilationJobsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListCompilationJobsWithContext indicates an expected call of ListCompilationJobsWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListCompilationJobsWithContext(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, "ListCompilationJobsWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListCompilationJobsWithContext), varargs...)
}

// ListContexts mocks base method.
func (m *MockSageMakerAPI) ListContexts(arg0 *sagemaker.ListContextsInput) (*sagemaker.ListContextsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListContexts", arg0)
	ret0, _ := ret[0].(*sagemaker.ListContextsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListContexts indicates an expected call of ListContexts.
func (mr *MockSageMakerAPIMockRecorder) ListContexts(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListContexts", reflect.TypeOf((*MockSageMakerAPI)(nil).ListContexts), arg0)
}

// ListContextsPages mocks base method.
func (m *MockSageMakerAPI) ListContextsPages(arg0 *sagemaker.ListContextsInput, arg1 func(*sagemaker.ListContextsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListContextsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListContextsPages indicates an expected call of ListContextsPages.
func (mr *MockSageMakerAPIMockRecorder) ListContextsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListContextsPages", reflect.TypeOf((*MockSageMakerAPI)(nil).ListContextsPages), arg0, arg1)
}

// ListContextsPagesWithContext mocks base method.
func (m *MockSageMakerAPI) ListContextsPagesWithContext(arg0 aws.Context, arg1 *sagemaker.ListContextsInput, arg2 func(*sagemaker.ListContextsOutput, 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, "ListContextsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListContextsPagesWithContext indicates an expected call of ListContextsPagesWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListContextsPagesWithContext(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, "ListContextsPagesWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListContextsPagesWithContext), varargs...)
}

// ListContextsRequest mocks base method.
func (m *MockSageMakerAPI) ListContextsRequest(arg0 *sagemaker.ListContextsInput) (*request.Request, *sagemaker.ListContextsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListContextsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.ListContextsOutput)
	return ret0, ret1
}

// ListContextsRequest indicates an expected call of ListContextsRequest.
func (mr *MockSageMakerAPIMockRecorder) ListContextsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListContextsRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).ListContextsRequest), arg0)
}

// ListContextsWithContext mocks base method.
func (m *MockSageMakerAPI) ListContextsWithContext(arg0 aws.Context, arg1 *sagemaker.ListContextsInput, arg2 ...request.Option) (*sagemaker.ListContextsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListContextsWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.ListContextsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListContextsWithContext indicates an expected call of ListContextsWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListContextsWithContext(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, "ListContextsWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListContextsWithContext), varargs...)
}

// ListDataQualityJobDefinitions mocks base method.
func (m *MockSageMakerAPI) ListDataQualityJobDefinitions(arg0 *sagemaker.ListDataQualityJobDefinitionsInput) (*sagemaker.ListDataQualityJobDefinitionsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListDataQualityJobDefinitions", arg0)
	ret0, _ := ret[0].(*sagemaker.ListDataQualityJobDefinitionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListDataQualityJobDefinitions indicates an expected call of ListDataQualityJobDefinitions.
func (mr *MockSageMakerAPIMockRecorder) ListDataQualityJobDefinitions(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListDataQualityJobDefinitions", reflect.TypeOf((*MockSageMakerAPI)(nil).ListDataQualityJobDefinitions), arg0)
}

// ListDataQualityJobDefinitionsPages mocks base method.
func (m *MockSageMakerAPI) ListDataQualityJobDefinitionsPages(arg0 *sagemaker.ListDataQualityJobDefinitionsInput, arg1 func(*sagemaker.ListDataQualityJobDefinitionsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListDataQualityJobDefinitionsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListDataQualityJobDefinitionsPages indicates an expected call of ListDataQualityJobDefinitionsPages.
func (mr *MockSageMakerAPIMockRecorder) ListDataQualityJobDefinitionsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListDataQualityJobDefinitionsPages", reflect.TypeOf((*MockSageMakerAPI)(nil).ListDataQualityJobDefinitionsPages), arg0, arg1)
}

// ListDataQualityJobDefinitionsPagesWithContext mocks base method.
func (m *MockSageMakerAPI) ListDataQualityJobDefinitionsPagesWithContext(arg0 aws.Context, arg1 *sagemaker.ListDataQualityJobDefinitionsInput, arg2 func(*sagemaker.ListDataQualityJobDefinitionsOutput, 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, "ListDataQualityJobDefinitionsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListDataQualityJobDefinitionsPagesWithContext indicates an expected call of ListDataQualityJobDefinitionsPagesWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListDataQualityJobDefinitionsPagesWithContext(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, "ListDataQualityJobDefinitionsPagesWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListDataQualityJobDefinitionsPagesWithContext), varargs...)
}

// ListDataQualityJobDefinitionsRequest mocks base method.
func (m *MockSageMakerAPI) ListDataQualityJobDefinitionsRequest(arg0 *sagemaker.ListDataQualityJobDefinitionsInput) (*request.Request, *sagemaker.ListDataQualityJobDefinitionsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListDataQualityJobDefinitionsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.ListDataQualityJobDefinitionsOutput)
	return ret0, ret1
}

// ListDataQualityJobDefinitionsRequest indicates an expected call of ListDataQualityJobDefinitionsRequest.
func (mr *MockSageMakerAPIMockRecorder) ListDataQualityJobDefinitionsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListDataQualityJobDefinitionsRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).ListDataQualityJobDefinitionsRequest), arg0)
}

// ListDataQualityJobDefinitionsWithContext mocks base method.
func (m *MockSageMakerAPI) ListDataQualityJobDefinitionsWithContext(arg0 aws.Context, arg1 *sagemaker.ListDataQualityJobDefinitionsInput, arg2 ...request.Option) (*sagemaker.ListDataQualityJobDefinitionsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListDataQualityJobDefinitionsWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.ListDataQualityJobDefinitionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListDataQualityJobDefinitionsWithContext indicates an expected call of ListDataQualityJobDefinitionsWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListDataQualityJobDefinitionsWithContext(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, "ListDataQualityJobDefinitionsWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListDataQualityJobDefinitionsWithContext), varargs...)
}

// ListDeviceFleets mocks base method.
func (m *MockSageMakerAPI) ListDeviceFleets(arg0 *sagemaker.ListDeviceFleetsInput) (*sagemaker.ListDeviceFleetsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListDeviceFleets", arg0)
	ret0, _ := ret[0].(*sagemaker.ListDeviceFleetsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListDeviceFleets indicates an expected call of ListDeviceFleets.
func (mr *MockSageMakerAPIMockRecorder) ListDeviceFleets(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListDeviceFleets", reflect.TypeOf((*MockSageMakerAPI)(nil).ListDeviceFleets), arg0)
}

// ListDeviceFleetsPages mocks base method.
func (m *MockSageMakerAPI) ListDeviceFleetsPages(arg0 *sagemaker.ListDeviceFleetsInput, arg1 func(*sagemaker.ListDeviceFleetsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListDeviceFleetsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListDeviceFleetsPages indicates an expected call of ListDeviceFleetsPages.
func (mr *MockSageMakerAPIMockRecorder) ListDeviceFleetsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListDeviceFleetsPages", reflect.TypeOf((*MockSageMakerAPI)(nil).ListDeviceFleetsPages), arg0, arg1)
}

// ListDeviceFleetsPagesWithContext mocks base method.
func (m *MockSageMakerAPI) ListDeviceFleetsPagesWithContext(arg0 aws.Context, arg1 *sagemaker.ListDeviceFleetsInput, arg2 func(*sagemaker.ListDeviceFleetsOutput, 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, "ListDeviceFleetsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListDeviceFleetsPagesWithContext indicates an expected call of ListDeviceFleetsPagesWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListDeviceFleetsPagesWithContext(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, "ListDeviceFleetsPagesWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListDeviceFleetsPagesWithContext), varargs...)
}

// ListDeviceFleetsRequest mocks base method.
func (m *MockSageMakerAPI) ListDeviceFleetsRequest(arg0 *sagemaker.ListDeviceFleetsInput) (*request.Request, *sagemaker.ListDeviceFleetsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListDeviceFleetsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.ListDeviceFleetsOutput)
	return ret0, ret1
}

// ListDeviceFleetsRequest indicates an expected call of ListDeviceFleetsRequest.
func (mr *MockSageMakerAPIMockRecorder) ListDeviceFleetsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListDeviceFleetsRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).ListDeviceFleetsRequest), arg0)
}

// ListDeviceFleetsWithContext mocks base method.
func (m *MockSageMakerAPI) ListDeviceFleetsWithContext(arg0 aws.Context, arg1 *sagemaker.ListDeviceFleetsInput, arg2 ...request.Option) (*sagemaker.ListDeviceFleetsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListDeviceFleetsWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.ListDeviceFleetsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListDeviceFleetsWithContext indicates an expected call of ListDeviceFleetsWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListDeviceFleetsWithContext(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, "ListDeviceFleetsWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListDeviceFleetsWithContext), varargs...)
}

// ListDevices mocks base method.
func (m *MockSageMakerAPI) ListDevices(arg0 *sagemaker.ListDevicesInput) (*sagemaker.ListDevicesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListDevices", arg0)
	ret0, _ := ret[0].(*sagemaker.ListDevicesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListDevices indicates an expected call of ListDevices.
func (mr *MockSageMakerAPIMockRecorder) ListDevices(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListDevices", reflect.TypeOf((*MockSageMakerAPI)(nil).ListDevices), arg0)
}

// ListDevicesPages mocks base method.
func (m *MockSageMakerAPI) ListDevicesPages(arg0 *sagemaker.ListDevicesInput, arg1 func(*sagemaker.ListDevicesOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListDevicesPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListDevicesPages indicates an expected call of ListDevicesPages.
func (mr *MockSageMakerAPIMockRecorder) ListDevicesPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListDevicesPages", reflect.TypeOf((*MockSageMakerAPI)(nil).ListDevicesPages), arg0, arg1)
}

// ListDevicesPagesWithContext mocks base method.
func (m *MockSageMakerAPI) ListDevicesPagesWithContext(arg0 aws.Context, arg1 *sagemaker.ListDevicesInput, arg2 func(*sagemaker.ListDevicesOutput, 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, "ListDevicesPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListDevicesPagesWithContext indicates an expected call of ListDevicesPagesWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListDevicesPagesWithContext(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, "ListDevicesPagesWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListDevicesPagesWithContext), varargs...)
}

// ListDevicesRequest mocks base method.
func (m *MockSageMakerAPI) ListDevicesRequest(arg0 *sagemaker.ListDevicesInput) (*request.Request, *sagemaker.ListDevicesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListDevicesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.ListDevicesOutput)
	return ret0, ret1
}

// ListDevicesRequest indicates an expected call of ListDevicesRequest.
func (mr *MockSageMakerAPIMockRecorder) ListDevicesRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListDevicesRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).ListDevicesRequest), arg0)
}

// ListDevicesWithContext mocks base method.
func (m *MockSageMakerAPI) ListDevicesWithContext(arg0 aws.Context, arg1 *sagemaker.ListDevicesInput, arg2 ...request.Option) (*sagemaker.ListDevicesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListDevicesWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.ListDevicesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListDevicesWithContext indicates an expected call of ListDevicesWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListDevicesWithContext(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, "ListDevicesWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListDevicesWithContext), varargs...)
}

// ListDomains mocks base method.
func (m *MockSageMakerAPI) ListDomains(arg0 *sagemaker.ListDomainsInput) (*sagemaker.ListDomainsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListDomains", arg0)
	ret0, _ := ret[0].(*sagemaker.ListDomainsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListDomains indicates an expected call of ListDomains.
func (mr *MockSageMakerAPIMockRecorder) ListDomains(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListDomains", reflect.TypeOf((*MockSageMakerAPI)(nil).ListDomains), arg0)
}

// ListDomainsPages mocks base method.
func (m *MockSageMakerAPI) ListDomainsPages(arg0 *sagemaker.ListDomainsInput, arg1 func(*sagemaker.ListDomainsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListDomainsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListDomainsPages indicates an expected call of ListDomainsPages.
func (mr *MockSageMakerAPIMockRecorder) ListDomainsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListDomainsPages", reflect.TypeOf((*MockSageMakerAPI)(nil).ListDomainsPages), arg0, arg1)
}

// ListDomainsPagesWithContext mocks base method.
func (m *MockSageMakerAPI) ListDomainsPagesWithContext(arg0 aws.Context, arg1 *sagemaker.ListDomainsInput, arg2 func(*sagemaker.ListDomainsOutput, 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, "ListDomainsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListDomainsPagesWithContext indicates an expected call of ListDomainsPagesWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListDomainsPagesWithContext(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, "ListDomainsPagesWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListDomainsPagesWithContext), varargs...)
}

// ListDomainsRequest mocks base method.
func (m *MockSageMakerAPI) ListDomainsRequest(arg0 *sagemaker.ListDomainsInput) (*request.Request, *sagemaker.ListDomainsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListDomainsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.ListDomainsOutput)
	return ret0, ret1
}

// ListDomainsRequest indicates an expected call of ListDomainsRequest.
func (mr *MockSageMakerAPIMockRecorder) ListDomainsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListDomainsRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).ListDomainsRequest), arg0)
}

// ListDomainsWithContext mocks base method.
func (m *MockSageMakerAPI) ListDomainsWithContext(arg0 aws.Context, arg1 *sagemaker.ListDomainsInput, arg2 ...request.Option) (*sagemaker.ListDomainsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListDomainsWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.ListDomainsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListDomainsWithContext indicates an expected call of ListDomainsWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListDomainsWithContext(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, "ListDomainsWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListDomainsWithContext), varargs...)
}

// ListEdgeDeploymentPlans mocks base method.
func (m *MockSageMakerAPI) ListEdgeDeploymentPlans(arg0 *sagemaker.ListEdgeDeploymentPlansInput) (*sagemaker.ListEdgeDeploymentPlansOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListEdgeDeploymentPlans", arg0)
	ret0, _ := ret[0].(*sagemaker.ListEdgeDeploymentPlansOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListEdgeDeploymentPlans indicates an expected call of ListEdgeDeploymentPlans.
func (mr *MockSageMakerAPIMockRecorder) ListEdgeDeploymentPlans(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListEdgeDeploymentPlans", reflect.TypeOf((*MockSageMakerAPI)(nil).ListEdgeDeploymentPlans), arg0)
}

// ListEdgeDeploymentPlansPages mocks base method.
func (m *MockSageMakerAPI) ListEdgeDeploymentPlansPages(arg0 *sagemaker.ListEdgeDeploymentPlansInput, arg1 func(*sagemaker.ListEdgeDeploymentPlansOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListEdgeDeploymentPlansPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListEdgeDeploymentPlansPages indicates an expected call of ListEdgeDeploymentPlansPages.
func (mr *MockSageMakerAPIMockRecorder) ListEdgeDeploymentPlansPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListEdgeDeploymentPlansPages", reflect.TypeOf((*MockSageMakerAPI)(nil).ListEdgeDeploymentPlansPages), arg0, arg1)
}

// ListEdgeDeploymentPlansPagesWithContext mocks base method.
func (m *MockSageMakerAPI) ListEdgeDeploymentPlansPagesWithContext(arg0 aws.Context, arg1 *sagemaker.ListEdgeDeploymentPlansInput, arg2 func(*sagemaker.ListEdgeDeploymentPlansOutput, 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, "ListEdgeDeploymentPlansPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListEdgeDeploymentPlansPagesWithContext indicates an expected call of ListEdgeDeploymentPlansPagesWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListEdgeDeploymentPlansPagesWithContext(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, "ListEdgeDeploymentPlansPagesWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListEdgeDeploymentPlansPagesWithContext), varargs...)
}

// ListEdgeDeploymentPlansRequest mocks base method.
func (m *MockSageMakerAPI) ListEdgeDeploymentPlansRequest(arg0 *sagemaker.ListEdgeDeploymentPlansInput) (*request.Request, *sagemaker.ListEdgeDeploymentPlansOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListEdgeDeploymentPlansRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.ListEdgeDeploymentPlansOutput)
	return ret0, ret1
}

// ListEdgeDeploymentPlansRequest indicates an expected call of ListEdgeDeploymentPlansRequest.
func (mr *MockSageMakerAPIMockRecorder) ListEdgeDeploymentPlansRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListEdgeDeploymentPlansRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).ListEdgeDeploymentPlansRequest), arg0)
}

// ListEdgeDeploymentPlansWithContext mocks base method.
func (m *MockSageMakerAPI) ListEdgeDeploymentPlansWithContext(arg0 aws.Context, arg1 *sagemaker.ListEdgeDeploymentPlansInput, arg2 ...request.Option) (*sagemaker.ListEdgeDeploymentPlansOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListEdgeDeploymentPlansWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.ListEdgeDeploymentPlansOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListEdgeDeploymentPlansWithContext indicates an expected call of ListEdgeDeploymentPlansWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListEdgeDeploymentPlansWithContext(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, "ListEdgeDeploymentPlansWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListEdgeDeploymentPlansWithContext), varargs...)
}

// ListEdgePackagingJobs mocks base method.
func (m *MockSageMakerAPI) ListEdgePackagingJobs(arg0 *sagemaker.ListEdgePackagingJobsInput) (*sagemaker.ListEdgePackagingJobsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListEdgePackagingJobs", arg0)
	ret0, _ := ret[0].(*sagemaker.ListEdgePackagingJobsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListEdgePackagingJobs indicates an expected call of ListEdgePackagingJobs.
func (mr *MockSageMakerAPIMockRecorder) ListEdgePackagingJobs(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListEdgePackagingJobs", reflect.TypeOf((*MockSageMakerAPI)(nil).ListEdgePackagingJobs), arg0)
}

// ListEdgePackagingJobsPages mocks base method.
func (m *MockSageMakerAPI) ListEdgePackagingJobsPages(arg0 *sagemaker.ListEdgePackagingJobsInput, arg1 func(*sagemaker.ListEdgePackagingJobsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListEdgePackagingJobsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListEdgePackagingJobsPages indicates an expected call of ListEdgePackagingJobsPages.
func (mr *MockSageMakerAPIMockRecorder) ListEdgePackagingJobsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListEdgePackagingJobsPages", reflect.TypeOf((*MockSageMakerAPI)(nil).ListEdgePackagingJobsPages), arg0, arg1)
}

// ListEdgePackagingJobsPagesWithContext mocks base method.
func (m *MockSageMakerAPI) ListEdgePackagingJobsPagesWithContext(arg0 aws.Context, arg1 *sagemaker.ListEdgePackagingJobsInput, arg2 func(*sagemaker.ListEdgePackagingJobsOutput, 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, "ListEdgePackagingJobsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListEdgePackagingJobsPagesWithContext indicates an expected call of ListEdgePackagingJobsPagesWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListEdgePackagingJobsPagesWithContext(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, "ListEdgePackagingJobsPagesWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListEdgePackagingJobsPagesWithContext), varargs...)
}

// ListEdgePackagingJobsRequest mocks base method.
func (m *MockSageMakerAPI) ListEdgePackagingJobsRequest(arg0 *sagemaker.ListEdgePackagingJobsInput) (*request.Request, *sagemaker.ListEdgePackagingJobsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListEdgePackagingJobsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.ListEdgePackagingJobsOutput)
	return ret0, ret1
}

// ListEdgePackagingJobsRequest indicates an expected call of ListEdgePackagingJobsRequest.
func (mr *MockSageMakerAPIMockRecorder) ListEdgePackagingJobsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListEdgePackagingJobsRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).ListEdgePackagingJobsRequest), arg0)
}

// ListEdgePackagingJobsWithContext mocks base method.
func (m *MockSageMakerAPI) ListEdgePackagingJobsWithContext(arg0 aws.Context, arg1 *sagemaker.ListEdgePackagingJobsInput, arg2 ...request.Option) (*sagemaker.ListEdgePackagingJobsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListEdgePackagingJobsWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.ListEdgePackagingJobsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListEdgePackagingJobsWithContext indicates an expected call of ListEdgePackagingJobsWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListEdgePackagingJobsWithContext(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, "ListEdgePackagingJobsWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListEdgePackagingJobsWithContext), varargs...)
}

// ListEndpointConfigs mocks base method.
func (m *MockSageMakerAPI) ListEndpointConfigs(arg0 *sagemaker.ListEndpointConfigsInput) (*sagemaker.ListEndpointConfigsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListEndpointConfigs", arg0)
	ret0, _ := ret[0].(*sagemaker.ListEndpointConfigsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListEndpointConfigs indicates an expected call of ListEndpointConfigs.
func (mr *MockSageMakerAPIMockRecorder) ListEndpointConfigs(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListEndpointConfigs", reflect.TypeOf((*MockSageMakerAPI)(nil).ListEndpointConfigs), arg0)
}

// ListEndpointConfigsPages mocks base method.
func (m *MockSageMakerAPI) ListEndpointConfigsPages(arg0 *sagemaker.ListEndpointConfigsInput, arg1 func(*sagemaker.ListEndpointConfigsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListEndpointConfigsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListEndpointConfigsPages indicates an expected call of ListEndpointConfigsPages.
func (mr *MockSageMakerAPIMockRecorder) ListEndpointConfigsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListEndpointConfigsPages", reflect.TypeOf((*MockSageMakerAPI)(nil).ListEndpointConfigsPages), arg0, arg1)
}

// ListEndpointConfigsPagesWithContext mocks base method.
func (m *MockSageMakerAPI) ListEndpointConfigsPagesWithContext(arg0 aws.Context, arg1 *sagemaker.ListEndpointConfigsInput, arg2 func(*sagemaker.ListEndpointConfigsOutput, 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, "ListEndpointConfigsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListEndpointConfigsPagesWithContext indicates an expected call of ListEndpointConfigsPagesWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListEndpointConfigsPagesWithContext(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, "ListEndpointConfigsPagesWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListEndpointConfigsPagesWithContext), varargs...)
}

// ListEndpointConfigsRequest mocks base method.
func (m *MockSageMakerAPI) ListEndpointConfigsRequest(arg0 *sagemaker.ListEndpointConfigsInput) (*request.Request, *sagemaker.ListEndpointConfigsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListEndpointConfigsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.ListEndpointConfigsOutput)
	return ret0, ret1
}

// ListEndpointConfigsRequest indicates an expected call of ListEndpointConfigsRequest.
func (mr *MockSageMakerAPIMockRecorder) ListEndpointConfigsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListEndpointConfigsRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).ListEndpointConfigsRequest), arg0)
}

// ListEndpointConfigsWithContext mocks base method.
func (m *MockSageMakerAPI) ListEndpointConfigsWithContext(arg0 aws.Context, arg1 *sagemaker.ListEndpointConfigsInput, arg2 ...request.Option) (*sagemaker.ListEndpointConfigsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListEndpointConfigsWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.ListEndpointConfigsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListEndpointConfigsWithContext indicates an expected call of ListEndpointConfigsWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListEndpointConfigsWithContext(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, "ListEndpointConfigsWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListEndpointConfigsWithContext), varargs...)
}

// ListEndpoints mocks base method.
func (m *MockSageMakerAPI) ListEndpoints(arg0 *sagemaker.ListEndpointsInput) (*sagemaker.ListEndpointsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListEndpoints", arg0)
	ret0, _ := ret[0].(*sagemaker.ListEndpointsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListEndpoints indicates an expected call of ListEndpoints.
func (mr *MockSageMakerAPIMockRecorder) ListEndpoints(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListEndpoints", reflect.TypeOf((*MockSageMakerAPI)(nil).ListEndpoints), arg0)
}

// ListEndpointsPages mocks base method.
func (m *MockSageMakerAPI) ListEndpointsPages(arg0 *sagemaker.ListEndpointsInput, arg1 func(*sagemaker.ListEndpointsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListEndpointsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListEndpointsPages indicates an expected call of ListEndpointsPages.
func (mr *MockSageMakerAPIMockRecorder) ListEndpointsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListEndpointsPages", reflect.TypeOf((*MockSageMakerAPI)(nil).ListEndpointsPages), arg0, arg1)
}

// ListEndpointsPagesWithContext mocks base method.
func (m *MockSageMakerAPI) ListEndpointsPagesWithContext(arg0 aws.Context, arg1 *sagemaker.ListEndpointsInput, arg2 func(*sagemaker.ListEndpointsOutput, 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, "ListEndpointsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListEndpointsPagesWithContext indicates an expected call of ListEndpointsPagesWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListEndpointsPagesWithContext(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, "ListEndpointsPagesWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListEndpointsPagesWithContext), varargs...)
}

// ListEndpointsRequest mocks base method.
func (m *MockSageMakerAPI) ListEndpointsRequest(arg0 *sagemaker.ListEndpointsInput) (*request.Request, *sagemaker.ListEndpointsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListEndpointsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.ListEndpointsOutput)
	return ret0, ret1
}

// ListEndpointsRequest indicates an expected call of ListEndpointsRequest.
func (mr *MockSageMakerAPIMockRecorder) ListEndpointsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListEndpointsRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).ListEndpointsRequest), arg0)
}

// ListEndpointsWithContext mocks base method.
func (m *MockSageMakerAPI) ListEndpointsWithContext(arg0 aws.Context, arg1 *sagemaker.ListEndpointsInput, arg2 ...request.Option) (*sagemaker.ListEndpointsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListEndpointsWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.ListEndpointsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListEndpointsWithContext indicates an expected call of ListEndpointsWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListEndpointsWithContext(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, "ListEndpointsWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListEndpointsWithContext), varargs...)
}

// ListExperiments mocks base method.
func (m *MockSageMakerAPI) ListExperiments(arg0 *sagemaker.ListExperimentsInput) (*sagemaker.ListExperimentsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListExperiments", arg0)
	ret0, _ := ret[0].(*sagemaker.ListExperimentsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListExperiments indicates an expected call of ListExperiments.
func (mr *MockSageMakerAPIMockRecorder) ListExperiments(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListExperiments", reflect.TypeOf((*MockSageMakerAPI)(nil).ListExperiments), arg0)
}

// ListExperimentsPages mocks base method.
func (m *MockSageMakerAPI) ListExperimentsPages(arg0 *sagemaker.ListExperimentsInput, arg1 func(*sagemaker.ListExperimentsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListExperimentsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListExperimentsPages indicates an expected call of ListExperimentsPages.
func (mr *MockSageMakerAPIMockRecorder) ListExperimentsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListExperimentsPages", reflect.TypeOf((*MockSageMakerAPI)(nil).ListExperimentsPages), arg0, arg1)
}

// ListExperimentsPagesWithContext mocks base method.
func (m *MockSageMakerAPI) ListExperimentsPagesWithContext(arg0 aws.Context, arg1 *sagemaker.ListExperimentsInput, arg2 func(*sagemaker.ListExperimentsOutput, 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, "ListExperimentsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListExperimentsPagesWithContext indicates an expected call of ListExperimentsPagesWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListExperimentsPagesWithContext(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, "ListExperimentsPagesWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListExperimentsPagesWithContext), varargs...)
}

// ListExperimentsRequest mocks base method.
func (m *MockSageMakerAPI) ListExperimentsRequest(arg0 *sagemaker.ListExperimentsInput) (*request.Request, *sagemaker.ListExperimentsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListExperimentsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.ListExperimentsOutput)
	return ret0, ret1
}

// ListExperimentsRequest indicates an expected call of ListExperimentsRequest.
func (mr *MockSageMakerAPIMockRecorder) ListExperimentsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListExperimentsRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).ListExperimentsRequest), arg0)
}

// ListExperimentsWithContext mocks base method.
func (m *MockSageMakerAPI) ListExperimentsWithContext(arg0 aws.Context, arg1 *sagemaker.ListExperimentsInput, arg2 ...request.Option) (*sagemaker.ListExperimentsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListExperimentsWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.ListExperimentsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListExperimentsWithContext indicates an expected call of ListExperimentsWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListExperimentsWithContext(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, "ListExperimentsWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListExperimentsWithContext), varargs...)
}

// ListFeatureGroups mocks base method.
func (m *MockSageMakerAPI) ListFeatureGroups(arg0 *sagemaker.ListFeatureGroupsInput) (*sagemaker.ListFeatureGroupsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListFeatureGroups", arg0)
	ret0, _ := ret[0].(*sagemaker.ListFeatureGroupsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListFeatureGroups indicates an expected call of ListFeatureGroups.
func (mr *MockSageMakerAPIMockRecorder) ListFeatureGroups(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListFeatureGroups", reflect.TypeOf((*MockSageMakerAPI)(nil).ListFeatureGroups), arg0)
}

// ListFeatureGroupsPages mocks base method.
func (m *MockSageMakerAPI) ListFeatureGroupsPages(arg0 *sagemaker.ListFeatureGroupsInput, arg1 func(*sagemaker.ListFeatureGroupsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListFeatureGroupsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListFeatureGroupsPages indicates an expected call of ListFeatureGroupsPages.
func (mr *MockSageMakerAPIMockRecorder) ListFeatureGroupsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListFeatureGroupsPages", reflect.TypeOf((*MockSageMakerAPI)(nil).ListFeatureGroupsPages), arg0, arg1)
}

// ListFeatureGroupsPagesWithContext mocks base method.
func (m *MockSageMakerAPI) ListFeatureGroupsPagesWithContext(arg0 aws.Context, arg1 *sagemaker.ListFeatureGroupsInput, arg2 func(*sagemaker.ListFeatureGroupsOutput, 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, "ListFeatureGroupsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListFeatureGroupsPagesWithContext indicates an expected call of ListFeatureGroupsPagesWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListFeatureGroupsPagesWithContext(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, "ListFeatureGroupsPagesWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListFeatureGroupsPagesWithContext), varargs...)
}

// ListFeatureGroupsRequest mocks base method.
func (m *MockSageMakerAPI) ListFeatureGroupsRequest(arg0 *sagemaker.ListFeatureGroupsInput) (*request.Request, *sagemaker.ListFeatureGroupsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListFeatureGroupsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.ListFeatureGroupsOutput)
	return ret0, ret1
}

// ListFeatureGroupsRequest indicates an expected call of ListFeatureGroupsRequest.
func (mr *MockSageMakerAPIMockRecorder) ListFeatureGroupsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListFeatureGroupsRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).ListFeatureGroupsRequest), arg0)
}

// ListFeatureGroupsWithContext mocks base method.
func (m *MockSageMakerAPI) ListFeatureGroupsWithContext(arg0 aws.Context, arg1 *sagemaker.ListFeatureGroupsInput, arg2 ...request.Option) (*sagemaker.ListFeatureGroupsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListFeatureGroupsWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.ListFeatureGroupsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListFeatureGroupsWithContext indicates an expected call of ListFeatureGroupsWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListFeatureGroupsWithContext(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, "ListFeatureGroupsWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListFeatureGroupsWithContext), varargs...)
}

// ListFlowDefinitions mocks base method.
func (m *MockSageMakerAPI) ListFlowDefinitions(arg0 *sagemaker.ListFlowDefinitionsInput) (*sagemaker.ListFlowDefinitionsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListFlowDefinitions", arg0)
	ret0, _ := ret[0].(*sagemaker.ListFlowDefinitionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListFlowDefinitions indicates an expected call of ListFlowDefinitions.
func (mr *MockSageMakerAPIMockRecorder) ListFlowDefinitions(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListFlowDefinitions", reflect.TypeOf((*MockSageMakerAPI)(nil).ListFlowDefinitions), arg0)
}

// ListFlowDefinitionsPages mocks base method.
func (m *MockSageMakerAPI) ListFlowDefinitionsPages(arg0 *sagemaker.ListFlowDefinitionsInput, arg1 func(*sagemaker.ListFlowDefinitionsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListFlowDefinitionsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListFlowDefinitionsPages indicates an expected call of ListFlowDefinitionsPages.
func (mr *MockSageMakerAPIMockRecorder) ListFlowDefinitionsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListFlowDefinitionsPages", reflect.TypeOf((*MockSageMakerAPI)(nil).ListFlowDefinitionsPages), arg0, arg1)
}

// ListFlowDefinitionsPagesWithContext mocks base method.
func (m *MockSageMakerAPI) ListFlowDefinitionsPagesWithContext(arg0 aws.Context, arg1 *sagemaker.ListFlowDefinitionsInput, arg2 func(*sagemaker.ListFlowDefinitionsOutput, 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, "ListFlowDefinitionsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListFlowDefinitionsPagesWithContext indicates an expected call of ListFlowDefinitionsPagesWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListFlowDefinitionsPagesWithContext(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, "ListFlowDefinitionsPagesWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListFlowDefinitionsPagesWithContext), varargs...)
}

// ListFlowDefinitionsRequest mocks base method.
func (m *MockSageMakerAPI) ListFlowDefinitionsRequest(arg0 *sagemaker.ListFlowDefinitionsInput) (*request.Request, *sagemaker.ListFlowDefinitionsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListFlowDefinitionsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.ListFlowDefinitionsOutput)
	return ret0, ret1
}

// ListFlowDefinitionsRequest indicates an expected call of ListFlowDefinitionsRequest.
func (mr *MockSageMakerAPIMockRecorder) ListFlowDefinitionsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListFlowDefinitionsRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).ListFlowDefinitionsRequest), arg0)
}

// ListFlowDefinitionsWithContext mocks base method.
func (m *MockSageMakerAPI) ListFlowDefinitionsWithContext(arg0 aws.Context, arg1 *sagemaker.ListFlowDefinitionsInput, arg2 ...request.Option) (*sagemaker.ListFlowDefinitionsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListFlowDefinitionsWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.ListFlowDefinitionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListFlowDefinitionsWithContext indicates an expected call of ListFlowDefinitionsWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListFlowDefinitionsWithContext(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, "ListFlowDefinitionsWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListFlowDefinitionsWithContext), varargs...)
}

// ListHubContentVersions mocks base method.
func (m *MockSageMakerAPI) ListHubContentVersions(arg0 *sagemaker.ListHubContentVersionsInput) (*sagemaker.ListHubContentVersionsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListHubContentVersions", arg0)
	ret0, _ := ret[0].(*sagemaker.ListHubContentVersionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListHubContentVersions indicates an expected call of ListHubContentVersions.
func (mr *MockSageMakerAPIMockRecorder) ListHubContentVersions(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListHubContentVersions", reflect.TypeOf((*MockSageMakerAPI)(nil).ListHubContentVersions), arg0)
}

// ListHubContentVersionsRequest mocks base method.
func (m *MockSageMakerAPI) ListHubContentVersionsRequest(arg0 *sagemaker.ListHubContentVersionsInput) (*request.Request, *sagemaker.ListHubContentVersionsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListHubContentVersionsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.ListHubContentVersionsOutput)
	return ret0, ret1
}

// ListHubContentVersionsRequest indicates an expected call of ListHubContentVersionsRequest.
func (mr *MockSageMakerAPIMockRecorder) ListHubContentVersionsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListHubContentVersionsRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).ListHubContentVersionsRequest), arg0)
}

// ListHubContentVersionsWithContext mocks base method.
func (m *MockSageMakerAPI) ListHubContentVersionsWithContext(arg0 aws.Context, arg1 *sagemaker.ListHubContentVersionsInput, arg2 ...request.Option) (*sagemaker.ListHubContentVersionsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListHubContentVersionsWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.ListHubContentVersionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListHubContentVersionsWithContext indicates an expected call of ListHubContentVersionsWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListHubContentVersionsWithContext(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, "ListHubContentVersionsWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListHubContentVersionsWithContext), varargs...)
}

// ListHubContents mocks base method.
func (m *MockSageMakerAPI) ListHubContents(arg0 *sagemaker.ListHubContentsInput) (*sagemaker.ListHubContentsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListHubContents", arg0)
	ret0, _ := ret[0].(*sagemaker.ListHubContentsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListHubContents indicates an expected call of ListHubContents.
func (mr *MockSageMakerAPIMockRecorder) ListHubContents(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListHubContents", reflect.TypeOf((*MockSageMakerAPI)(nil).ListHubContents), arg0)
}

// ListHubContentsRequest mocks base method.
func (m *MockSageMakerAPI) ListHubContentsRequest(arg0 *sagemaker.ListHubContentsInput) (*request.Request, *sagemaker.ListHubContentsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListHubContentsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.ListHubContentsOutput)
	return ret0, ret1
}

// ListHubContentsRequest indicates an expected call of ListHubContentsRequest.
func (mr *MockSageMakerAPIMockRecorder) ListHubContentsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListHubContentsRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).ListHubContentsRequest), arg0)
}

// ListHubContentsWithContext mocks base method.
func (m *MockSageMakerAPI) ListHubContentsWithContext(arg0 aws.Context, arg1 *sagemaker.ListHubContentsInput, arg2 ...request.Option) (*sagemaker.ListHubContentsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListHubContentsWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.ListHubContentsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListHubContentsWithContext indicates an expected call of ListHubContentsWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListHubContentsWithContext(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, "ListHubContentsWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListHubContentsWithContext), varargs...)
}

// ListHubs mocks base method.
func (m *MockSageMakerAPI) ListHubs(arg0 *sagemaker.ListHubsInput) (*sagemaker.ListHubsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListHubs", arg0)
	ret0, _ := ret[0].(*sagemaker.ListHubsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListHubs indicates an expected call of ListHubs.
func (mr *MockSageMakerAPIMockRecorder) ListHubs(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListHubs", reflect.TypeOf((*MockSageMakerAPI)(nil).ListHubs), arg0)
}

// ListHubsRequest mocks base method.
func (m *MockSageMakerAPI) ListHubsRequest(arg0 *sagemaker.ListHubsInput) (*request.Request, *sagemaker.ListHubsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListHubsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.ListHubsOutput)
	return ret0, ret1
}

// ListHubsRequest indicates an expected call of ListHubsRequest.
func (mr *MockSageMakerAPIMockRecorder) ListHubsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListHubsRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).ListHubsRequest), arg0)
}

// ListHubsWithContext mocks base method.
func (m *MockSageMakerAPI) ListHubsWithContext(arg0 aws.Context, arg1 *sagemaker.ListHubsInput, arg2 ...request.Option) (*sagemaker.ListHubsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListHubsWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.ListHubsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListHubsWithContext indicates an expected call of ListHubsWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListHubsWithContext(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, "ListHubsWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListHubsWithContext), varargs...)
}

// ListHumanTaskUis mocks base method.
func (m *MockSageMakerAPI) ListHumanTaskUis(arg0 *sagemaker.ListHumanTaskUisInput) (*sagemaker.ListHumanTaskUisOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListHumanTaskUis", arg0)
	ret0, _ := ret[0].(*sagemaker.ListHumanTaskUisOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListHumanTaskUis indicates an expected call of ListHumanTaskUis.
func (mr *MockSageMakerAPIMockRecorder) ListHumanTaskUis(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListHumanTaskUis", reflect.TypeOf((*MockSageMakerAPI)(nil).ListHumanTaskUis), arg0)
}

// ListHumanTaskUisPages mocks base method.
func (m *MockSageMakerAPI) ListHumanTaskUisPages(arg0 *sagemaker.ListHumanTaskUisInput, arg1 func(*sagemaker.ListHumanTaskUisOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListHumanTaskUisPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListHumanTaskUisPages indicates an expected call of ListHumanTaskUisPages.
func (mr *MockSageMakerAPIMockRecorder) ListHumanTaskUisPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListHumanTaskUisPages", reflect.TypeOf((*MockSageMakerAPI)(nil).ListHumanTaskUisPages), arg0, arg1)
}

// ListHumanTaskUisPagesWithContext mocks base method.
func (m *MockSageMakerAPI) ListHumanTaskUisPagesWithContext(arg0 aws.Context, arg1 *sagemaker.ListHumanTaskUisInput, arg2 func(*sagemaker.ListHumanTaskUisOutput, 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, "ListHumanTaskUisPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListHumanTaskUisPagesWithContext indicates an expected call of ListHumanTaskUisPagesWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListHumanTaskUisPagesWithContext(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, "ListHumanTaskUisPagesWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListHumanTaskUisPagesWithContext), varargs...)
}

// ListHumanTaskUisRequest mocks base method.
func (m *MockSageMakerAPI) ListHumanTaskUisRequest(arg0 *sagemaker.ListHumanTaskUisInput) (*request.Request, *sagemaker.ListHumanTaskUisOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListHumanTaskUisRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.ListHumanTaskUisOutput)
	return ret0, ret1
}

// ListHumanTaskUisRequest indicates an expected call of ListHumanTaskUisRequest.
func (mr *MockSageMakerAPIMockRecorder) ListHumanTaskUisRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListHumanTaskUisRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).ListHumanTaskUisRequest), arg0)
}

// ListHumanTaskUisWithContext mocks base method.
func (m *MockSageMakerAPI) ListHumanTaskUisWithContext(arg0 aws.Context, arg1 *sagemaker.ListHumanTaskUisInput, arg2 ...request.Option) (*sagemaker.ListHumanTaskUisOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListHumanTaskUisWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.ListHumanTaskUisOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListHumanTaskUisWithContext indicates an expected call of ListHumanTaskUisWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListHumanTaskUisWithContext(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, "ListHumanTaskUisWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListHumanTaskUisWithContext), varargs...)
}

// ListHyperParameterTuningJobs mocks base method.
func (m *MockSageMakerAPI) ListHyperParameterTuningJobs(arg0 *sagemaker.ListHyperParameterTuningJobsInput) (*sagemaker.ListHyperParameterTuningJobsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListHyperParameterTuningJobs", arg0)
	ret0, _ := ret[0].(*sagemaker.ListHyperParameterTuningJobsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListHyperParameterTuningJobs indicates an expected call of ListHyperParameterTuningJobs.
func (mr *MockSageMakerAPIMockRecorder) ListHyperParameterTuningJobs(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListHyperParameterTuningJobs", reflect.TypeOf((*MockSageMakerAPI)(nil).ListHyperParameterTuningJobs), arg0)
}

// ListHyperParameterTuningJobsPages mocks base method.
func (m *MockSageMakerAPI) ListHyperParameterTuningJobsPages(arg0 *sagemaker.ListHyperParameterTuningJobsInput, arg1 func(*sagemaker.ListHyperParameterTuningJobsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListHyperParameterTuningJobsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListHyperParameterTuningJobsPages indicates an expected call of ListHyperParameterTuningJobsPages.
func (mr *MockSageMakerAPIMockRecorder) ListHyperParameterTuningJobsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListHyperParameterTuningJobsPages", reflect.TypeOf((*MockSageMakerAPI)(nil).ListHyperParameterTuningJobsPages), arg0, arg1)
}

// ListHyperParameterTuningJobsPagesWithContext mocks base method.
func (m *MockSageMakerAPI) ListHyperParameterTuningJobsPagesWithContext(arg0 aws.Context, arg1 *sagemaker.ListHyperParameterTuningJobsInput, arg2 func(*sagemaker.ListHyperParameterTuningJobsOutput, 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, "ListHyperParameterTuningJobsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListHyperParameterTuningJobsPagesWithContext indicates an expected call of ListHyperParameterTuningJobsPagesWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListHyperParameterTuningJobsPagesWithContext(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, "ListHyperParameterTuningJobsPagesWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListHyperParameterTuningJobsPagesWithContext), varargs...)
}

// ListHyperParameterTuningJobsRequest mocks base method.
func (m *MockSageMakerAPI) ListHyperParameterTuningJobsRequest(arg0 *sagemaker.ListHyperParameterTuningJobsInput) (*request.Request, *sagemaker.ListHyperParameterTuningJobsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListHyperParameterTuningJobsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.ListHyperParameterTuningJobsOutput)
	return ret0, ret1
}

// ListHyperParameterTuningJobsRequest indicates an expected call of ListHyperParameterTuningJobsRequest.
func (mr *MockSageMakerAPIMockRecorder) ListHyperParameterTuningJobsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListHyperParameterTuningJobsRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).ListHyperParameterTuningJobsRequest), arg0)
}

// ListHyperParameterTuningJobsWithContext mocks base method.
func (m *MockSageMakerAPI) ListHyperParameterTuningJobsWithContext(arg0 aws.Context, arg1 *sagemaker.ListHyperParameterTuningJobsInput, arg2 ...request.Option) (*sagemaker.ListHyperParameterTuningJobsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListHyperParameterTuningJobsWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.ListHyperParameterTuningJobsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListHyperParameterTuningJobsWithContext indicates an expected call of ListHyperParameterTuningJobsWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListHyperParameterTuningJobsWithContext(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, "ListHyperParameterTuningJobsWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListHyperParameterTuningJobsWithContext), varargs...)
}

// ListImageVersions mocks base method.
func (m *MockSageMakerAPI) ListImageVersions(arg0 *sagemaker.ListImageVersionsInput) (*sagemaker.ListImageVersionsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListImageVersions", arg0)
	ret0, _ := ret[0].(*sagemaker.ListImageVersionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListImageVersions indicates an expected call of ListImageVersions.
func (mr *MockSageMakerAPIMockRecorder) ListImageVersions(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListImageVersions", reflect.TypeOf((*MockSageMakerAPI)(nil).ListImageVersions), arg0)
}

// ListImageVersionsPages mocks base method.
func (m *MockSageMakerAPI) ListImageVersionsPages(arg0 *sagemaker.ListImageVersionsInput, arg1 func(*sagemaker.ListImageVersionsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListImageVersionsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListImageVersionsPages indicates an expected call of ListImageVersionsPages.
func (mr *MockSageMakerAPIMockRecorder) ListImageVersionsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListImageVersionsPages", reflect.TypeOf((*MockSageMakerAPI)(nil).ListImageVersionsPages), arg0, arg1)
}

// ListImageVersionsPagesWithContext mocks base method.
func (m *MockSageMakerAPI) ListImageVersionsPagesWithContext(arg0 aws.Context, arg1 *sagemaker.ListImageVersionsInput, arg2 func(*sagemaker.ListImageVersionsOutput, 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, "ListImageVersionsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListImageVersionsPagesWithContext indicates an expected call of ListImageVersionsPagesWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListImageVersionsPagesWithContext(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, "ListImageVersionsPagesWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListImageVersionsPagesWithContext), varargs...)
}

// ListImageVersionsRequest mocks base method.
func (m *MockSageMakerAPI) ListImageVersionsRequest(arg0 *sagemaker.ListImageVersionsInput) (*request.Request, *sagemaker.ListImageVersionsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListImageVersionsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.ListImageVersionsOutput)
	return ret0, ret1
}

// ListImageVersionsRequest indicates an expected call of ListImageVersionsRequest.
func (mr *MockSageMakerAPIMockRecorder) ListImageVersionsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListImageVersionsRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).ListImageVersionsRequest), arg0)
}

// ListImageVersionsWithContext mocks base method.
func (m *MockSageMakerAPI) ListImageVersionsWithContext(arg0 aws.Context, arg1 *sagemaker.ListImageVersionsInput, arg2 ...request.Option) (*sagemaker.ListImageVersionsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListImageVersionsWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.ListImageVersionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListImageVersionsWithContext indicates an expected call of ListImageVersionsWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListImageVersionsWithContext(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, "ListImageVersionsWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListImageVersionsWithContext), varargs...)
}

// ListImages mocks base method.
func (m *MockSageMakerAPI) ListImages(arg0 *sagemaker.ListImagesInput) (*sagemaker.ListImagesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListImages", arg0)
	ret0, _ := ret[0].(*sagemaker.ListImagesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListImages indicates an expected call of ListImages.
func (mr *MockSageMakerAPIMockRecorder) ListImages(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListImages", reflect.TypeOf((*MockSageMakerAPI)(nil).ListImages), arg0)
}

// ListImagesPages mocks base method.
func (m *MockSageMakerAPI) ListImagesPages(arg0 *sagemaker.ListImagesInput, arg1 func(*sagemaker.ListImagesOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListImagesPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListImagesPages indicates an expected call of ListImagesPages.
func (mr *MockSageMakerAPIMockRecorder) ListImagesPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListImagesPages", reflect.TypeOf((*MockSageMakerAPI)(nil).ListImagesPages), arg0, arg1)
}

// ListImagesPagesWithContext mocks base method.
func (m *MockSageMakerAPI) ListImagesPagesWithContext(arg0 aws.Context, arg1 *sagemaker.ListImagesInput, arg2 func(*sagemaker.ListImagesOutput, 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, "ListImagesPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListImagesPagesWithContext indicates an expected call of ListImagesPagesWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListImagesPagesWithContext(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, "ListImagesPagesWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListImagesPagesWithContext), varargs...)
}

// ListImagesRequest mocks base method.
func (m *MockSageMakerAPI) ListImagesRequest(arg0 *sagemaker.ListImagesInput) (*request.Request, *sagemaker.ListImagesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListImagesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.ListImagesOutput)
	return ret0, ret1
}

// ListImagesRequest indicates an expected call of ListImagesRequest.
func (mr *MockSageMakerAPIMockRecorder) ListImagesRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListImagesRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).ListImagesRequest), arg0)
}

// ListImagesWithContext mocks base method.
func (m *MockSageMakerAPI) ListImagesWithContext(arg0 aws.Context, arg1 *sagemaker.ListImagesInput, arg2 ...request.Option) (*sagemaker.ListImagesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListImagesWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.ListImagesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListImagesWithContext indicates an expected call of ListImagesWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListImagesWithContext(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, "ListImagesWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListImagesWithContext), varargs...)
}

// ListInferenceComponents mocks base method.
func (m *MockSageMakerAPI) ListInferenceComponents(arg0 *sagemaker.ListInferenceComponentsInput) (*sagemaker.ListInferenceComponentsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListInferenceComponents", arg0)
	ret0, _ := ret[0].(*sagemaker.ListInferenceComponentsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListInferenceComponents indicates an expected call of ListInferenceComponents.
func (mr *MockSageMakerAPIMockRecorder) ListInferenceComponents(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListInferenceComponents", reflect.TypeOf((*MockSageMakerAPI)(nil).ListInferenceComponents), arg0)
}

// ListInferenceComponentsPages mocks base method.
func (m *MockSageMakerAPI) ListInferenceComponentsPages(arg0 *sagemaker.ListInferenceComponentsInput, arg1 func(*sagemaker.ListInferenceComponentsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListInferenceComponentsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListInferenceComponentsPages indicates an expected call of ListInferenceComponentsPages.
func (mr *MockSageMakerAPIMockRecorder) ListInferenceComponentsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListInferenceComponentsPages", reflect.TypeOf((*MockSageMakerAPI)(nil).ListInferenceComponentsPages), arg0, arg1)
}

// ListInferenceComponentsPagesWithContext mocks base method.
func (m *MockSageMakerAPI) ListInferenceComponentsPagesWithContext(arg0 aws.Context, arg1 *sagemaker.ListInferenceComponentsInput, arg2 func(*sagemaker.ListInferenceComponentsOutput, 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, "ListInferenceComponentsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListInferenceComponentsPagesWithContext indicates an expected call of ListInferenceComponentsPagesWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListInferenceComponentsPagesWithContext(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, "ListInferenceComponentsPagesWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListInferenceComponentsPagesWithContext), varargs...)
}

// ListInferenceComponentsRequest mocks base method.
func (m *MockSageMakerAPI) ListInferenceComponentsRequest(arg0 *sagemaker.ListInferenceComponentsInput) (*request.Request, *sagemaker.ListInferenceComponentsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListInferenceComponentsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.ListInferenceComponentsOutput)
	return ret0, ret1
}

// ListInferenceComponentsRequest indicates an expected call of ListInferenceComponentsRequest.
func (mr *MockSageMakerAPIMockRecorder) ListInferenceComponentsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListInferenceComponentsRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).ListInferenceComponentsRequest), arg0)
}

// ListInferenceComponentsWithContext mocks base method.
func (m *MockSageMakerAPI) ListInferenceComponentsWithContext(arg0 aws.Context, arg1 *sagemaker.ListInferenceComponentsInput, arg2 ...request.Option) (*sagemaker.ListInferenceComponentsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListInferenceComponentsWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.ListInferenceComponentsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListInferenceComponentsWithContext indicates an expected call of ListInferenceComponentsWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListInferenceComponentsWithContext(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, "ListInferenceComponentsWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListInferenceComponentsWithContext), varargs...)
}

// ListInferenceExperiments mocks base method.
func (m *MockSageMakerAPI) ListInferenceExperiments(arg0 *sagemaker.ListInferenceExperimentsInput) (*sagemaker.ListInferenceExperimentsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListInferenceExperiments", arg0)
	ret0, _ := ret[0].(*sagemaker.ListInferenceExperimentsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListInferenceExperiments indicates an expected call of ListInferenceExperiments.
func (mr *MockSageMakerAPIMockRecorder) ListInferenceExperiments(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListInferenceExperiments", reflect.TypeOf((*MockSageMakerAPI)(nil).ListInferenceExperiments), arg0)
}

// ListInferenceExperimentsPages mocks base method.
func (m *MockSageMakerAPI) ListInferenceExperimentsPages(arg0 *sagemaker.ListInferenceExperimentsInput, arg1 func(*sagemaker.ListInferenceExperimentsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListInferenceExperimentsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListInferenceExperimentsPages indicates an expected call of ListInferenceExperimentsPages.
func (mr *MockSageMakerAPIMockRecorder) ListInferenceExperimentsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListInferenceExperimentsPages", reflect.TypeOf((*MockSageMakerAPI)(nil).ListInferenceExperimentsPages), arg0, arg1)
}

// ListInferenceExperimentsPagesWithContext mocks base method.
func (m *MockSageMakerAPI) ListInferenceExperimentsPagesWithContext(arg0 aws.Context, arg1 *sagemaker.ListInferenceExperimentsInput, arg2 func(*sagemaker.ListInferenceExperimentsOutput, 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, "ListInferenceExperimentsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListInferenceExperimentsPagesWithContext indicates an expected call of ListInferenceExperimentsPagesWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListInferenceExperimentsPagesWithContext(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, "ListInferenceExperimentsPagesWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListInferenceExperimentsPagesWithContext), varargs...)
}

// ListInferenceExperimentsRequest mocks base method.
func (m *MockSageMakerAPI) ListInferenceExperimentsRequest(arg0 *sagemaker.ListInferenceExperimentsInput) (*request.Request, *sagemaker.ListInferenceExperimentsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListInferenceExperimentsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.ListInferenceExperimentsOutput)
	return ret0, ret1
}

// ListInferenceExperimentsRequest indicates an expected call of ListInferenceExperimentsRequest.
func (mr *MockSageMakerAPIMockRecorder) ListInferenceExperimentsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListInferenceExperimentsRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).ListInferenceExperimentsRequest), arg0)
}

// ListInferenceExperimentsWithContext mocks base method.
func (m *MockSageMakerAPI) ListInferenceExperimentsWithContext(arg0 aws.Context, arg1 *sagemaker.ListInferenceExperimentsInput, arg2 ...request.Option) (*sagemaker.ListInferenceExperimentsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListInferenceExperimentsWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.ListInferenceExperimentsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListInferenceExperimentsWithContext indicates an expected call of ListInferenceExperimentsWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListInferenceExperimentsWithContext(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, "ListInferenceExperimentsWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListInferenceExperimentsWithContext), varargs...)
}

// ListInferenceRecommendationsJobSteps mocks base method.
func (m *MockSageMakerAPI) ListInferenceRecommendationsJobSteps(arg0 *sagemaker.ListInferenceRecommendationsJobStepsInput) (*sagemaker.ListInferenceRecommendationsJobStepsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListInferenceRecommendationsJobSteps", arg0)
	ret0, _ := ret[0].(*sagemaker.ListInferenceRecommendationsJobStepsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListInferenceRecommendationsJobSteps indicates an expected call of ListInferenceRecommendationsJobSteps.
func (mr *MockSageMakerAPIMockRecorder) ListInferenceRecommendationsJobSteps(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListInferenceRecommendationsJobSteps", reflect.TypeOf((*MockSageMakerAPI)(nil).ListInferenceRecommendationsJobSteps), arg0)
}

// ListInferenceRecommendationsJobStepsPages mocks base method.
func (m *MockSageMakerAPI) ListInferenceRecommendationsJobStepsPages(arg0 *sagemaker.ListInferenceRecommendationsJobStepsInput, arg1 func(*sagemaker.ListInferenceRecommendationsJobStepsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListInferenceRecommendationsJobStepsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListInferenceRecommendationsJobStepsPages indicates an expected call of ListInferenceRecommendationsJobStepsPages.
func (mr *MockSageMakerAPIMockRecorder) ListInferenceRecommendationsJobStepsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListInferenceRecommendationsJobStepsPages", reflect.TypeOf((*MockSageMakerAPI)(nil).ListInferenceRecommendationsJobStepsPages), arg0, arg1)
}

// ListInferenceRecommendationsJobStepsPagesWithContext mocks base method.
func (m *MockSageMakerAPI) ListInferenceRecommendationsJobStepsPagesWithContext(arg0 aws.Context, arg1 *sagemaker.ListInferenceRecommendationsJobStepsInput, arg2 func(*sagemaker.ListInferenceRecommendationsJobStepsOutput, 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, "ListInferenceRecommendationsJobStepsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListInferenceRecommendationsJobStepsPagesWithContext indicates an expected call of ListInferenceRecommendationsJobStepsPagesWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListInferenceRecommendationsJobStepsPagesWithContext(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, "ListInferenceRecommendationsJobStepsPagesWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListInferenceRecommendationsJobStepsPagesWithContext), varargs...)
}

// ListInferenceRecommendationsJobStepsRequest mocks base method.
func (m *MockSageMakerAPI) ListInferenceRecommendationsJobStepsRequest(arg0 *sagemaker.ListInferenceRecommendationsJobStepsInput) (*request.Request, *sagemaker.ListInferenceRecommendationsJobStepsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListInferenceRecommendationsJobStepsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.ListInferenceRecommendationsJobStepsOutput)
	return ret0, ret1
}

// ListInferenceRecommendationsJobStepsRequest indicates an expected call of ListInferenceRecommendationsJobStepsRequest.
func (mr *MockSageMakerAPIMockRecorder) ListInferenceRecommendationsJobStepsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListInferenceRecommendationsJobStepsRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).ListInferenceRecommendationsJobStepsRequest), arg0)
}

// ListInferenceRecommendationsJobStepsWithContext mocks base method.
func (m *MockSageMakerAPI) ListInferenceRecommendationsJobStepsWithContext(arg0 aws.Context, arg1 *sagemaker.ListInferenceRecommendationsJobStepsInput, arg2 ...request.Option) (*sagemaker.ListInferenceRecommendationsJobStepsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListInferenceRecommendationsJobStepsWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.ListInferenceRecommendationsJobStepsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListInferenceRecommendationsJobStepsWithContext indicates an expected call of ListInferenceRecommendationsJobStepsWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListInferenceRecommendationsJobStepsWithContext(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, "ListInferenceRecommendationsJobStepsWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListInferenceRecommendationsJobStepsWithContext), varargs...)
}

// ListInferenceRecommendationsJobs mocks base method.
func (m *MockSageMakerAPI) ListInferenceRecommendationsJobs(arg0 *sagemaker.ListInferenceRecommendationsJobsInput) (*sagemaker.ListInferenceRecommendationsJobsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListInferenceRecommendationsJobs", arg0)
	ret0, _ := ret[0].(*sagemaker.ListInferenceRecommendationsJobsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListInferenceRecommendationsJobs indicates an expected call of ListInferenceRecommendationsJobs.
func (mr *MockSageMakerAPIMockRecorder) ListInferenceRecommendationsJobs(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListInferenceRecommendationsJobs", reflect.TypeOf((*MockSageMakerAPI)(nil).ListInferenceRecommendationsJobs), arg0)
}

// ListInferenceRecommendationsJobsPages mocks base method.
func (m *MockSageMakerAPI) ListInferenceRecommendationsJobsPages(arg0 *sagemaker.ListInferenceRecommendationsJobsInput, arg1 func(*sagemaker.ListInferenceRecommendationsJobsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListInferenceRecommendationsJobsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListInferenceRecommendationsJobsPages indicates an expected call of ListInferenceRecommendationsJobsPages.
func (mr *MockSageMakerAPIMockRecorder) ListInferenceRecommendationsJobsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListInferenceRecommendationsJobsPages", reflect.TypeOf((*MockSageMakerAPI)(nil).ListInferenceRecommendationsJobsPages), arg0, arg1)
}

// ListInferenceRecommendationsJobsPagesWithContext mocks base method.
func (m *MockSageMakerAPI) ListInferenceRecommendationsJobsPagesWithContext(arg0 aws.Context, arg1 *sagemaker.ListInferenceRecommendationsJobsInput, arg2 func(*sagemaker.ListInferenceRecommendationsJobsOutput, 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, "ListInferenceRecommendationsJobsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListInferenceRecommendationsJobsPagesWithContext indicates an expected call of ListInferenceRecommendationsJobsPagesWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListInferenceRecommendationsJobsPagesWithContext(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, "ListInferenceRecommendationsJobsPagesWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListInferenceRecommendationsJobsPagesWithContext), varargs...)
}

// ListInferenceRecommendationsJobsRequest mocks base method.
func (m *MockSageMakerAPI) ListInferenceRecommendationsJobsRequest(arg0 *sagemaker.ListInferenceRecommendationsJobsInput) (*request.Request, *sagemaker.ListInferenceRecommendationsJobsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListInferenceRecommendationsJobsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.ListInferenceRecommendationsJobsOutput)
	return ret0, ret1
}

// ListInferenceRecommendationsJobsRequest indicates an expected call of ListInferenceRecommendationsJobsRequest.
func (mr *MockSageMakerAPIMockRecorder) ListInferenceRecommendationsJobsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListInferenceRecommendationsJobsRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).ListInferenceRecommendationsJobsRequest), arg0)
}

// ListInferenceRecommendationsJobsWithContext mocks base method.
func (m *MockSageMakerAPI) ListInferenceRecommendationsJobsWithContext(arg0 aws.Context, arg1 *sagemaker.ListInferenceRecommendationsJobsInput, arg2 ...request.Option) (*sagemaker.ListInferenceRecommendationsJobsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListInferenceRecommendationsJobsWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.ListInferenceRecommendationsJobsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListInferenceRecommendationsJobsWithContext indicates an expected call of ListInferenceRecommendationsJobsWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListInferenceRecommendationsJobsWithContext(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, "ListInferenceRecommendationsJobsWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListInferenceRecommendationsJobsWithContext), varargs...)
}

// ListLabelingJobs mocks base method.
func (m *MockSageMakerAPI) ListLabelingJobs(arg0 *sagemaker.ListLabelingJobsInput) (*sagemaker.ListLabelingJobsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListLabelingJobs", arg0)
	ret0, _ := ret[0].(*sagemaker.ListLabelingJobsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListLabelingJobs indicates an expected call of ListLabelingJobs.
func (mr *MockSageMakerAPIMockRecorder) ListLabelingJobs(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListLabelingJobs", reflect.TypeOf((*MockSageMakerAPI)(nil).ListLabelingJobs), arg0)
}

// ListLabelingJobsForWorkteam mocks base method.
func (m *MockSageMakerAPI) ListLabelingJobsForWorkteam(arg0 *sagemaker.ListLabelingJobsForWorkteamInput) (*sagemaker.ListLabelingJobsForWorkteamOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListLabelingJobsForWorkteam", arg0)
	ret0, _ := ret[0].(*sagemaker.ListLabelingJobsForWorkteamOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListLabelingJobsForWorkteam indicates an expected call of ListLabelingJobsForWorkteam.
func (mr *MockSageMakerAPIMockRecorder) ListLabelingJobsForWorkteam(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListLabelingJobsForWorkteam", reflect.TypeOf((*MockSageMakerAPI)(nil).ListLabelingJobsForWorkteam), arg0)
}

// ListLabelingJobsForWorkteamPages mocks base method.
func (m *MockSageMakerAPI) ListLabelingJobsForWorkteamPages(arg0 *sagemaker.ListLabelingJobsForWorkteamInput, arg1 func(*sagemaker.ListLabelingJobsForWorkteamOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListLabelingJobsForWorkteamPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListLabelingJobsForWorkteamPages indicates an expected call of ListLabelingJobsForWorkteamPages.
func (mr *MockSageMakerAPIMockRecorder) ListLabelingJobsForWorkteamPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListLabelingJobsForWorkteamPages", reflect.TypeOf((*MockSageMakerAPI)(nil).ListLabelingJobsForWorkteamPages), arg0, arg1)
}

// ListLabelingJobsForWorkteamPagesWithContext mocks base method.
func (m *MockSageMakerAPI) ListLabelingJobsForWorkteamPagesWithContext(arg0 aws.Context, arg1 *sagemaker.ListLabelingJobsForWorkteamInput, arg2 func(*sagemaker.ListLabelingJobsForWorkteamOutput, 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, "ListLabelingJobsForWorkteamPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListLabelingJobsForWorkteamPagesWithContext indicates an expected call of ListLabelingJobsForWorkteamPagesWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListLabelingJobsForWorkteamPagesWithContext(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, "ListLabelingJobsForWorkteamPagesWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListLabelingJobsForWorkteamPagesWithContext), varargs...)
}

// ListLabelingJobsForWorkteamRequest mocks base method.
func (m *MockSageMakerAPI) ListLabelingJobsForWorkteamRequest(arg0 *sagemaker.ListLabelingJobsForWorkteamInput) (*request.Request, *sagemaker.ListLabelingJobsForWorkteamOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListLabelingJobsForWorkteamRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.ListLabelingJobsForWorkteamOutput)
	return ret0, ret1
}

// ListLabelingJobsForWorkteamRequest indicates an expected call of ListLabelingJobsForWorkteamRequest.
func (mr *MockSageMakerAPIMockRecorder) ListLabelingJobsForWorkteamRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListLabelingJobsForWorkteamRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).ListLabelingJobsForWorkteamRequest), arg0)
}

// ListLabelingJobsForWorkteamWithContext mocks base method.
func (m *MockSageMakerAPI) ListLabelingJobsForWorkteamWithContext(arg0 aws.Context, arg1 *sagemaker.ListLabelingJobsForWorkteamInput, arg2 ...request.Option) (*sagemaker.ListLabelingJobsForWorkteamOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListLabelingJobsForWorkteamWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.ListLabelingJobsForWorkteamOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListLabelingJobsForWorkteamWithContext indicates an expected call of ListLabelingJobsForWorkteamWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListLabelingJobsForWorkteamWithContext(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, "ListLabelingJobsForWorkteamWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListLabelingJobsForWorkteamWithContext), varargs...)
}

// ListLabelingJobsPages mocks base method.
func (m *MockSageMakerAPI) ListLabelingJobsPages(arg0 *sagemaker.ListLabelingJobsInput, arg1 func(*sagemaker.ListLabelingJobsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListLabelingJobsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListLabelingJobsPages indicates an expected call of ListLabelingJobsPages.
func (mr *MockSageMakerAPIMockRecorder) ListLabelingJobsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListLabelingJobsPages", reflect.TypeOf((*MockSageMakerAPI)(nil).ListLabelingJobsPages), arg0, arg1)
}

// ListLabelingJobsPagesWithContext mocks base method.
func (m *MockSageMakerAPI) ListLabelingJobsPagesWithContext(arg0 aws.Context, arg1 *sagemaker.ListLabelingJobsInput, arg2 func(*sagemaker.ListLabelingJobsOutput, 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, "ListLabelingJobsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListLabelingJobsPagesWithContext indicates an expected call of ListLabelingJobsPagesWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListLabelingJobsPagesWithContext(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, "ListLabelingJobsPagesWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListLabelingJobsPagesWithContext), varargs...)
}

// ListLabelingJobsRequest mocks base method.
func (m *MockSageMakerAPI) ListLabelingJobsRequest(arg0 *sagemaker.ListLabelingJobsInput) (*request.Request, *sagemaker.ListLabelingJobsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListLabelingJobsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.ListLabelingJobsOutput)
	return ret0, ret1
}

// ListLabelingJobsRequest indicates an expected call of ListLabelingJobsRequest.
func (mr *MockSageMakerAPIMockRecorder) ListLabelingJobsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListLabelingJobsRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).ListLabelingJobsRequest), arg0)
}

// ListLabelingJobsWithContext mocks base method.
func (m *MockSageMakerAPI) ListLabelingJobsWithContext(arg0 aws.Context, arg1 *sagemaker.ListLabelingJobsInput, arg2 ...request.Option) (*sagemaker.ListLabelingJobsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListLabelingJobsWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.ListLabelingJobsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListLabelingJobsWithContext indicates an expected call of ListLabelingJobsWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListLabelingJobsWithContext(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, "ListLabelingJobsWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListLabelingJobsWithContext), varargs...)
}

// ListLineageGroups mocks base method.
func (m *MockSageMakerAPI) ListLineageGroups(arg0 *sagemaker.ListLineageGroupsInput) (*sagemaker.ListLineageGroupsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListLineageGroups", arg0)
	ret0, _ := ret[0].(*sagemaker.ListLineageGroupsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListLineageGroups indicates an expected call of ListLineageGroups.
func (mr *MockSageMakerAPIMockRecorder) ListLineageGroups(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListLineageGroups", reflect.TypeOf((*MockSageMakerAPI)(nil).ListLineageGroups), arg0)
}

// ListLineageGroupsPages mocks base method.
func (m *MockSageMakerAPI) ListLineageGroupsPages(arg0 *sagemaker.ListLineageGroupsInput, arg1 func(*sagemaker.ListLineageGroupsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListLineageGroupsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListLineageGroupsPages indicates an expected call of ListLineageGroupsPages.
func (mr *MockSageMakerAPIMockRecorder) ListLineageGroupsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListLineageGroupsPages", reflect.TypeOf((*MockSageMakerAPI)(nil).ListLineageGroupsPages), arg0, arg1)
}

// ListLineageGroupsPagesWithContext mocks base method.
func (m *MockSageMakerAPI) ListLineageGroupsPagesWithContext(arg0 aws.Context, arg1 *sagemaker.ListLineageGroupsInput, arg2 func(*sagemaker.ListLineageGroupsOutput, 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, "ListLineageGroupsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListLineageGroupsPagesWithContext indicates an expected call of ListLineageGroupsPagesWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListLineageGroupsPagesWithContext(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, "ListLineageGroupsPagesWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListLineageGroupsPagesWithContext), varargs...)
}

// ListLineageGroupsRequest mocks base method.
func (m *MockSageMakerAPI) ListLineageGroupsRequest(arg0 *sagemaker.ListLineageGroupsInput) (*request.Request, *sagemaker.ListLineageGroupsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListLineageGroupsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.ListLineageGroupsOutput)
	return ret0, ret1
}

// ListLineageGroupsRequest indicates an expected call of ListLineageGroupsRequest.
func (mr *MockSageMakerAPIMockRecorder) ListLineageGroupsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListLineageGroupsRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).ListLineageGroupsRequest), arg0)
}

// ListLineageGroupsWithContext mocks base method.
func (m *MockSageMakerAPI) ListLineageGroupsWithContext(arg0 aws.Context, arg1 *sagemaker.ListLineageGroupsInput, arg2 ...request.Option) (*sagemaker.ListLineageGroupsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListLineageGroupsWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.ListLineageGroupsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListLineageGroupsWithContext indicates an expected call of ListLineageGroupsWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListLineageGroupsWithContext(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, "ListLineageGroupsWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListLineageGroupsWithContext), varargs...)
}

// ListMlflowTrackingServers mocks base method.
func (m *MockSageMakerAPI) ListMlflowTrackingServers(arg0 *sagemaker.ListMlflowTrackingServersInput) (*sagemaker.ListMlflowTrackingServersOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListMlflowTrackingServers", arg0)
	ret0, _ := ret[0].(*sagemaker.ListMlflowTrackingServersOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListMlflowTrackingServers indicates an expected call of ListMlflowTrackingServers.
func (mr *MockSageMakerAPIMockRecorder) ListMlflowTrackingServers(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListMlflowTrackingServers", reflect.TypeOf((*MockSageMakerAPI)(nil).ListMlflowTrackingServers), arg0)
}

// ListMlflowTrackingServersPages mocks base method.
func (m *MockSageMakerAPI) ListMlflowTrackingServersPages(arg0 *sagemaker.ListMlflowTrackingServersInput, arg1 func(*sagemaker.ListMlflowTrackingServersOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListMlflowTrackingServersPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListMlflowTrackingServersPages indicates an expected call of ListMlflowTrackingServersPages.
func (mr *MockSageMakerAPIMockRecorder) ListMlflowTrackingServersPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListMlflowTrackingServersPages", reflect.TypeOf((*MockSageMakerAPI)(nil).ListMlflowTrackingServersPages), arg0, arg1)
}

// ListMlflowTrackingServersPagesWithContext mocks base method.
func (m *MockSageMakerAPI) ListMlflowTrackingServersPagesWithContext(arg0 aws.Context, arg1 *sagemaker.ListMlflowTrackingServersInput, arg2 func(*sagemaker.ListMlflowTrackingServersOutput, 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, "ListMlflowTrackingServersPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListMlflowTrackingServersPagesWithContext indicates an expected call of ListMlflowTrackingServersPagesWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListMlflowTrackingServersPagesWithContext(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, "ListMlflowTrackingServersPagesWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListMlflowTrackingServersPagesWithContext), varargs...)
}

// ListMlflowTrackingServersRequest mocks base method.
func (m *MockSageMakerAPI) ListMlflowTrackingServersRequest(arg0 *sagemaker.ListMlflowTrackingServersInput) (*request.Request, *sagemaker.ListMlflowTrackingServersOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListMlflowTrackingServersRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.ListMlflowTrackingServersOutput)
	return ret0, ret1
}

// ListMlflowTrackingServersRequest indicates an expected call of ListMlflowTrackingServersRequest.
func (mr *MockSageMakerAPIMockRecorder) ListMlflowTrackingServersRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListMlflowTrackingServersRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).ListMlflowTrackingServersRequest), arg0)
}

// ListMlflowTrackingServersWithContext mocks base method.
func (m *MockSageMakerAPI) ListMlflowTrackingServersWithContext(arg0 aws.Context, arg1 *sagemaker.ListMlflowTrackingServersInput, arg2 ...request.Option) (*sagemaker.ListMlflowTrackingServersOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListMlflowTrackingServersWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.ListMlflowTrackingServersOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListMlflowTrackingServersWithContext indicates an expected call of ListMlflowTrackingServersWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListMlflowTrackingServersWithContext(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, "ListMlflowTrackingServersWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListMlflowTrackingServersWithContext), varargs...)
}

// ListModelBiasJobDefinitions mocks base method.
func (m *MockSageMakerAPI) ListModelBiasJobDefinitions(arg0 *sagemaker.ListModelBiasJobDefinitionsInput) (*sagemaker.ListModelBiasJobDefinitionsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListModelBiasJobDefinitions", arg0)
	ret0, _ := ret[0].(*sagemaker.ListModelBiasJobDefinitionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListModelBiasJobDefinitions indicates an expected call of ListModelBiasJobDefinitions.
func (mr *MockSageMakerAPIMockRecorder) ListModelBiasJobDefinitions(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListModelBiasJobDefinitions", reflect.TypeOf((*MockSageMakerAPI)(nil).ListModelBiasJobDefinitions), arg0)
}

// ListModelBiasJobDefinitionsPages mocks base method.
func (m *MockSageMakerAPI) ListModelBiasJobDefinitionsPages(arg0 *sagemaker.ListModelBiasJobDefinitionsInput, arg1 func(*sagemaker.ListModelBiasJobDefinitionsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListModelBiasJobDefinitionsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListModelBiasJobDefinitionsPages indicates an expected call of ListModelBiasJobDefinitionsPages.
func (mr *MockSageMakerAPIMockRecorder) ListModelBiasJobDefinitionsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListModelBiasJobDefinitionsPages", reflect.TypeOf((*MockSageMakerAPI)(nil).ListModelBiasJobDefinitionsPages), arg0, arg1)
}

// ListModelBiasJobDefinitionsPagesWithContext mocks base method.
func (m *MockSageMakerAPI) ListModelBiasJobDefinitionsPagesWithContext(arg0 aws.Context, arg1 *sagemaker.ListModelBiasJobDefinitionsInput, arg2 func(*sagemaker.ListModelBiasJobDefinitionsOutput, 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, "ListModelBiasJobDefinitionsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListModelBiasJobDefinitionsPagesWithContext indicates an expected call of ListModelBiasJobDefinitionsPagesWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListModelBiasJobDefinitionsPagesWithContext(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, "ListModelBiasJobDefinitionsPagesWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListModelBiasJobDefinitionsPagesWithContext), varargs...)
}

// ListModelBiasJobDefinitionsRequest mocks base method.
func (m *MockSageMakerAPI) ListModelBiasJobDefinitionsRequest(arg0 *sagemaker.ListModelBiasJobDefinitionsInput) (*request.Request, *sagemaker.ListModelBiasJobDefinitionsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListModelBiasJobDefinitionsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.ListModelBiasJobDefinitionsOutput)
	return ret0, ret1
}

// ListModelBiasJobDefinitionsRequest indicates an expected call of ListModelBiasJobDefinitionsRequest.
func (mr *MockSageMakerAPIMockRecorder) ListModelBiasJobDefinitionsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListModelBiasJobDefinitionsRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).ListModelBiasJobDefinitionsRequest), arg0)
}

// ListModelBiasJobDefinitionsWithContext mocks base method.
func (m *MockSageMakerAPI) ListModelBiasJobDefinitionsWithContext(arg0 aws.Context, arg1 *sagemaker.ListModelBiasJobDefinitionsInput, arg2 ...request.Option) (*sagemaker.ListModelBiasJobDefinitionsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListModelBiasJobDefinitionsWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.ListModelBiasJobDefinitionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListModelBiasJobDefinitionsWithContext indicates an expected call of ListModelBiasJobDefinitionsWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListModelBiasJobDefinitionsWithContext(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, "ListModelBiasJobDefinitionsWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListModelBiasJobDefinitionsWithContext), varargs...)
}

// ListModelCardExportJobs mocks base method.
func (m *MockSageMakerAPI) ListModelCardExportJobs(arg0 *sagemaker.ListModelCardExportJobsInput) (*sagemaker.ListModelCardExportJobsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListModelCardExportJobs", arg0)
	ret0, _ := ret[0].(*sagemaker.ListModelCardExportJobsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListModelCardExportJobs indicates an expected call of ListModelCardExportJobs.
func (mr *MockSageMakerAPIMockRecorder) ListModelCardExportJobs(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListModelCardExportJobs", reflect.TypeOf((*MockSageMakerAPI)(nil).ListModelCardExportJobs), arg0)
}

// ListModelCardExportJobsPages mocks base method.
func (m *MockSageMakerAPI) ListModelCardExportJobsPages(arg0 *sagemaker.ListModelCardExportJobsInput, arg1 func(*sagemaker.ListModelCardExportJobsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListModelCardExportJobsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListModelCardExportJobsPages indicates an expected call of ListModelCardExportJobsPages.
func (mr *MockSageMakerAPIMockRecorder) ListModelCardExportJobsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListModelCardExportJobsPages", reflect.TypeOf((*MockSageMakerAPI)(nil).ListModelCardExportJobsPages), arg0, arg1)
}

// ListModelCardExportJobsPagesWithContext mocks base method.
func (m *MockSageMakerAPI) ListModelCardExportJobsPagesWithContext(arg0 aws.Context, arg1 *sagemaker.ListModelCardExportJobsInput, arg2 func(*sagemaker.ListModelCardExportJobsOutput, 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, "ListModelCardExportJobsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListModelCardExportJobsPagesWithContext indicates an expected call of ListModelCardExportJobsPagesWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListModelCardExportJobsPagesWithContext(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, "ListModelCardExportJobsPagesWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListModelCardExportJobsPagesWithContext), varargs...)
}

// ListModelCardExportJobsRequest mocks base method.
func (m *MockSageMakerAPI) ListModelCardExportJobsRequest(arg0 *sagemaker.ListModelCardExportJobsInput) (*request.Request, *sagemaker.ListModelCardExportJobsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListModelCardExportJobsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.ListModelCardExportJobsOutput)
	return ret0, ret1
}

// ListModelCardExportJobsRequest indicates an expected call of ListModelCardExportJobsRequest.
func (mr *MockSageMakerAPIMockRecorder) ListModelCardExportJobsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListModelCardExportJobsRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).ListModelCardExportJobsRequest), arg0)
}

// ListModelCardExportJobsWithContext mocks base method.
func (m *MockSageMakerAPI) ListModelCardExportJobsWithContext(arg0 aws.Context, arg1 *sagemaker.ListModelCardExportJobsInput, arg2 ...request.Option) (*sagemaker.ListModelCardExportJobsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListModelCardExportJobsWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.ListModelCardExportJobsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListModelCardExportJobsWithContext indicates an expected call of ListModelCardExportJobsWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListModelCardExportJobsWithContext(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, "ListModelCardExportJobsWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListModelCardExportJobsWithContext), varargs...)
}

// ListModelCardVersions mocks base method.
func (m *MockSageMakerAPI) ListModelCardVersions(arg0 *sagemaker.ListModelCardVersionsInput) (*sagemaker.ListModelCardVersionsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListModelCardVersions", arg0)
	ret0, _ := ret[0].(*sagemaker.ListModelCardVersionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListModelCardVersions indicates an expected call of ListModelCardVersions.
func (mr *MockSageMakerAPIMockRecorder) ListModelCardVersions(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListModelCardVersions", reflect.TypeOf((*MockSageMakerAPI)(nil).ListModelCardVersions), arg0)
}

// ListModelCardVersionsPages mocks base method.
func (m *MockSageMakerAPI) ListModelCardVersionsPages(arg0 *sagemaker.ListModelCardVersionsInput, arg1 func(*sagemaker.ListModelCardVersionsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListModelCardVersionsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListModelCardVersionsPages indicates an expected call of ListModelCardVersionsPages.
func (mr *MockSageMakerAPIMockRecorder) ListModelCardVersionsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListModelCardVersionsPages", reflect.TypeOf((*MockSageMakerAPI)(nil).ListModelCardVersionsPages), arg0, arg1)
}

// ListModelCardVersionsPagesWithContext mocks base method.
func (m *MockSageMakerAPI) ListModelCardVersionsPagesWithContext(arg0 aws.Context, arg1 *sagemaker.ListModelCardVersionsInput, arg2 func(*sagemaker.ListModelCardVersionsOutput, 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, "ListModelCardVersionsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListModelCardVersionsPagesWithContext indicates an expected call of ListModelCardVersionsPagesWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListModelCardVersionsPagesWithContext(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, "ListModelCardVersionsPagesWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListModelCardVersionsPagesWithContext), varargs...)
}

// ListModelCardVersionsRequest mocks base method.
func (m *MockSageMakerAPI) ListModelCardVersionsRequest(arg0 *sagemaker.ListModelCardVersionsInput) (*request.Request, *sagemaker.ListModelCardVersionsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListModelCardVersionsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.ListModelCardVersionsOutput)
	return ret0, ret1
}

// ListModelCardVersionsRequest indicates an expected call of ListModelCardVersionsRequest.
func (mr *MockSageMakerAPIMockRecorder) ListModelCardVersionsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListModelCardVersionsRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).ListModelCardVersionsRequest), arg0)
}

// ListModelCardVersionsWithContext mocks base method.
func (m *MockSageMakerAPI) ListModelCardVersionsWithContext(arg0 aws.Context, arg1 *sagemaker.ListModelCardVersionsInput, arg2 ...request.Option) (*sagemaker.ListModelCardVersionsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListModelCardVersionsWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.ListModelCardVersionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListModelCardVersionsWithContext indicates an expected call of ListModelCardVersionsWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListModelCardVersionsWithContext(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, "ListModelCardVersionsWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListModelCardVersionsWithContext), varargs...)
}

// ListModelCards mocks base method.
func (m *MockSageMakerAPI) ListModelCards(arg0 *sagemaker.ListModelCardsInput) (*sagemaker.ListModelCardsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListModelCards", arg0)
	ret0, _ := ret[0].(*sagemaker.ListModelCardsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListModelCards indicates an expected call of ListModelCards.
func (mr *MockSageMakerAPIMockRecorder) ListModelCards(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListModelCards", reflect.TypeOf((*MockSageMakerAPI)(nil).ListModelCards), arg0)
}

// ListModelCardsPages mocks base method.
func (m *MockSageMakerAPI) ListModelCardsPages(arg0 *sagemaker.ListModelCardsInput, arg1 func(*sagemaker.ListModelCardsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListModelCardsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListModelCardsPages indicates an expected call of ListModelCardsPages.
func (mr *MockSageMakerAPIMockRecorder) ListModelCardsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListModelCardsPages", reflect.TypeOf((*MockSageMakerAPI)(nil).ListModelCardsPages), arg0, arg1)
}

// ListModelCardsPagesWithContext mocks base method.
func (m *MockSageMakerAPI) ListModelCardsPagesWithContext(arg0 aws.Context, arg1 *sagemaker.ListModelCardsInput, arg2 func(*sagemaker.ListModelCardsOutput, 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, "ListModelCardsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListModelCardsPagesWithContext indicates an expected call of ListModelCardsPagesWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListModelCardsPagesWithContext(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, "ListModelCardsPagesWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListModelCardsPagesWithContext), varargs...)
}

// ListModelCardsRequest mocks base method.
func (m *MockSageMakerAPI) ListModelCardsRequest(arg0 *sagemaker.ListModelCardsInput) (*request.Request, *sagemaker.ListModelCardsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListModelCardsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.ListModelCardsOutput)
	return ret0, ret1
}

// ListModelCardsRequest indicates an expected call of ListModelCardsRequest.
func (mr *MockSageMakerAPIMockRecorder) ListModelCardsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListModelCardsRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).ListModelCardsRequest), arg0)
}

// ListModelCardsWithContext mocks base method.
func (m *MockSageMakerAPI) ListModelCardsWithContext(arg0 aws.Context, arg1 *sagemaker.ListModelCardsInput, arg2 ...request.Option) (*sagemaker.ListModelCardsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListModelCardsWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.ListModelCardsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListModelCardsWithContext indicates an expected call of ListModelCardsWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListModelCardsWithContext(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, "ListModelCardsWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListModelCardsWithContext), varargs...)
}

// ListModelExplainabilityJobDefinitions mocks base method.
func (m *MockSageMakerAPI) ListModelExplainabilityJobDefinitions(arg0 *sagemaker.ListModelExplainabilityJobDefinitionsInput) (*sagemaker.ListModelExplainabilityJobDefinitionsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListModelExplainabilityJobDefinitions", arg0)
	ret0, _ := ret[0].(*sagemaker.ListModelExplainabilityJobDefinitionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListModelExplainabilityJobDefinitions indicates an expected call of ListModelExplainabilityJobDefinitions.
func (mr *MockSageMakerAPIMockRecorder) ListModelExplainabilityJobDefinitions(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListModelExplainabilityJobDefinitions", reflect.TypeOf((*MockSageMakerAPI)(nil).ListModelExplainabilityJobDefinitions), arg0)
}

// ListModelExplainabilityJobDefinitionsPages mocks base method.
func (m *MockSageMakerAPI) ListModelExplainabilityJobDefinitionsPages(arg0 *sagemaker.ListModelExplainabilityJobDefinitionsInput, arg1 func(*sagemaker.ListModelExplainabilityJobDefinitionsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListModelExplainabilityJobDefinitionsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListModelExplainabilityJobDefinitionsPages indicates an expected call of ListModelExplainabilityJobDefinitionsPages.
func (mr *MockSageMakerAPIMockRecorder) ListModelExplainabilityJobDefinitionsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListModelExplainabilityJobDefinitionsPages", reflect.TypeOf((*MockSageMakerAPI)(nil).ListModelExplainabilityJobDefinitionsPages), arg0, arg1)
}

// ListModelExplainabilityJobDefinitionsPagesWithContext mocks base method.
func (m *MockSageMakerAPI) ListModelExplainabilityJobDefinitionsPagesWithContext(arg0 aws.Context, arg1 *sagemaker.ListModelExplainabilityJobDefinitionsInput, arg2 func(*sagemaker.ListModelExplainabilityJobDefinitionsOutput, 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, "ListModelExplainabilityJobDefinitionsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListModelExplainabilityJobDefinitionsPagesWithContext indicates an expected call of ListModelExplainabilityJobDefinitionsPagesWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListModelExplainabilityJobDefinitionsPagesWithContext(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, "ListModelExplainabilityJobDefinitionsPagesWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListModelExplainabilityJobDefinitionsPagesWithContext), varargs...)
}

// ListModelExplainabilityJobDefinitionsRequest mocks base method.
func (m *MockSageMakerAPI) ListModelExplainabilityJobDefinitionsRequest(arg0 *sagemaker.ListModelExplainabilityJobDefinitionsInput) (*request.Request, *sagemaker.ListModelExplainabilityJobDefinitionsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListModelExplainabilityJobDefinitionsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.ListModelExplainabilityJobDefinitionsOutput)
	return ret0, ret1
}

// ListModelExplainabilityJobDefinitionsRequest indicates an expected call of ListModelExplainabilityJobDefinitionsRequest.
func (mr *MockSageMakerAPIMockRecorder) ListModelExplainabilityJobDefinitionsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListModelExplainabilityJobDefinitionsRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).ListModelExplainabilityJobDefinitionsRequest), arg0)
}

// ListModelExplainabilityJobDefinitionsWithContext mocks base method.
func (m *MockSageMakerAPI) ListModelExplainabilityJobDefinitionsWithContext(arg0 aws.Context, arg1 *sagemaker.ListModelExplainabilityJobDefinitionsInput, arg2 ...request.Option) (*sagemaker.ListModelExplainabilityJobDefinitionsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListModelExplainabilityJobDefinitionsWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.ListModelExplainabilityJobDefinitionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListModelExplainabilityJobDefinitionsWithContext indicates an expected call of ListModelExplainabilityJobDefinitionsWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListModelExplainabilityJobDefinitionsWithContext(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, "ListModelExplainabilityJobDefinitionsWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListModelExplainabilityJobDefinitionsWithContext), varargs...)
}

// ListModelMetadata mocks base method.
func (m *MockSageMakerAPI) ListModelMetadata(arg0 *sagemaker.ListModelMetadataInput) (*sagemaker.ListModelMetadataOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListModelMetadata", arg0)
	ret0, _ := ret[0].(*sagemaker.ListModelMetadataOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListModelMetadata indicates an expected call of ListModelMetadata.
func (mr *MockSageMakerAPIMockRecorder) ListModelMetadata(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListModelMetadata", reflect.TypeOf((*MockSageMakerAPI)(nil).ListModelMetadata), arg0)
}

// ListModelMetadataPages mocks base method.
func (m *MockSageMakerAPI) ListModelMetadataPages(arg0 *sagemaker.ListModelMetadataInput, arg1 func(*sagemaker.ListModelMetadataOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListModelMetadataPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListModelMetadataPages indicates an expected call of ListModelMetadataPages.
func (mr *MockSageMakerAPIMockRecorder) ListModelMetadataPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListModelMetadataPages", reflect.TypeOf((*MockSageMakerAPI)(nil).ListModelMetadataPages), arg0, arg1)
}

// ListModelMetadataPagesWithContext mocks base method.
func (m *MockSageMakerAPI) ListModelMetadataPagesWithContext(arg0 aws.Context, arg1 *sagemaker.ListModelMetadataInput, arg2 func(*sagemaker.ListModelMetadataOutput, 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, "ListModelMetadataPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListModelMetadataPagesWithContext indicates an expected call of ListModelMetadataPagesWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListModelMetadataPagesWithContext(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, "ListModelMetadataPagesWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListModelMetadataPagesWithContext), varargs...)
}

// ListModelMetadataRequest mocks base method.
func (m *MockSageMakerAPI) ListModelMetadataRequest(arg0 *sagemaker.ListModelMetadataInput) (*request.Request, *sagemaker.ListModelMetadataOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListModelMetadataRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.ListModelMetadataOutput)
	return ret0, ret1
}

// ListModelMetadataRequest indicates an expected call of ListModelMetadataRequest.
func (mr *MockSageMakerAPIMockRecorder) ListModelMetadataRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListModelMetadataRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).ListModelMetadataRequest), arg0)
}

// ListModelMetadataWithContext mocks base method.
func (m *MockSageMakerAPI) ListModelMetadataWithContext(arg0 aws.Context, arg1 *sagemaker.ListModelMetadataInput, arg2 ...request.Option) (*sagemaker.ListModelMetadataOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListModelMetadataWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.ListModelMetadataOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListModelMetadataWithContext indicates an expected call of ListModelMetadataWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListModelMetadataWithContext(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, "ListModelMetadataWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListModelMetadataWithContext), varargs...)
}

// ListModelPackageGroups mocks base method.
func (m *MockSageMakerAPI) ListModelPackageGroups(arg0 *sagemaker.ListModelPackageGroupsInput) (*sagemaker.ListModelPackageGroupsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListModelPackageGroups", arg0)
	ret0, _ := ret[0].(*sagemaker.ListModelPackageGroupsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListModelPackageGroups indicates an expected call of ListModelPackageGroups.
func (mr *MockSageMakerAPIMockRecorder) ListModelPackageGroups(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListModelPackageGroups", reflect.TypeOf((*MockSageMakerAPI)(nil).ListModelPackageGroups), arg0)
}

// ListModelPackageGroupsPages mocks base method.
func (m *MockSageMakerAPI) ListModelPackageGroupsPages(arg0 *sagemaker.ListModelPackageGroupsInput, arg1 func(*sagemaker.ListModelPackageGroupsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListModelPackageGroupsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListModelPackageGroupsPages indicates an expected call of ListModelPackageGroupsPages.
func (mr *MockSageMakerAPIMockRecorder) ListModelPackageGroupsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListModelPackageGroupsPages", reflect.TypeOf((*MockSageMakerAPI)(nil).ListModelPackageGroupsPages), arg0, arg1)
}

// ListModelPackageGroupsPagesWithContext mocks base method.
func (m *MockSageMakerAPI) ListModelPackageGroupsPagesWithContext(arg0 aws.Context, arg1 *sagemaker.ListModelPackageGroupsInput, arg2 func(*sagemaker.ListModelPackageGroupsOutput, 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, "ListModelPackageGroupsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListModelPackageGroupsPagesWithContext indicates an expected call of ListModelPackageGroupsPagesWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListModelPackageGroupsPagesWithContext(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, "ListModelPackageGroupsPagesWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListModelPackageGroupsPagesWithContext), varargs...)
}

// ListModelPackageGroupsRequest mocks base method.
func (m *MockSageMakerAPI) ListModelPackageGroupsRequest(arg0 *sagemaker.ListModelPackageGroupsInput) (*request.Request, *sagemaker.ListModelPackageGroupsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListModelPackageGroupsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.ListModelPackageGroupsOutput)
	return ret0, ret1
}

// ListModelPackageGroupsRequest indicates an expected call of ListModelPackageGroupsRequest.
func (mr *MockSageMakerAPIMockRecorder) ListModelPackageGroupsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListModelPackageGroupsRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).ListModelPackageGroupsRequest), arg0)
}

// ListModelPackageGroupsWithContext mocks base method.
func (m *MockSageMakerAPI) ListModelPackageGroupsWithContext(arg0 aws.Context, arg1 *sagemaker.ListModelPackageGroupsInput, arg2 ...request.Option) (*sagemaker.ListModelPackageGroupsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListModelPackageGroupsWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.ListModelPackageGroupsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListModelPackageGroupsWithContext indicates an expected call of ListModelPackageGroupsWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListModelPackageGroupsWithContext(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, "ListModelPackageGroupsWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListModelPackageGroupsWithContext), varargs...)
}

// ListModelPackages mocks base method.
func (m *MockSageMakerAPI) ListModelPackages(arg0 *sagemaker.ListModelPackagesInput) (*sagemaker.ListModelPackagesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListModelPackages", arg0)
	ret0, _ := ret[0].(*sagemaker.ListModelPackagesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListModelPackages indicates an expected call of ListModelPackages.
func (mr *MockSageMakerAPIMockRecorder) ListModelPackages(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListModelPackages", reflect.TypeOf((*MockSageMakerAPI)(nil).ListModelPackages), arg0)
}

// ListModelPackagesPages mocks base method.
func (m *MockSageMakerAPI) ListModelPackagesPages(arg0 *sagemaker.ListModelPackagesInput, arg1 func(*sagemaker.ListModelPackagesOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListModelPackagesPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListModelPackagesPages indicates an expected call of ListModelPackagesPages.
func (mr *MockSageMakerAPIMockRecorder) ListModelPackagesPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListModelPackagesPages", reflect.TypeOf((*MockSageMakerAPI)(nil).ListModelPackagesPages), arg0, arg1)
}

// ListModelPackagesPagesWithContext mocks base method.
func (m *MockSageMakerAPI) ListModelPackagesPagesWithContext(arg0 aws.Context, arg1 *sagemaker.ListModelPackagesInput, arg2 func(*sagemaker.ListModelPackagesOutput, 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, "ListModelPackagesPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListModelPackagesPagesWithContext indicates an expected call of ListModelPackagesPagesWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListModelPackagesPagesWithContext(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, "ListModelPackagesPagesWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListModelPackagesPagesWithContext), varargs...)
}

// ListModelPackagesRequest mocks base method.
func (m *MockSageMakerAPI) ListModelPackagesRequest(arg0 *sagemaker.ListModelPackagesInput) (*request.Request, *sagemaker.ListModelPackagesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListModelPackagesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.ListModelPackagesOutput)
	return ret0, ret1
}

// ListModelPackagesRequest indicates an expected call of ListModelPackagesRequest.
func (mr *MockSageMakerAPIMockRecorder) ListModelPackagesRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListModelPackagesRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).ListModelPackagesRequest), arg0)
}

// ListModelPackagesWithContext mocks base method.
func (m *MockSageMakerAPI) ListModelPackagesWithContext(arg0 aws.Context, arg1 *sagemaker.ListModelPackagesInput, arg2 ...request.Option) (*sagemaker.ListModelPackagesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListModelPackagesWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.ListModelPackagesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListModelPackagesWithContext indicates an expected call of ListModelPackagesWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListModelPackagesWithContext(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, "ListModelPackagesWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListModelPackagesWithContext), varargs...)
}

// ListModelQualityJobDefinitions mocks base method.
func (m *MockSageMakerAPI) ListModelQualityJobDefinitions(arg0 *sagemaker.ListModelQualityJobDefinitionsInput) (*sagemaker.ListModelQualityJobDefinitionsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListModelQualityJobDefinitions", arg0)
	ret0, _ := ret[0].(*sagemaker.ListModelQualityJobDefinitionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListModelQualityJobDefinitions indicates an expected call of ListModelQualityJobDefinitions.
func (mr *MockSageMakerAPIMockRecorder) ListModelQualityJobDefinitions(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListModelQualityJobDefinitions", reflect.TypeOf((*MockSageMakerAPI)(nil).ListModelQualityJobDefinitions), arg0)
}

// ListModelQualityJobDefinitionsPages mocks base method.
func (m *MockSageMakerAPI) ListModelQualityJobDefinitionsPages(arg0 *sagemaker.ListModelQualityJobDefinitionsInput, arg1 func(*sagemaker.ListModelQualityJobDefinitionsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListModelQualityJobDefinitionsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListModelQualityJobDefinitionsPages indicates an expected call of ListModelQualityJobDefinitionsPages.
func (mr *MockSageMakerAPIMockRecorder) ListModelQualityJobDefinitionsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListModelQualityJobDefinitionsPages", reflect.TypeOf((*MockSageMakerAPI)(nil).ListModelQualityJobDefinitionsPages), arg0, arg1)
}

// ListModelQualityJobDefinitionsPagesWithContext mocks base method.
func (m *MockSageMakerAPI) ListModelQualityJobDefinitionsPagesWithContext(arg0 aws.Context, arg1 *sagemaker.ListModelQualityJobDefinitionsInput, arg2 func(*sagemaker.ListModelQualityJobDefinitionsOutput, 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, "ListModelQualityJobDefinitionsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListModelQualityJobDefinitionsPagesWithContext indicates an expected call of ListModelQualityJobDefinitionsPagesWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListModelQualityJobDefinitionsPagesWithContext(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, "ListModelQualityJobDefinitionsPagesWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListModelQualityJobDefinitionsPagesWithContext), varargs...)
}

// ListModelQualityJobDefinitionsRequest mocks base method.
func (m *MockSageMakerAPI) ListModelQualityJobDefinitionsRequest(arg0 *sagemaker.ListModelQualityJobDefinitionsInput) (*request.Request, *sagemaker.ListModelQualityJobDefinitionsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListModelQualityJobDefinitionsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.ListModelQualityJobDefinitionsOutput)
	return ret0, ret1
}

// ListModelQualityJobDefinitionsRequest indicates an expected call of ListModelQualityJobDefinitionsRequest.
func (mr *MockSageMakerAPIMockRecorder) ListModelQualityJobDefinitionsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListModelQualityJobDefinitionsRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).ListModelQualityJobDefinitionsRequest), arg0)
}

// ListModelQualityJobDefinitionsWithContext mocks base method.
func (m *MockSageMakerAPI) ListModelQualityJobDefinitionsWithContext(arg0 aws.Context, arg1 *sagemaker.ListModelQualityJobDefinitionsInput, arg2 ...request.Option) (*sagemaker.ListModelQualityJobDefinitionsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListModelQualityJobDefinitionsWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.ListModelQualityJobDefinitionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListModelQualityJobDefinitionsWithContext indicates an expected call of ListModelQualityJobDefinitionsWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListModelQualityJobDefinitionsWithContext(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, "ListModelQualityJobDefinitionsWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListModelQualityJobDefinitionsWithContext), varargs...)
}

// ListModels mocks base method.
func (m *MockSageMakerAPI) ListModels(arg0 *sagemaker.ListModelsInput) (*sagemaker.ListModelsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListModels", arg0)
	ret0, _ := ret[0].(*sagemaker.ListModelsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListModels indicates an expected call of ListModels.
func (mr *MockSageMakerAPIMockRecorder) ListModels(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListModels", reflect.TypeOf((*MockSageMakerAPI)(nil).ListModels), arg0)
}

// ListModelsPages mocks base method.
func (m *MockSageMakerAPI) ListModelsPages(arg0 *sagemaker.ListModelsInput, arg1 func(*sagemaker.ListModelsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListModelsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListModelsPages indicates an expected call of ListModelsPages.
func (mr *MockSageMakerAPIMockRecorder) ListModelsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListModelsPages", reflect.TypeOf((*MockSageMakerAPI)(nil).ListModelsPages), arg0, arg1)
}

// ListModelsPagesWithContext mocks base method.
func (m *MockSageMakerAPI) ListModelsPagesWithContext(arg0 aws.Context, arg1 *sagemaker.ListModelsInput, arg2 func(*sagemaker.ListModelsOutput, 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, "ListModelsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListModelsPagesWithContext indicates an expected call of ListModelsPagesWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListModelsPagesWithContext(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, "ListModelsPagesWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListModelsPagesWithContext), varargs...)
}

// ListModelsRequest mocks base method.
func (m *MockSageMakerAPI) ListModelsRequest(arg0 *sagemaker.ListModelsInput) (*request.Request, *sagemaker.ListModelsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListModelsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.ListModelsOutput)
	return ret0, ret1
}

// ListModelsRequest indicates an expected call of ListModelsRequest.
func (mr *MockSageMakerAPIMockRecorder) ListModelsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListModelsRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).ListModelsRequest), arg0)
}

// ListModelsWithContext mocks base method.
func (m *MockSageMakerAPI) ListModelsWithContext(arg0 aws.Context, arg1 *sagemaker.ListModelsInput, arg2 ...request.Option) (*sagemaker.ListModelsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListModelsWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.ListModelsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListModelsWithContext indicates an expected call of ListModelsWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListModelsWithContext(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, "ListModelsWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListModelsWithContext), varargs...)
}

// ListMonitoringAlertHistory mocks base method.
func (m *MockSageMakerAPI) ListMonitoringAlertHistory(arg0 *sagemaker.ListMonitoringAlertHistoryInput) (*sagemaker.ListMonitoringAlertHistoryOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListMonitoringAlertHistory", arg0)
	ret0, _ := ret[0].(*sagemaker.ListMonitoringAlertHistoryOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListMonitoringAlertHistory indicates an expected call of ListMonitoringAlertHistory.
func (mr *MockSageMakerAPIMockRecorder) ListMonitoringAlertHistory(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListMonitoringAlertHistory", reflect.TypeOf((*MockSageMakerAPI)(nil).ListMonitoringAlertHistory), arg0)
}

// ListMonitoringAlertHistoryPages mocks base method.
func (m *MockSageMakerAPI) ListMonitoringAlertHistoryPages(arg0 *sagemaker.ListMonitoringAlertHistoryInput, arg1 func(*sagemaker.ListMonitoringAlertHistoryOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListMonitoringAlertHistoryPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListMonitoringAlertHistoryPages indicates an expected call of ListMonitoringAlertHistoryPages.
func (mr *MockSageMakerAPIMockRecorder) ListMonitoringAlertHistoryPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListMonitoringAlertHistoryPages", reflect.TypeOf((*MockSageMakerAPI)(nil).ListMonitoringAlertHistoryPages), arg0, arg1)
}

// ListMonitoringAlertHistoryPagesWithContext mocks base method.
func (m *MockSageMakerAPI) ListMonitoringAlertHistoryPagesWithContext(arg0 aws.Context, arg1 *sagemaker.ListMonitoringAlertHistoryInput, arg2 func(*sagemaker.ListMonitoringAlertHistoryOutput, 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, "ListMonitoringAlertHistoryPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListMonitoringAlertHistoryPagesWithContext indicates an expected call of ListMonitoringAlertHistoryPagesWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListMonitoringAlertHistoryPagesWithContext(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, "ListMonitoringAlertHistoryPagesWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListMonitoringAlertHistoryPagesWithContext), varargs...)
}

// ListMonitoringAlertHistoryRequest mocks base method.
func (m *MockSageMakerAPI) ListMonitoringAlertHistoryRequest(arg0 *sagemaker.ListMonitoringAlertHistoryInput) (*request.Request, *sagemaker.ListMonitoringAlertHistoryOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListMonitoringAlertHistoryRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.ListMonitoringAlertHistoryOutput)
	return ret0, ret1
}

// ListMonitoringAlertHistoryRequest indicates an expected call of ListMonitoringAlertHistoryRequest.
func (mr *MockSageMakerAPIMockRecorder) ListMonitoringAlertHistoryRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListMonitoringAlertHistoryRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).ListMonitoringAlertHistoryRequest), arg0)
}

// ListMonitoringAlertHistoryWithContext mocks base method.
func (m *MockSageMakerAPI) ListMonitoringAlertHistoryWithContext(arg0 aws.Context, arg1 *sagemaker.ListMonitoringAlertHistoryInput, arg2 ...request.Option) (*sagemaker.ListMonitoringAlertHistoryOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListMonitoringAlertHistoryWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.ListMonitoringAlertHistoryOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListMonitoringAlertHistoryWithContext indicates an expected call of ListMonitoringAlertHistoryWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListMonitoringAlertHistoryWithContext(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, "ListMonitoringAlertHistoryWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListMonitoringAlertHistoryWithContext), varargs...)
}

// ListMonitoringAlerts mocks base method.
func (m *MockSageMakerAPI) ListMonitoringAlerts(arg0 *sagemaker.ListMonitoringAlertsInput) (*sagemaker.ListMonitoringAlertsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListMonitoringAlerts", arg0)
	ret0, _ := ret[0].(*sagemaker.ListMonitoringAlertsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListMonitoringAlerts indicates an expected call of ListMonitoringAlerts.
func (mr *MockSageMakerAPIMockRecorder) ListMonitoringAlerts(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListMonitoringAlerts", reflect.TypeOf((*MockSageMakerAPI)(nil).ListMonitoringAlerts), arg0)
}

// ListMonitoringAlertsPages mocks base method.
func (m *MockSageMakerAPI) ListMonitoringAlertsPages(arg0 *sagemaker.ListMonitoringAlertsInput, arg1 func(*sagemaker.ListMonitoringAlertsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListMonitoringAlertsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListMonitoringAlertsPages indicates an expected call of ListMonitoringAlertsPages.
func (mr *MockSageMakerAPIMockRecorder) ListMonitoringAlertsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListMonitoringAlertsPages", reflect.TypeOf((*MockSageMakerAPI)(nil).ListMonitoringAlertsPages), arg0, arg1)
}

// ListMonitoringAlertsPagesWithContext mocks base method.
func (m *MockSageMakerAPI) ListMonitoringAlertsPagesWithContext(arg0 aws.Context, arg1 *sagemaker.ListMonitoringAlertsInput, arg2 func(*sagemaker.ListMonitoringAlertsOutput, 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, "ListMonitoringAlertsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListMonitoringAlertsPagesWithContext indicates an expected call of ListMonitoringAlertsPagesWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListMonitoringAlertsPagesWithContext(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, "ListMonitoringAlertsPagesWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListMonitoringAlertsPagesWithContext), varargs...)
}

// ListMonitoringAlertsRequest mocks base method.
func (m *MockSageMakerAPI) ListMonitoringAlertsRequest(arg0 *sagemaker.ListMonitoringAlertsInput) (*request.Request, *sagemaker.ListMonitoringAlertsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListMonitoringAlertsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.ListMonitoringAlertsOutput)
	return ret0, ret1
}

// ListMonitoringAlertsRequest indicates an expected call of ListMonitoringAlertsRequest.
func (mr *MockSageMakerAPIMockRecorder) ListMonitoringAlertsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListMonitoringAlertsRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).ListMonitoringAlertsRequest), arg0)
}

// ListMonitoringAlertsWithContext mocks base method.
func (m *MockSageMakerAPI) ListMonitoringAlertsWithContext(arg0 aws.Context, arg1 *sagemaker.ListMonitoringAlertsInput, arg2 ...request.Option) (*sagemaker.ListMonitoringAlertsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListMonitoringAlertsWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.ListMonitoringAlertsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListMonitoringAlertsWithContext indicates an expected call of ListMonitoringAlertsWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListMonitoringAlertsWithContext(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, "ListMonitoringAlertsWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListMonitoringAlertsWithContext), varargs...)
}

// ListMonitoringExecutions mocks base method.
func (m *MockSageMakerAPI) ListMonitoringExecutions(arg0 *sagemaker.ListMonitoringExecutionsInput) (*sagemaker.ListMonitoringExecutionsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListMonitoringExecutions", arg0)
	ret0, _ := ret[0].(*sagemaker.ListMonitoringExecutionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListMonitoringExecutions indicates an expected call of ListMonitoringExecutions.
func (mr *MockSageMakerAPIMockRecorder) ListMonitoringExecutions(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListMonitoringExecutions", reflect.TypeOf((*MockSageMakerAPI)(nil).ListMonitoringExecutions), arg0)
}

// ListMonitoringExecutionsPages mocks base method.
func (m *MockSageMakerAPI) ListMonitoringExecutionsPages(arg0 *sagemaker.ListMonitoringExecutionsInput, arg1 func(*sagemaker.ListMonitoringExecutionsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListMonitoringExecutionsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListMonitoringExecutionsPages indicates an expected call of ListMonitoringExecutionsPages.
func (mr *MockSageMakerAPIMockRecorder) ListMonitoringExecutionsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListMonitoringExecutionsPages", reflect.TypeOf((*MockSageMakerAPI)(nil).ListMonitoringExecutionsPages), arg0, arg1)
}

// ListMonitoringExecutionsPagesWithContext mocks base method.
func (m *MockSageMakerAPI) ListMonitoringExecutionsPagesWithContext(arg0 aws.Context, arg1 *sagemaker.ListMonitoringExecutionsInput, arg2 func(*sagemaker.ListMonitoringExecutionsOutput, 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, "ListMonitoringExecutionsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListMonitoringExecutionsPagesWithContext indicates an expected call of ListMonitoringExecutionsPagesWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListMonitoringExecutionsPagesWithContext(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, "ListMonitoringExecutionsPagesWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListMonitoringExecutionsPagesWithContext), varargs...)
}

// ListMonitoringExecutionsRequest mocks base method.
func (m *MockSageMakerAPI) ListMonitoringExecutionsRequest(arg0 *sagemaker.ListMonitoringExecutionsInput) (*request.Request, *sagemaker.ListMonitoringExecutionsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListMonitoringExecutionsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.ListMonitoringExecutionsOutput)
	return ret0, ret1
}

// ListMonitoringExecutionsRequest indicates an expected call of ListMonitoringExecutionsRequest.
func (mr *MockSageMakerAPIMockRecorder) ListMonitoringExecutionsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListMonitoringExecutionsRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).ListMonitoringExecutionsRequest), arg0)
}

// ListMonitoringExecutionsWithContext mocks base method.
func (m *MockSageMakerAPI) ListMonitoringExecutionsWithContext(arg0 aws.Context, arg1 *sagemaker.ListMonitoringExecutionsInput, arg2 ...request.Option) (*sagemaker.ListMonitoringExecutionsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListMonitoringExecutionsWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.ListMonitoringExecutionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListMonitoringExecutionsWithContext indicates an expected call of ListMonitoringExecutionsWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListMonitoringExecutionsWithContext(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, "ListMonitoringExecutionsWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListMonitoringExecutionsWithContext), varargs...)
}

// ListMonitoringSchedules mocks base method.
func (m *MockSageMakerAPI) ListMonitoringSchedules(arg0 *sagemaker.ListMonitoringSchedulesInput) (*sagemaker.ListMonitoringSchedulesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListMonitoringSchedules", arg0)
	ret0, _ := ret[0].(*sagemaker.ListMonitoringSchedulesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListMonitoringSchedules indicates an expected call of ListMonitoringSchedules.
func (mr *MockSageMakerAPIMockRecorder) ListMonitoringSchedules(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListMonitoringSchedules", reflect.TypeOf((*MockSageMakerAPI)(nil).ListMonitoringSchedules), arg0)
}

// ListMonitoringSchedulesPages mocks base method.
func (m *MockSageMakerAPI) ListMonitoringSchedulesPages(arg0 *sagemaker.ListMonitoringSchedulesInput, arg1 func(*sagemaker.ListMonitoringSchedulesOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListMonitoringSchedulesPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListMonitoringSchedulesPages indicates an expected call of ListMonitoringSchedulesPages.
func (mr *MockSageMakerAPIMockRecorder) ListMonitoringSchedulesPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListMonitoringSchedulesPages", reflect.TypeOf((*MockSageMakerAPI)(nil).ListMonitoringSchedulesPages), arg0, arg1)
}

// ListMonitoringSchedulesPagesWithContext mocks base method.
func (m *MockSageMakerAPI) ListMonitoringSchedulesPagesWithContext(arg0 aws.Context, arg1 *sagemaker.ListMonitoringSchedulesInput, arg2 func(*sagemaker.ListMonitoringSchedulesOutput, 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, "ListMonitoringSchedulesPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListMonitoringSchedulesPagesWithContext indicates an expected call of ListMonitoringSchedulesPagesWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListMonitoringSchedulesPagesWithContext(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, "ListMonitoringSchedulesPagesWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListMonitoringSchedulesPagesWithContext), varargs...)
}

// ListMonitoringSchedulesRequest mocks base method.
func (m *MockSageMakerAPI) ListMonitoringSchedulesRequest(arg0 *sagemaker.ListMonitoringSchedulesInput) (*request.Request, *sagemaker.ListMonitoringSchedulesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListMonitoringSchedulesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.ListMonitoringSchedulesOutput)
	return ret0, ret1
}

// ListMonitoringSchedulesRequest indicates an expected call of ListMonitoringSchedulesRequest.
func (mr *MockSageMakerAPIMockRecorder) ListMonitoringSchedulesRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListMonitoringSchedulesRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).ListMonitoringSchedulesRequest), arg0)
}

// ListMonitoringSchedulesWithContext mocks base method.
func (m *MockSageMakerAPI) ListMonitoringSchedulesWithContext(arg0 aws.Context, arg1 *sagemaker.ListMonitoringSchedulesInput, arg2 ...request.Option) (*sagemaker.ListMonitoringSchedulesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListMonitoringSchedulesWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.ListMonitoringSchedulesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListMonitoringSchedulesWithContext indicates an expected call of ListMonitoringSchedulesWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListMonitoringSchedulesWithContext(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, "ListMonitoringSchedulesWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListMonitoringSchedulesWithContext), varargs...)
}

// ListNotebookInstanceLifecycleConfigs mocks base method.
func (m *MockSageMakerAPI) ListNotebookInstanceLifecycleConfigs(arg0 *sagemaker.ListNotebookInstanceLifecycleConfigsInput) (*sagemaker.ListNotebookInstanceLifecycleConfigsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListNotebookInstanceLifecycleConfigs", arg0)
	ret0, _ := ret[0].(*sagemaker.ListNotebookInstanceLifecycleConfigsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListNotebookInstanceLifecycleConfigs indicates an expected call of ListNotebookInstanceLifecycleConfigs.
func (mr *MockSageMakerAPIMockRecorder) ListNotebookInstanceLifecycleConfigs(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListNotebookInstanceLifecycleConfigs", reflect.TypeOf((*MockSageMakerAPI)(nil).ListNotebookInstanceLifecycleConfigs), arg0)
}

// ListNotebookInstanceLifecycleConfigsPages mocks base method.
func (m *MockSageMakerAPI) ListNotebookInstanceLifecycleConfigsPages(arg0 *sagemaker.ListNotebookInstanceLifecycleConfigsInput, arg1 func(*sagemaker.ListNotebookInstanceLifecycleConfigsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListNotebookInstanceLifecycleConfigsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListNotebookInstanceLifecycleConfigsPages indicates an expected call of ListNotebookInstanceLifecycleConfigsPages.
func (mr *MockSageMakerAPIMockRecorder) ListNotebookInstanceLifecycleConfigsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListNotebookInstanceLifecycleConfigsPages", reflect.TypeOf((*MockSageMakerAPI)(nil).ListNotebookInstanceLifecycleConfigsPages), arg0, arg1)
}

// ListNotebookInstanceLifecycleConfigsPagesWithContext mocks base method.
func (m *MockSageMakerAPI) ListNotebookInstanceLifecycleConfigsPagesWithContext(arg0 aws.Context, arg1 *sagemaker.ListNotebookInstanceLifecycleConfigsInput, arg2 func(*sagemaker.ListNotebookInstanceLifecycleConfigsOutput, 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, "ListNotebookInstanceLifecycleConfigsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListNotebookInstanceLifecycleConfigsPagesWithContext indicates an expected call of ListNotebookInstanceLifecycleConfigsPagesWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListNotebookInstanceLifecycleConfigsPagesWithContext(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, "ListNotebookInstanceLifecycleConfigsPagesWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListNotebookInstanceLifecycleConfigsPagesWithContext), varargs...)
}

// ListNotebookInstanceLifecycleConfigsRequest mocks base method.
func (m *MockSageMakerAPI) ListNotebookInstanceLifecycleConfigsRequest(arg0 *sagemaker.ListNotebookInstanceLifecycleConfigsInput) (*request.Request, *sagemaker.ListNotebookInstanceLifecycleConfigsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListNotebookInstanceLifecycleConfigsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.ListNotebookInstanceLifecycleConfigsOutput)
	return ret0, ret1
}

// ListNotebookInstanceLifecycleConfigsRequest indicates an expected call of ListNotebookInstanceLifecycleConfigsRequest.
func (mr *MockSageMakerAPIMockRecorder) ListNotebookInstanceLifecycleConfigsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListNotebookInstanceLifecycleConfigsRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).ListNotebookInstanceLifecycleConfigsRequest), arg0)
}

// ListNotebookInstanceLifecycleConfigsWithContext mocks base method.
func (m *MockSageMakerAPI) ListNotebookInstanceLifecycleConfigsWithContext(arg0 aws.Context, arg1 *sagemaker.ListNotebookInstanceLifecycleConfigsInput, arg2 ...request.Option) (*sagemaker.ListNotebookInstanceLifecycleConfigsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListNotebookInstanceLifecycleConfigsWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.ListNotebookInstanceLifecycleConfigsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListNotebookInstanceLifecycleConfigsWithContext indicates an expected call of ListNotebookInstanceLifecycleConfigsWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListNotebookInstanceLifecycleConfigsWithContext(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, "ListNotebookInstanceLifecycleConfigsWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListNotebookInstanceLifecycleConfigsWithContext), varargs...)
}

// ListNotebookInstances mocks base method.
func (m *MockSageMakerAPI) ListNotebookInstances(arg0 *sagemaker.ListNotebookInstancesInput) (*sagemaker.ListNotebookInstancesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListNotebookInstances", arg0)
	ret0, _ := ret[0].(*sagemaker.ListNotebookInstancesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListNotebookInstances indicates an expected call of ListNotebookInstances.
func (mr *MockSageMakerAPIMockRecorder) ListNotebookInstances(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListNotebookInstances", reflect.TypeOf((*MockSageMakerAPI)(nil).ListNotebookInstances), arg0)
}

// ListNotebookInstancesPages mocks base method.
func (m *MockSageMakerAPI) ListNotebookInstancesPages(arg0 *sagemaker.ListNotebookInstancesInput, arg1 func(*sagemaker.ListNotebookInstancesOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListNotebookInstancesPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListNotebookInstancesPages indicates an expected call of ListNotebookInstancesPages.
func (mr *MockSageMakerAPIMockRecorder) ListNotebookInstancesPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListNotebookInstancesPages", reflect.TypeOf((*MockSageMakerAPI)(nil).ListNotebookInstancesPages), arg0, arg1)
}

// ListNotebookInstancesPagesWithContext mocks base method.
func (m *MockSageMakerAPI) ListNotebookInstancesPagesWithContext(arg0 aws.Context, arg1 *sagemaker.ListNotebookInstancesInput, arg2 func(*sagemaker.ListNotebookInstancesOutput, 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, "ListNotebookInstancesPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListNotebookInstancesPagesWithContext indicates an expected call of ListNotebookInstancesPagesWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListNotebookInstancesPagesWithContext(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, "ListNotebookInstancesPagesWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListNotebookInstancesPagesWithContext), varargs...)
}

// ListNotebookInstancesRequest mocks base method.
func (m *MockSageMakerAPI) ListNotebookInstancesRequest(arg0 *sagemaker.ListNotebookInstancesInput) (*request.Request, *sagemaker.ListNotebookInstancesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListNotebookInstancesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.ListNotebookInstancesOutput)
	return ret0, ret1
}

// ListNotebookInstancesRequest indicates an expected call of ListNotebookInstancesRequest.
func (mr *MockSageMakerAPIMockRecorder) ListNotebookInstancesRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListNotebookInstancesRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).ListNotebookInstancesRequest), arg0)
}

// ListNotebookInstancesWithContext mocks base method.
func (m *MockSageMakerAPI) ListNotebookInstancesWithContext(arg0 aws.Context, arg1 *sagemaker.ListNotebookInstancesInput, arg2 ...request.Option) (*sagemaker.ListNotebookInstancesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListNotebookInstancesWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.ListNotebookInstancesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListNotebookInstancesWithContext indicates an expected call of ListNotebookInstancesWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListNotebookInstancesWithContext(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, "ListNotebookInstancesWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListNotebookInstancesWithContext), varargs...)
}

// ListOptimizationJobs mocks base method.
func (m *MockSageMakerAPI) ListOptimizationJobs(arg0 *sagemaker.ListOptimizationJobsInput) (*sagemaker.ListOptimizationJobsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListOptimizationJobs", arg0)
	ret0, _ := ret[0].(*sagemaker.ListOptimizationJobsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListOptimizationJobs indicates an expected call of ListOptimizationJobs.
func (mr *MockSageMakerAPIMockRecorder) ListOptimizationJobs(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListOptimizationJobs", reflect.TypeOf((*MockSageMakerAPI)(nil).ListOptimizationJobs), arg0)
}

// ListOptimizationJobsPages mocks base method.
func (m *MockSageMakerAPI) ListOptimizationJobsPages(arg0 *sagemaker.ListOptimizationJobsInput, arg1 func(*sagemaker.ListOptimizationJobsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListOptimizationJobsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListOptimizationJobsPages indicates an expected call of ListOptimizationJobsPages.
func (mr *MockSageMakerAPIMockRecorder) ListOptimizationJobsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListOptimizationJobsPages", reflect.TypeOf((*MockSageMakerAPI)(nil).ListOptimizationJobsPages), arg0, arg1)
}

// ListOptimizationJobsPagesWithContext mocks base method.
func (m *MockSageMakerAPI) ListOptimizationJobsPagesWithContext(arg0 aws.Context, arg1 *sagemaker.ListOptimizationJobsInput, arg2 func(*sagemaker.ListOptimizationJobsOutput, 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, "ListOptimizationJobsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListOptimizationJobsPagesWithContext indicates an expected call of ListOptimizationJobsPagesWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListOptimizationJobsPagesWithContext(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, "ListOptimizationJobsPagesWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListOptimizationJobsPagesWithContext), varargs...)
}

// ListOptimizationJobsRequest mocks base method.
func (m *MockSageMakerAPI) ListOptimizationJobsRequest(arg0 *sagemaker.ListOptimizationJobsInput) (*request.Request, *sagemaker.ListOptimizationJobsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListOptimizationJobsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.ListOptimizationJobsOutput)
	return ret0, ret1
}

// ListOptimizationJobsRequest indicates an expected call of ListOptimizationJobsRequest.
func (mr *MockSageMakerAPIMockRecorder) ListOptimizationJobsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListOptimizationJobsRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).ListOptimizationJobsRequest), arg0)
}

// ListOptimizationJobsWithContext mocks base method.
func (m *MockSageMakerAPI) ListOptimizationJobsWithContext(arg0 aws.Context, arg1 *sagemaker.ListOptimizationJobsInput, arg2 ...request.Option) (*sagemaker.ListOptimizationJobsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListOptimizationJobsWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.ListOptimizationJobsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListOptimizationJobsWithContext indicates an expected call of ListOptimizationJobsWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListOptimizationJobsWithContext(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, "ListOptimizationJobsWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListOptimizationJobsWithContext), varargs...)
}

// ListPipelineExecutionSteps mocks base method.
func (m *MockSageMakerAPI) ListPipelineExecutionSteps(arg0 *sagemaker.ListPipelineExecutionStepsInput) (*sagemaker.ListPipelineExecutionStepsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListPipelineExecutionSteps", arg0)
	ret0, _ := ret[0].(*sagemaker.ListPipelineExecutionStepsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListPipelineExecutionSteps indicates an expected call of ListPipelineExecutionSteps.
func (mr *MockSageMakerAPIMockRecorder) ListPipelineExecutionSteps(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPipelineExecutionSteps", reflect.TypeOf((*MockSageMakerAPI)(nil).ListPipelineExecutionSteps), arg0)
}

// ListPipelineExecutionStepsPages mocks base method.
func (m *MockSageMakerAPI) ListPipelineExecutionStepsPages(arg0 *sagemaker.ListPipelineExecutionStepsInput, arg1 func(*sagemaker.ListPipelineExecutionStepsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListPipelineExecutionStepsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListPipelineExecutionStepsPages indicates an expected call of ListPipelineExecutionStepsPages.
func (mr *MockSageMakerAPIMockRecorder) ListPipelineExecutionStepsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPipelineExecutionStepsPages", reflect.TypeOf((*MockSageMakerAPI)(nil).ListPipelineExecutionStepsPages), arg0, arg1)
}

// ListPipelineExecutionStepsPagesWithContext mocks base method.
func (m *MockSageMakerAPI) ListPipelineExecutionStepsPagesWithContext(arg0 aws.Context, arg1 *sagemaker.ListPipelineExecutionStepsInput, arg2 func(*sagemaker.ListPipelineExecutionStepsOutput, 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, "ListPipelineExecutionStepsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListPipelineExecutionStepsPagesWithContext indicates an expected call of ListPipelineExecutionStepsPagesWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListPipelineExecutionStepsPagesWithContext(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, "ListPipelineExecutionStepsPagesWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListPipelineExecutionStepsPagesWithContext), varargs...)
}

// ListPipelineExecutionStepsRequest mocks base method.
func (m *MockSageMakerAPI) ListPipelineExecutionStepsRequest(arg0 *sagemaker.ListPipelineExecutionStepsInput) (*request.Request, *sagemaker.ListPipelineExecutionStepsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListPipelineExecutionStepsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.ListPipelineExecutionStepsOutput)
	return ret0, ret1
}

// ListPipelineExecutionStepsRequest indicates an expected call of ListPipelineExecutionStepsRequest.
func (mr *MockSageMakerAPIMockRecorder) ListPipelineExecutionStepsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPipelineExecutionStepsRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).ListPipelineExecutionStepsRequest), arg0)
}

// ListPipelineExecutionStepsWithContext mocks base method.
func (m *MockSageMakerAPI) ListPipelineExecutionStepsWithContext(arg0 aws.Context, arg1 *sagemaker.ListPipelineExecutionStepsInput, arg2 ...request.Option) (*sagemaker.ListPipelineExecutionStepsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListPipelineExecutionStepsWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.ListPipelineExecutionStepsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListPipelineExecutionStepsWithContext indicates an expected call of ListPipelineExecutionStepsWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListPipelineExecutionStepsWithContext(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, "ListPipelineExecutionStepsWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListPipelineExecutionStepsWithContext), varargs...)
}

// ListPipelineExecutions mocks base method.
func (m *MockSageMakerAPI) ListPipelineExecutions(arg0 *sagemaker.ListPipelineExecutionsInput) (*sagemaker.ListPipelineExecutionsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListPipelineExecutions", arg0)
	ret0, _ := ret[0].(*sagemaker.ListPipelineExecutionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListPipelineExecutions indicates an expected call of ListPipelineExecutions.
func (mr *MockSageMakerAPIMockRecorder) ListPipelineExecutions(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPipelineExecutions", reflect.TypeOf((*MockSageMakerAPI)(nil).ListPipelineExecutions), arg0)
}

// ListPipelineExecutionsPages mocks base method.
func (m *MockSageMakerAPI) ListPipelineExecutionsPages(arg0 *sagemaker.ListPipelineExecutionsInput, arg1 func(*sagemaker.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 *MockSageMakerAPIMockRecorder) ListPipelineExecutionsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPipelineExecutionsPages", reflect.TypeOf((*MockSageMakerAPI)(nil).ListPipelineExecutionsPages), arg0, arg1)
}

// ListPipelineExecutionsPagesWithContext mocks base method.
func (m *MockSageMakerAPI) ListPipelineExecutionsPagesWithContext(arg0 aws.Context, arg1 *sagemaker.ListPipelineExecutionsInput, arg2 func(*sagemaker.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 *MockSageMakerAPIMockRecorder) 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((*MockSageMakerAPI)(nil).ListPipelineExecutionsPagesWithContext), varargs...)
}

// ListPipelineExecutionsRequest mocks base method.
func (m *MockSageMakerAPI) ListPipelineExecutionsRequest(arg0 *sagemaker.ListPipelineExecutionsInput) (*request.Request, *sagemaker.ListPipelineExecutionsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListPipelineExecutionsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.ListPipelineExecutionsOutput)
	return ret0, ret1
}

// ListPipelineExecutionsRequest indicates an expected call of ListPipelineExecutionsRequest.
func (mr *MockSageMakerAPIMockRecorder) ListPipelineExecutionsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPipelineExecutionsRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).ListPipelineExecutionsRequest), arg0)
}

// ListPipelineExecutionsWithContext mocks base method.
func (m *MockSageMakerAPI) ListPipelineExecutionsWithContext(arg0 aws.Context, arg1 *sagemaker.ListPipelineExecutionsInput, arg2 ...request.Option) (*sagemaker.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].(*sagemaker.ListPipelineExecutionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListPipelineExecutionsWithContext indicates an expected call of ListPipelineExecutionsWithContext.
func (mr *MockSageMakerAPIMockRecorder) 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((*MockSageMakerAPI)(nil).ListPipelineExecutionsWithContext), varargs...)
}

// ListPipelineParametersForExecution mocks base method.
func (m *MockSageMakerAPI) ListPipelineParametersForExecution(arg0 *sagemaker.ListPipelineParametersForExecutionInput) (*sagemaker.ListPipelineParametersForExecutionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListPipelineParametersForExecution", arg0)
	ret0, _ := ret[0].(*sagemaker.ListPipelineParametersForExecutionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListPipelineParametersForExecution indicates an expected call of ListPipelineParametersForExecution.
func (mr *MockSageMakerAPIMockRecorder) ListPipelineParametersForExecution(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPipelineParametersForExecution", reflect.TypeOf((*MockSageMakerAPI)(nil).ListPipelineParametersForExecution), arg0)
}

// ListPipelineParametersForExecutionPages mocks base method.
func (m *MockSageMakerAPI) ListPipelineParametersForExecutionPages(arg0 *sagemaker.ListPipelineParametersForExecutionInput, arg1 func(*sagemaker.ListPipelineParametersForExecutionOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListPipelineParametersForExecutionPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListPipelineParametersForExecutionPages indicates an expected call of ListPipelineParametersForExecutionPages.
func (mr *MockSageMakerAPIMockRecorder) ListPipelineParametersForExecutionPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPipelineParametersForExecutionPages", reflect.TypeOf((*MockSageMakerAPI)(nil).ListPipelineParametersForExecutionPages), arg0, arg1)
}

// ListPipelineParametersForExecutionPagesWithContext mocks base method.
func (m *MockSageMakerAPI) ListPipelineParametersForExecutionPagesWithContext(arg0 aws.Context, arg1 *sagemaker.ListPipelineParametersForExecutionInput, arg2 func(*sagemaker.ListPipelineParametersForExecutionOutput, 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, "ListPipelineParametersForExecutionPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListPipelineParametersForExecutionPagesWithContext indicates an expected call of ListPipelineParametersForExecutionPagesWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListPipelineParametersForExecutionPagesWithContext(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, "ListPipelineParametersForExecutionPagesWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListPipelineParametersForExecutionPagesWithContext), varargs...)
}

// ListPipelineParametersForExecutionRequest mocks base method.
func (m *MockSageMakerAPI) ListPipelineParametersForExecutionRequest(arg0 *sagemaker.ListPipelineParametersForExecutionInput) (*request.Request, *sagemaker.ListPipelineParametersForExecutionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListPipelineParametersForExecutionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.ListPipelineParametersForExecutionOutput)
	return ret0, ret1
}

// ListPipelineParametersForExecutionRequest indicates an expected call of ListPipelineParametersForExecutionRequest.
func (mr *MockSageMakerAPIMockRecorder) ListPipelineParametersForExecutionRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPipelineParametersForExecutionRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).ListPipelineParametersForExecutionRequest), arg0)
}

// ListPipelineParametersForExecutionWithContext mocks base method.
func (m *MockSageMakerAPI) ListPipelineParametersForExecutionWithContext(arg0 aws.Context, arg1 *sagemaker.ListPipelineParametersForExecutionInput, arg2 ...request.Option) (*sagemaker.ListPipelineParametersForExecutionOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListPipelineParametersForExecutionWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.ListPipelineParametersForExecutionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListPipelineParametersForExecutionWithContext indicates an expected call of ListPipelineParametersForExecutionWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListPipelineParametersForExecutionWithContext(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, "ListPipelineParametersForExecutionWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListPipelineParametersForExecutionWithContext), varargs...)
}

// ListPipelines mocks base method.
func (m *MockSageMakerAPI) ListPipelines(arg0 *sagemaker.ListPipelinesInput) (*sagemaker.ListPipelinesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListPipelines", arg0)
	ret0, _ := ret[0].(*sagemaker.ListPipelinesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListPipelines indicates an expected call of ListPipelines.
func (mr *MockSageMakerAPIMockRecorder) ListPipelines(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPipelines", reflect.TypeOf((*MockSageMakerAPI)(nil).ListPipelines), arg0)
}

// ListPipelinesPages mocks base method.
func (m *MockSageMakerAPI) ListPipelinesPages(arg0 *sagemaker.ListPipelinesInput, arg1 func(*sagemaker.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 *MockSageMakerAPIMockRecorder) ListPipelinesPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPipelinesPages", reflect.TypeOf((*MockSageMakerAPI)(nil).ListPipelinesPages), arg0, arg1)
}

// ListPipelinesPagesWithContext mocks base method.
func (m *MockSageMakerAPI) ListPipelinesPagesWithContext(arg0 aws.Context, arg1 *sagemaker.ListPipelinesInput, arg2 func(*sagemaker.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 *MockSageMakerAPIMockRecorder) 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((*MockSageMakerAPI)(nil).ListPipelinesPagesWithContext), varargs...)
}

// ListPipelinesRequest mocks base method.
func (m *MockSageMakerAPI) ListPipelinesRequest(arg0 *sagemaker.ListPipelinesInput) (*request.Request, *sagemaker.ListPipelinesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListPipelinesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.ListPipelinesOutput)
	return ret0, ret1
}

// ListPipelinesRequest indicates an expected call of ListPipelinesRequest.
func (mr *MockSageMakerAPIMockRecorder) ListPipelinesRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPipelinesRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).ListPipelinesRequest), arg0)
}

// ListPipelinesWithContext mocks base method.
func (m *MockSageMakerAPI) ListPipelinesWithContext(arg0 aws.Context, arg1 *sagemaker.ListPipelinesInput, arg2 ...request.Option) (*sagemaker.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].(*sagemaker.ListPipelinesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListPipelinesWithContext indicates an expected call of ListPipelinesWithContext.
func (mr *MockSageMakerAPIMockRecorder) 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((*MockSageMakerAPI)(nil).ListPipelinesWithContext), varargs...)
}

// ListProcessingJobs mocks base method.
func (m *MockSageMakerAPI) ListProcessingJobs(arg0 *sagemaker.ListProcessingJobsInput) (*sagemaker.ListProcessingJobsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListProcessingJobs", arg0)
	ret0, _ := ret[0].(*sagemaker.ListProcessingJobsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListProcessingJobs indicates an expected call of ListProcessingJobs.
func (mr *MockSageMakerAPIMockRecorder) ListProcessingJobs(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListProcessingJobs", reflect.TypeOf((*MockSageMakerAPI)(nil).ListProcessingJobs), arg0)
}

// ListProcessingJobsPages mocks base method.
func (m *MockSageMakerAPI) ListProcessingJobsPages(arg0 *sagemaker.ListProcessingJobsInput, arg1 func(*sagemaker.ListProcessingJobsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListProcessingJobsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListProcessingJobsPages indicates an expected call of ListProcessingJobsPages.
func (mr *MockSageMakerAPIMockRecorder) ListProcessingJobsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListProcessingJobsPages", reflect.TypeOf((*MockSageMakerAPI)(nil).ListProcessingJobsPages), arg0, arg1)
}

// ListProcessingJobsPagesWithContext mocks base method.
func (m *MockSageMakerAPI) ListProcessingJobsPagesWithContext(arg0 aws.Context, arg1 *sagemaker.ListProcessingJobsInput, arg2 func(*sagemaker.ListProcessingJobsOutput, 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, "ListProcessingJobsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListProcessingJobsPagesWithContext indicates an expected call of ListProcessingJobsPagesWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListProcessingJobsPagesWithContext(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, "ListProcessingJobsPagesWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListProcessingJobsPagesWithContext), varargs...)
}

// ListProcessingJobsRequest mocks base method.
func (m *MockSageMakerAPI) ListProcessingJobsRequest(arg0 *sagemaker.ListProcessingJobsInput) (*request.Request, *sagemaker.ListProcessingJobsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListProcessingJobsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.ListProcessingJobsOutput)
	return ret0, ret1
}

// ListProcessingJobsRequest indicates an expected call of ListProcessingJobsRequest.
func (mr *MockSageMakerAPIMockRecorder) ListProcessingJobsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListProcessingJobsRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).ListProcessingJobsRequest), arg0)
}

// ListProcessingJobsWithContext mocks base method.
func (m *MockSageMakerAPI) ListProcessingJobsWithContext(arg0 aws.Context, arg1 *sagemaker.ListProcessingJobsInput, arg2 ...request.Option) (*sagemaker.ListProcessingJobsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListProcessingJobsWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.ListProcessingJobsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListProcessingJobsWithContext indicates an expected call of ListProcessingJobsWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListProcessingJobsWithContext(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, "ListProcessingJobsWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListProcessingJobsWithContext), varargs...)
}

// ListProjects mocks base method.
func (m *MockSageMakerAPI) ListProjects(arg0 *sagemaker.ListProjectsInput) (*sagemaker.ListProjectsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListProjects", arg0)
	ret0, _ := ret[0].(*sagemaker.ListProjectsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListProjects indicates an expected call of ListProjects.
func (mr *MockSageMakerAPIMockRecorder) ListProjects(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListProjects", reflect.TypeOf((*MockSageMakerAPI)(nil).ListProjects), arg0)
}

// ListProjectsPages mocks base method.
func (m *MockSageMakerAPI) ListProjectsPages(arg0 *sagemaker.ListProjectsInput, arg1 func(*sagemaker.ListProjectsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListProjectsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListProjectsPages indicates an expected call of ListProjectsPages.
func (mr *MockSageMakerAPIMockRecorder) ListProjectsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListProjectsPages", reflect.TypeOf((*MockSageMakerAPI)(nil).ListProjectsPages), arg0, arg1)
}

// ListProjectsPagesWithContext mocks base method.
func (m *MockSageMakerAPI) ListProjectsPagesWithContext(arg0 aws.Context, arg1 *sagemaker.ListProjectsInput, arg2 func(*sagemaker.ListProjectsOutput, 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, "ListProjectsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListProjectsPagesWithContext indicates an expected call of ListProjectsPagesWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListProjectsPagesWithContext(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, "ListProjectsPagesWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListProjectsPagesWithContext), varargs...)
}

// ListProjectsRequest mocks base method.
func (m *MockSageMakerAPI) ListProjectsRequest(arg0 *sagemaker.ListProjectsInput) (*request.Request, *sagemaker.ListProjectsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListProjectsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.ListProjectsOutput)
	return ret0, ret1
}

// ListProjectsRequest indicates an expected call of ListProjectsRequest.
func (mr *MockSageMakerAPIMockRecorder) ListProjectsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListProjectsRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).ListProjectsRequest), arg0)
}

// ListProjectsWithContext mocks base method.
func (m *MockSageMakerAPI) ListProjectsWithContext(arg0 aws.Context, arg1 *sagemaker.ListProjectsInput, arg2 ...request.Option) (*sagemaker.ListProjectsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListProjectsWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.ListProjectsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListProjectsWithContext indicates an expected call of ListProjectsWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListProjectsWithContext(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, "ListProjectsWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListProjectsWithContext), varargs...)
}

// ListResourceCatalogs mocks base method.
func (m *MockSageMakerAPI) ListResourceCatalogs(arg0 *sagemaker.ListResourceCatalogsInput) (*sagemaker.ListResourceCatalogsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListResourceCatalogs", arg0)
	ret0, _ := ret[0].(*sagemaker.ListResourceCatalogsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListResourceCatalogs indicates an expected call of ListResourceCatalogs.
func (mr *MockSageMakerAPIMockRecorder) ListResourceCatalogs(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListResourceCatalogs", reflect.TypeOf((*MockSageMakerAPI)(nil).ListResourceCatalogs), arg0)
}

// ListResourceCatalogsPages mocks base method.
func (m *MockSageMakerAPI) ListResourceCatalogsPages(arg0 *sagemaker.ListResourceCatalogsInput, arg1 func(*sagemaker.ListResourceCatalogsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListResourceCatalogsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListResourceCatalogsPages indicates an expected call of ListResourceCatalogsPages.
func (mr *MockSageMakerAPIMockRecorder) ListResourceCatalogsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListResourceCatalogsPages", reflect.TypeOf((*MockSageMakerAPI)(nil).ListResourceCatalogsPages), arg0, arg1)
}

// ListResourceCatalogsPagesWithContext mocks base method.
func (m *MockSageMakerAPI) ListResourceCatalogsPagesWithContext(arg0 aws.Context, arg1 *sagemaker.ListResourceCatalogsInput, arg2 func(*sagemaker.ListResourceCatalogsOutput, 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, "ListResourceCatalogsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListResourceCatalogsPagesWithContext indicates an expected call of ListResourceCatalogsPagesWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListResourceCatalogsPagesWithContext(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, "ListResourceCatalogsPagesWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListResourceCatalogsPagesWithContext), varargs...)
}

// ListResourceCatalogsRequest mocks base method.
func (m *MockSageMakerAPI) ListResourceCatalogsRequest(arg0 *sagemaker.ListResourceCatalogsInput) (*request.Request, *sagemaker.ListResourceCatalogsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListResourceCatalogsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.ListResourceCatalogsOutput)
	return ret0, ret1
}

// ListResourceCatalogsRequest indicates an expected call of ListResourceCatalogsRequest.
func (mr *MockSageMakerAPIMockRecorder) ListResourceCatalogsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListResourceCatalogsRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).ListResourceCatalogsRequest), arg0)
}

// ListResourceCatalogsWithContext mocks base method.
func (m *MockSageMakerAPI) ListResourceCatalogsWithContext(arg0 aws.Context, arg1 *sagemaker.ListResourceCatalogsInput, arg2 ...request.Option) (*sagemaker.ListResourceCatalogsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListResourceCatalogsWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.ListResourceCatalogsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListResourceCatalogsWithContext indicates an expected call of ListResourceCatalogsWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListResourceCatalogsWithContext(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, "ListResourceCatalogsWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListResourceCatalogsWithContext), varargs...)
}

// ListSpaces mocks base method.
func (m *MockSageMakerAPI) ListSpaces(arg0 *sagemaker.ListSpacesInput) (*sagemaker.ListSpacesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListSpaces", arg0)
	ret0, _ := ret[0].(*sagemaker.ListSpacesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListSpaces indicates an expected call of ListSpaces.
func (mr *MockSageMakerAPIMockRecorder) ListSpaces(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListSpaces", reflect.TypeOf((*MockSageMakerAPI)(nil).ListSpaces), arg0)
}

// ListSpacesPages mocks base method.
func (m *MockSageMakerAPI) ListSpacesPages(arg0 *sagemaker.ListSpacesInput, arg1 func(*sagemaker.ListSpacesOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListSpacesPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListSpacesPages indicates an expected call of ListSpacesPages.
func (mr *MockSageMakerAPIMockRecorder) ListSpacesPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListSpacesPages", reflect.TypeOf((*MockSageMakerAPI)(nil).ListSpacesPages), arg0, arg1)
}

// ListSpacesPagesWithContext mocks base method.
func (m *MockSageMakerAPI) ListSpacesPagesWithContext(arg0 aws.Context, arg1 *sagemaker.ListSpacesInput, arg2 func(*sagemaker.ListSpacesOutput, 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, "ListSpacesPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListSpacesPagesWithContext indicates an expected call of ListSpacesPagesWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListSpacesPagesWithContext(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, "ListSpacesPagesWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListSpacesPagesWithContext), varargs...)
}

// ListSpacesRequest mocks base method.
func (m *MockSageMakerAPI) ListSpacesRequest(arg0 *sagemaker.ListSpacesInput) (*request.Request, *sagemaker.ListSpacesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListSpacesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.ListSpacesOutput)
	return ret0, ret1
}

// ListSpacesRequest indicates an expected call of ListSpacesRequest.
func (mr *MockSageMakerAPIMockRecorder) ListSpacesRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListSpacesRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).ListSpacesRequest), arg0)
}

// ListSpacesWithContext mocks base method.
func (m *MockSageMakerAPI) ListSpacesWithContext(arg0 aws.Context, arg1 *sagemaker.ListSpacesInput, arg2 ...request.Option) (*sagemaker.ListSpacesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListSpacesWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.ListSpacesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListSpacesWithContext indicates an expected call of ListSpacesWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListSpacesWithContext(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, "ListSpacesWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListSpacesWithContext), varargs...)
}

// ListStageDevices mocks base method.
func (m *MockSageMakerAPI) ListStageDevices(arg0 *sagemaker.ListStageDevicesInput) (*sagemaker.ListStageDevicesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListStageDevices", arg0)
	ret0, _ := ret[0].(*sagemaker.ListStageDevicesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListStageDevices indicates an expected call of ListStageDevices.
func (mr *MockSageMakerAPIMockRecorder) ListStageDevices(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListStageDevices", reflect.TypeOf((*MockSageMakerAPI)(nil).ListStageDevices), arg0)
}

// ListStageDevicesPages mocks base method.
func (m *MockSageMakerAPI) ListStageDevicesPages(arg0 *sagemaker.ListStageDevicesInput, arg1 func(*sagemaker.ListStageDevicesOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListStageDevicesPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListStageDevicesPages indicates an expected call of ListStageDevicesPages.
func (mr *MockSageMakerAPIMockRecorder) ListStageDevicesPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListStageDevicesPages", reflect.TypeOf((*MockSageMakerAPI)(nil).ListStageDevicesPages), arg0, arg1)
}

// ListStageDevicesPagesWithContext mocks base method.
func (m *MockSageMakerAPI) ListStageDevicesPagesWithContext(arg0 aws.Context, arg1 *sagemaker.ListStageDevicesInput, arg2 func(*sagemaker.ListStageDevicesOutput, 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, "ListStageDevicesPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListStageDevicesPagesWithContext indicates an expected call of ListStageDevicesPagesWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListStageDevicesPagesWithContext(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, "ListStageDevicesPagesWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListStageDevicesPagesWithContext), varargs...)
}

// ListStageDevicesRequest mocks base method.
func (m *MockSageMakerAPI) ListStageDevicesRequest(arg0 *sagemaker.ListStageDevicesInput) (*request.Request, *sagemaker.ListStageDevicesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListStageDevicesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.ListStageDevicesOutput)
	return ret0, ret1
}

// ListStageDevicesRequest indicates an expected call of ListStageDevicesRequest.
func (mr *MockSageMakerAPIMockRecorder) ListStageDevicesRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListStageDevicesRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).ListStageDevicesRequest), arg0)
}

// ListStageDevicesWithContext mocks base method.
func (m *MockSageMakerAPI) ListStageDevicesWithContext(arg0 aws.Context, arg1 *sagemaker.ListStageDevicesInput, arg2 ...request.Option) (*sagemaker.ListStageDevicesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListStageDevicesWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.ListStageDevicesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListStageDevicesWithContext indicates an expected call of ListStageDevicesWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListStageDevicesWithContext(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, "ListStageDevicesWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListStageDevicesWithContext), varargs...)
}

// ListStudioLifecycleConfigs mocks base method.
func (m *MockSageMakerAPI) ListStudioLifecycleConfigs(arg0 *sagemaker.ListStudioLifecycleConfigsInput) (*sagemaker.ListStudioLifecycleConfigsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListStudioLifecycleConfigs", arg0)
	ret0, _ := ret[0].(*sagemaker.ListStudioLifecycleConfigsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListStudioLifecycleConfigs indicates an expected call of ListStudioLifecycleConfigs.
func (mr *MockSageMakerAPIMockRecorder) ListStudioLifecycleConfigs(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListStudioLifecycleConfigs", reflect.TypeOf((*MockSageMakerAPI)(nil).ListStudioLifecycleConfigs), arg0)
}

// ListStudioLifecycleConfigsPages mocks base method.
func (m *MockSageMakerAPI) ListStudioLifecycleConfigsPages(arg0 *sagemaker.ListStudioLifecycleConfigsInput, arg1 func(*sagemaker.ListStudioLifecycleConfigsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListStudioLifecycleConfigsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListStudioLifecycleConfigsPages indicates an expected call of ListStudioLifecycleConfigsPages.
func (mr *MockSageMakerAPIMockRecorder) ListStudioLifecycleConfigsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListStudioLifecycleConfigsPages", reflect.TypeOf((*MockSageMakerAPI)(nil).ListStudioLifecycleConfigsPages), arg0, arg1)
}

// ListStudioLifecycleConfigsPagesWithContext mocks base method.
func (m *MockSageMakerAPI) ListStudioLifecycleConfigsPagesWithContext(arg0 aws.Context, arg1 *sagemaker.ListStudioLifecycleConfigsInput, arg2 func(*sagemaker.ListStudioLifecycleConfigsOutput, 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, "ListStudioLifecycleConfigsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListStudioLifecycleConfigsPagesWithContext indicates an expected call of ListStudioLifecycleConfigsPagesWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListStudioLifecycleConfigsPagesWithContext(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, "ListStudioLifecycleConfigsPagesWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListStudioLifecycleConfigsPagesWithContext), varargs...)
}

// ListStudioLifecycleConfigsRequest mocks base method.
func (m *MockSageMakerAPI) ListStudioLifecycleConfigsRequest(arg0 *sagemaker.ListStudioLifecycleConfigsInput) (*request.Request, *sagemaker.ListStudioLifecycleConfigsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListStudioLifecycleConfigsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.ListStudioLifecycleConfigsOutput)
	return ret0, ret1
}

// ListStudioLifecycleConfigsRequest indicates an expected call of ListStudioLifecycleConfigsRequest.
func (mr *MockSageMakerAPIMockRecorder) ListStudioLifecycleConfigsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListStudioLifecycleConfigsRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).ListStudioLifecycleConfigsRequest), arg0)
}

// ListStudioLifecycleConfigsWithContext mocks base method.
func (m *MockSageMakerAPI) ListStudioLifecycleConfigsWithContext(arg0 aws.Context, arg1 *sagemaker.ListStudioLifecycleConfigsInput, arg2 ...request.Option) (*sagemaker.ListStudioLifecycleConfigsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListStudioLifecycleConfigsWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.ListStudioLifecycleConfigsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListStudioLifecycleConfigsWithContext indicates an expected call of ListStudioLifecycleConfigsWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListStudioLifecycleConfigsWithContext(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, "ListStudioLifecycleConfigsWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListStudioLifecycleConfigsWithContext), varargs...)
}

// ListSubscribedWorkteams mocks base method.
func (m *MockSageMakerAPI) ListSubscribedWorkteams(arg0 *sagemaker.ListSubscribedWorkteamsInput) (*sagemaker.ListSubscribedWorkteamsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListSubscribedWorkteams", arg0)
	ret0, _ := ret[0].(*sagemaker.ListSubscribedWorkteamsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListSubscribedWorkteams indicates an expected call of ListSubscribedWorkteams.
func (mr *MockSageMakerAPIMockRecorder) ListSubscribedWorkteams(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListSubscribedWorkteams", reflect.TypeOf((*MockSageMakerAPI)(nil).ListSubscribedWorkteams), arg0)
}

// ListSubscribedWorkteamsPages mocks base method.
func (m *MockSageMakerAPI) ListSubscribedWorkteamsPages(arg0 *sagemaker.ListSubscribedWorkteamsInput, arg1 func(*sagemaker.ListSubscribedWorkteamsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListSubscribedWorkteamsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListSubscribedWorkteamsPages indicates an expected call of ListSubscribedWorkteamsPages.
func (mr *MockSageMakerAPIMockRecorder) ListSubscribedWorkteamsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListSubscribedWorkteamsPages", reflect.TypeOf((*MockSageMakerAPI)(nil).ListSubscribedWorkteamsPages), arg0, arg1)
}

// ListSubscribedWorkteamsPagesWithContext mocks base method.
func (m *MockSageMakerAPI) ListSubscribedWorkteamsPagesWithContext(arg0 aws.Context, arg1 *sagemaker.ListSubscribedWorkteamsInput, arg2 func(*sagemaker.ListSubscribedWorkteamsOutput, 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, "ListSubscribedWorkteamsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListSubscribedWorkteamsPagesWithContext indicates an expected call of ListSubscribedWorkteamsPagesWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListSubscribedWorkteamsPagesWithContext(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, "ListSubscribedWorkteamsPagesWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListSubscribedWorkteamsPagesWithContext), varargs...)
}

// ListSubscribedWorkteamsRequest mocks base method.
func (m *MockSageMakerAPI) ListSubscribedWorkteamsRequest(arg0 *sagemaker.ListSubscribedWorkteamsInput) (*request.Request, *sagemaker.ListSubscribedWorkteamsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListSubscribedWorkteamsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.ListSubscribedWorkteamsOutput)
	return ret0, ret1
}

// ListSubscribedWorkteamsRequest indicates an expected call of ListSubscribedWorkteamsRequest.
func (mr *MockSageMakerAPIMockRecorder) ListSubscribedWorkteamsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListSubscribedWorkteamsRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).ListSubscribedWorkteamsRequest), arg0)
}

// ListSubscribedWorkteamsWithContext mocks base method.
func (m *MockSageMakerAPI) ListSubscribedWorkteamsWithContext(arg0 aws.Context, arg1 *sagemaker.ListSubscribedWorkteamsInput, arg2 ...request.Option) (*sagemaker.ListSubscribedWorkteamsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListSubscribedWorkteamsWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.ListSubscribedWorkteamsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListSubscribedWorkteamsWithContext indicates an expected call of ListSubscribedWorkteamsWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListSubscribedWorkteamsWithContext(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, "ListSubscribedWorkteamsWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListSubscribedWorkteamsWithContext), varargs...)
}

// ListTags mocks base method.
func (m *MockSageMakerAPI) ListTags(arg0 *sagemaker.ListTagsInput) (*sagemaker.ListTagsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListTags", arg0)
	ret0, _ := ret[0].(*sagemaker.ListTagsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListTags indicates an expected call of ListTags.
func (mr *MockSageMakerAPIMockRecorder) ListTags(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTags", reflect.TypeOf((*MockSageMakerAPI)(nil).ListTags), arg0)
}

// ListTagsPages mocks base method.
func (m *MockSageMakerAPI) ListTagsPages(arg0 *sagemaker.ListTagsInput, arg1 func(*sagemaker.ListTagsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListTagsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListTagsPages indicates an expected call of ListTagsPages.
func (mr *MockSageMakerAPIMockRecorder) ListTagsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTagsPages", reflect.TypeOf((*MockSageMakerAPI)(nil).ListTagsPages), arg0, arg1)
}

// ListTagsPagesWithContext mocks base method.
func (m *MockSageMakerAPI) ListTagsPagesWithContext(arg0 aws.Context, arg1 *sagemaker.ListTagsInput, arg2 func(*sagemaker.ListTagsOutput, 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, "ListTagsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListTagsPagesWithContext indicates an expected call of ListTagsPagesWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListTagsPagesWithContext(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, "ListTagsPagesWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListTagsPagesWithContext), varargs...)
}

// ListTagsRequest mocks base method.
func (m *MockSageMakerAPI) ListTagsRequest(arg0 *sagemaker.ListTagsInput) (*request.Request, *sagemaker.ListTagsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListTagsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.ListTagsOutput)
	return ret0, ret1
}

// ListTagsRequest indicates an expected call of ListTagsRequest.
func (mr *MockSageMakerAPIMockRecorder) ListTagsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTagsRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).ListTagsRequest), arg0)
}

// ListTagsWithContext mocks base method.
func (m *MockSageMakerAPI) ListTagsWithContext(arg0 aws.Context, arg1 *sagemaker.ListTagsInput, arg2 ...request.Option) (*sagemaker.ListTagsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListTagsWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.ListTagsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListTagsWithContext indicates an expected call of ListTagsWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListTagsWithContext(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, "ListTagsWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListTagsWithContext), varargs...)
}

// ListTrainingJobs mocks base method.
func (m *MockSageMakerAPI) ListTrainingJobs(arg0 *sagemaker.ListTrainingJobsInput) (*sagemaker.ListTrainingJobsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListTrainingJobs", arg0)
	ret0, _ := ret[0].(*sagemaker.ListTrainingJobsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListTrainingJobs indicates an expected call of ListTrainingJobs.
func (mr *MockSageMakerAPIMockRecorder) ListTrainingJobs(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTrainingJobs", reflect.TypeOf((*MockSageMakerAPI)(nil).ListTrainingJobs), arg0)
}

// ListTrainingJobsForHyperParameterTuningJob mocks base method.
func (m *MockSageMakerAPI) ListTrainingJobsForHyperParameterTuningJob(arg0 *sagemaker.ListTrainingJobsForHyperParameterTuningJobInput) (*sagemaker.ListTrainingJobsForHyperParameterTuningJobOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListTrainingJobsForHyperParameterTuningJob", arg0)
	ret0, _ := ret[0].(*sagemaker.ListTrainingJobsForHyperParameterTuningJobOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListTrainingJobsForHyperParameterTuningJob indicates an expected call of ListTrainingJobsForHyperParameterTuningJob.
func (mr *MockSageMakerAPIMockRecorder) ListTrainingJobsForHyperParameterTuningJob(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTrainingJobsForHyperParameterTuningJob", reflect.TypeOf((*MockSageMakerAPI)(nil).ListTrainingJobsForHyperParameterTuningJob), arg0)
}

// ListTrainingJobsForHyperParameterTuningJobPages mocks base method.
func (m *MockSageMakerAPI) ListTrainingJobsForHyperParameterTuningJobPages(arg0 *sagemaker.ListTrainingJobsForHyperParameterTuningJobInput, arg1 func(*sagemaker.ListTrainingJobsForHyperParameterTuningJobOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListTrainingJobsForHyperParameterTuningJobPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListTrainingJobsForHyperParameterTuningJobPages indicates an expected call of ListTrainingJobsForHyperParameterTuningJobPages.
func (mr *MockSageMakerAPIMockRecorder) ListTrainingJobsForHyperParameterTuningJobPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTrainingJobsForHyperParameterTuningJobPages", reflect.TypeOf((*MockSageMakerAPI)(nil).ListTrainingJobsForHyperParameterTuningJobPages), arg0, arg1)
}

// ListTrainingJobsForHyperParameterTuningJobPagesWithContext mocks base method.
func (m *MockSageMakerAPI) ListTrainingJobsForHyperParameterTuningJobPagesWithContext(arg0 aws.Context, arg1 *sagemaker.ListTrainingJobsForHyperParameterTuningJobInput, arg2 func(*sagemaker.ListTrainingJobsForHyperParameterTuningJobOutput, 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, "ListTrainingJobsForHyperParameterTuningJobPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListTrainingJobsForHyperParameterTuningJobPagesWithContext indicates an expected call of ListTrainingJobsForHyperParameterTuningJobPagesWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListTrainingJobsForHyperParameterTuningJobPagesWithContext(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, "ListTrainingJobsForHyperParameterTuningJobPagesWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListTrainingJobsForHyperParameterTuningJobPagesWithContext), varargs...)
}

// ListTrainingJobsForHyperParameterTuningJobRequest mocks base method.
func (m *MockSageMakerAPI) ListTrainingJobsForHyperParameterTuningJobRequest(arg0 *sagemaker.ListTrainingJobsForHyperParameterTuningJobInput) (*request.Request, *sagemaker.ListTrainingJobsForHyperParameterTuningJobOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListTrainingJobsForHyperParameterTuningJobRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.ListTrainingJobsForHyperParameterTuningJobOutput)
	return ret0, ret1
}

// ListTrainingJobsForHyperParameterTuningJobRequest indicates an expected call of ListTrainingJobsForHyperParameterTuningJobRequest.
func (mr *MockSageMakerAPIMockRecorder) ListTrainingJobsForHyperParameterTuningJobRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTrainingJobsForHyperParameterTuningJobRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).ListTrainingJobsForHyperParameterTuningJobRequest), arg0)
}

// ListTrainingJobsForHyperParameterTuningJobWithContext mocks base method.
func (m *MockSageMakerAPI) ListTrainingJobsForHyperParameterTuningJobWithContext(arg0 aws.Context, arg1 *sagemaker.ListTrainingJobsForHyperParameterTuningJobInput, arg2 ...request.Option) (*sagemaker.ListTrainingJobsForHyperParameterTuningJobOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListTrainingJobsForHyperParameterTuningJobWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.ListTrainingJobsForHyperParameterTuningJobOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListTrainingJobsForHyperParameterTuningJobWithContext indicates an expected call of ListTrainingJobsForHyperParameterTuningJobWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListTrainingJobsForHyperParameterTuningJobWithContext(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, "ListTrainingJobsForHyperParameterTuningJobWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListTrainingJobsForHyperParameterTuningJobWithContext), varargs...)
}

// ListTrainingJobsPages mocks base method.
func (m *MockSageMakerAPI) ListTrainingJobsPages(arg0 *sagemaker.ListTrainingJobsInput, arg1 func(*sagemaker.ListTrainingJobsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListTrainingJobsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListTrainingJobsPages indicates an expected call of ListTrainingJobsPages.
func (mr *MockSageMakerAPIMockRecorder) ListTrainingJobsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTrainingJobsPages", reflect.TypeOf((*MockSageMakerAPI)(nil).ListTrainingJobsPages), arg0, arg1)
}

// ListTrainingJobsPagesWithContext mocks base method.
func (m *MockSageMakerAPI) ListTrainingJobsPagesWithContext(arg0 aws.Context, arg1 *sagemaker.ListTrainingJobsInput, arg2 func(*sagemaker.ListTrainingJobsOutput, 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, "ListTrainingJobsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListTrainingJobsPagesWithContext indicates an expected call of ListTrainingJobsPagesWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListTrainingJobsPagesWithContext(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, "ListTrainingJobsPagesWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListTrainingJobsPagesWithContext), varargs...)
}

// ListTrainingJobsRequest mocks base method.
func (m *MockSageMakerAPI) ListTrainingJobsRequest(arg0 *sagemaker.ListTrainingJobsInput) (*request.Request, *sagemaker.ListTrainingJobsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListTrainingJobsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.ListTrainingJobsOutput)
	return ret0, ret1
}

// ListTrainingJobsRequest indicates an expected call of ListTrainingJobsRequest.
func (mr *MockSageMakerAPIMockRecorder) ListTrainingJobsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTrainingJobsRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).ListTrainingJobsRequest), arg0)
}

// ListTrainingJobsWithContext mocks base method.
func (m *MockSageMakerAPI) ListTrainingJobsWithContext(arg0 aws.Context, arg1 *sagemaker.ListTrainingJobsInput, arg2 ...request.Option) (*sagemaker.ListTrainingJobsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListTrainingJobsWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.ListTrainingJobsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListTrainingJobsWithContext indicates an expected call of ListTrainingJobsWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListTrainingJobsWithContext(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, "ListTrainingJobsWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListTrainingJobsWithContext), varargs...)
}

// ListTransformJobs mocks base method.
func (m *MockSageMakerAPI) ListTransformJobs(arg0 *sagemaker.ListTransformJobsInput) (*sagemaker.ListTransformJobsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListTransformJobs", arg0)
	ret0, _ := ret[0].(*sagemaker.ListTransformJobsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListTransformJobs indicates an expected call of ListTransformJobs.
func (mr *MockSageMakerAPIMockRecorder) ListTransformJobs(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTransformJobs", reflect.TypeOf((*MockSageMakerAPI)(nil).ListTransformJobs), arg0)
}

// ListTransformJobsPages mocks base method.
func (m *MockSageMakerAPI) ListTransformJobsPages(arg0 *sagemaker.ListTransformJobsInput, arg1 func(*sagemaker.ListTransformJobsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListTransformJobsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListTransformJobsPages indicates an expected call of ListTransformJobsPages.
func (mr *MockSageMakerAPIMockRecorder) ListTransformJobsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTransformJobsPages", reflect.TypeOf((*MockSageMakerAPI)(nil).ListTransformJobsPages), arg0, arg1)
}

// ListTransformJobsPagesWithContext mocks base method.
func (m *MockSageMakerAPI) ListTransformJobsPagesWithContext(arg0 aws.Context, arg1 *sagemaker.ListTransformJobsInput, arg2 func(*sagemaker.ListTransformJobsOutput, 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, "ListTransformJobsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListTransformJobsPagesWithContext indicates an expected call of ListTransformJobsPagesWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListTransformJobsPagesWithContext(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, "ListTransformJobsPagesWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListTransformJobsPagesWithContext), varargs...)
}

// ListTransformJobsRequest mocks base method.
func (m *MockSageMakerAPI) ListTransformJobsRequest(arg0 *sagemaker.ListTransformJobsInput) (*request.Request, *sagemaker.ListTransformJobsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListTransformJobsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.ListTransformJobsOutput)
	return ret0, ret1
}

// ListTransformJobsRequest indicates an expected call of ListTransformJobsRequest.
func (mr *MockSageMakerAPIMockRecorder) ListTransformJobsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTransformJobsRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).ListTransformJobsRequest), arg0)
}

// ListTransformJobsWithContext mocks base method.
func (m *MockSageMakerAPI) ListTransformJobsWithContext(arg0 aws.Context, arg1 *sagemaker.ListTransformJobsInput, arg2 ...request.Option) (*sagemaker.ListTransformJobsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListTransformJobsWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.ListTransformJobsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListTransformJobsWithContext indicates an expected call of ListTransformJobsWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListTransformJobsWithContext(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, "ListTransformJobsWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListTransformJobsWithContext), varargs...)
}

// ListTrialComponents mocks base method.
func (m *MockSageMakerAPI) ListTrialComponents(arg0 *sagemaker.ListTrialComponentsInput) (*sagemaker.ListTrialComponentsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListTrialComponents", arg0)
	ret0, _ := ret[0].(*sagemaker.ListTrialComponentsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListTrialComponents indicates an expected call of ListTrialComponents.
func (mr *MockSageMakerAPIMockRecorder) ListTrialComponents(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTrialComponents", reflect.TypeOf((*MockSageMakerAPI)(nil).ListTrialComponents), arg0)
}

// ListTrialComponentsPages mocks base method.
func (m *MockSageMakerAPI) ListTrialComponentsPages(arg0 *sagemaker.ListTrialComponentsInput, arg1 func(*sagemaker.ListTrialComponentsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListTrialComponentsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListTrialComponentsPages indicates an expected call of ListTrialComponentsPages.
func (mr *MockSageMakerAPIMockRecorder) ListTrialComponentsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTrialComponentsPages", reflect.TypeOf((*MockSageMakerAPI)(nil).ListTrialComponentsPages), arg0, arg1)
}

// ListTrialComponentsPagesWithContext mocks base method.
func (m *MockSageMakerAPI) ListTrialComponentsPagesWithContext(arg0 aws.Context, arg1 *sagemaker.ListTrialComponentsInput, arg2 func(*sagemaker.ListTrialComponentsOutput, 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, "ListTrialComponentsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListTrialComponentsPagesWithContext indicates an expected call of ListTrialComponentsPagesWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListTrialComponentsPagesWithContext(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, "ListTrialComponentsPagesWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListTrialComponentsPagesWithContext), varargs...)
}

// ListTrialComponentsRequest mocks base method.
func (m *MockSageMakerAPI) ListTrialComponentsRequest(arg0 *sagemaker.ListTrialComponentsInput) (*request.Request, *sagemaker.ListTrialComponentsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListTrialComponentsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.ListTrialComponentsOutput)
	return ret0, ret1
}

// ListTrialComponentsRequest indicates an expected call of ListTrialComponentsRequest.
func (mr *MockSageMakerAPIMockRecorder) ListTrialComponentsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTrialComponentsRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).ListTrialComponentsRequest), arg0)
}

// ListTrialComponentsWithContext mocks base method.
func (m *MockSageMakerAPI) ListTrialComponentsWithContext(arg0 aws.Context, arg1 *sagemaker.ListTrialComponentsInput, arg2 ...request.Option) (*sagemaker.ListTrialComponentsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListTrialComponentsWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.ListTrialComponentsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListTrialComponentsWithContext indicates an expected call of ListTrialComponentsWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListTrialComponentsWithContext(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, "ListTrialComponentsWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListTrialComponentsWithContext), varargs...)
}

// ListTrials mocks base method.
func (m *MockSageMakerAPI) ListTrials(arg0 *sagemaker.ListTrialsInput) (*sagemaker.ListTrialsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListTrials", arg0)
	ret0, _ := ret[0].(*sagemaker.ListTrialsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListTrials indicates an expected call of ListTrials.
func (mr *MockSageMakerAPIMockRecorder) ListTrials(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTrials", reflect.TypeOf((*MockSageMakerAPI)(nil).ListTrials), arg0)
}

// ListTrialsPages mocks base method.
func (m *MockSageMakerAPI) ListTrialsPages(arg0 *sagemaker.ListTrialsInput, arg1 func(*sagemaker.ListTrialsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListTrialsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListTrialsPages indicates an expected call of ListTrialsPages.
func (mr *MockSageMakerAPIMockRecorder) ListTrialsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTrialsPages", reflect.TypeOf((*MockSageMakerAPI)(nil).ListTrialsPages), arg0, arg1)
}

// ListTrialsPagesWithContext mocks base method.
func (m *MockSageMakerAPI) ListTrialsPagesWithContext(arg0 aws.Context, arg1 *sagemaker.ListTrialsInput, arg2 func(*sagemaker.ListTrialsOutput, 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, "ListTrialsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListTrialsPagesWithContext indicates an expected call of ListTrialsPagesWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListTrialsPagesWithContext(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, "ListTrialsPagesWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListTrialsPagesWithContext), varargs...)
}

// ListTrialsRequest mocks base method.
func (m *MockSageMakerAPI) ListTrialsRequest(arg0 *sagemaker.ListTrialsInput) (*request.Request, *sagemaker.ListTrialsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListTrialsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.ListTrialsOutput)
	return ret0, ret1
}

// ListTrialsRequest indicates an expected call of ListTrialsRequest.
func (mr *MockSageMakerAPIMockRecorder) ListTrialsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTrialsRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).ListTrialsRequest), arg0)
}

// ListTrialsWithContext mocks base method.
func (m *MockSageMakerAPI) ListTrialsWithContext(arg0 aws.Context, arg1 *sagemaker.ListTrialsInput, arg2 ...request.Option) (*sagemaker.ListTrialsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListTrialsWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.ListTrialsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListTrialsWithContext indicates an expected call of ListTrialsWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListTrialsWithContext(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, "ListTrialsWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListTrialsWithContext), varargs...)
}

// ListUserProfiles mocks base method.
func (m *MockSageMakerAPI) ListUserProfiles(arg0 *sagemaker.ListUserProfilesInput) (*sagemaker.ListUserProfilesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListUserProfiles", arg0)
	ret0, _ := ret[0].(*sagemaker.ListUserProfilesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListUserProfiles indicates an expected call of ListUserProfiles.
func (mr *MockSageMakerAPIMockRecorder) ListUserProfiles(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListUserProfiles", reflect.TypeOf((*MockSageMakerAPI)(nil).ListUserProfiles), arg0)
}

// ListUserProfilesPages mocks base method.
func (m *MockSageMakerAPI) ListUserProfilesPages(arg0 *sagemaker.ListUserProfilesInput, arg1 func(*sagemaker.ListUserProfilesOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListUserProfilesPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListUserProfilesPages indicates an expected call of ListUserProfilesPages.
func (mr *MockSageMakerAPIMockRecorder) ListUserProfilesPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListUserProfilesPages", reflect.TypeOf((*MockSageMakerAPI)(nil).ListUserProfilesPages), arg0, arg1)
}

// ListUserProfilesPagesWithContext mocks base method.
func (m *MockSageMakerAPI) ListUserProfilesPagesWithContext(arg0 aws.Context, arg1 *sagemaker.ListUserProfilesInput, arg2 func(*sagemaker.ListUserProfilesOutput, 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, "ListUserProfilesPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListUserProfilesPagesWithContext indicates an expected call of ListUserProfilesPagesWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListUserProfilesPagesWithContext(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, "ListUserProfilesPagesWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListUserProfilesPagesWithContext), varargs...)
}

// ListUserProfilesRequest mocks base method.
func (m *MockSageMakerAPI) ListUserProfilesRequest(arg0 *sagemaker.ListUserProfilesInput) (*request.Request, *sagemaker.ListUserProfilesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListUserProfilesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.ListUserProfilesOutput)
	return ret0, ret1
}

// ListUserProfilesRequest indicates an expected call of ListUserProfilesRequest.
func (mr *MockSageMakerAPIMockRecorder) ListUserProfilesRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListUserProfilesRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).ListUserProfilesRequest), arg0)
}

// ListUserProfilesWithContext mocks base method.
func (m *MockSageMakerAPI) ListUserProfilesWithContext(arg0 aws.Context, arg1 *sagemaker.ListUserProfilesInput, arg2 ...request.Option) (*sagemaker.ListUserProfilesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListUserProfilesWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.ListUserProfilesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListUserProfilesWithContext indicates an expected call of ListUserProfilesWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListUserProfilesWithContext(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, "ListUserProfilesWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListUserProfilesWithContext), varargs...)
}

// ListWorkforces mocks base method.
func (m *MockSageMakerAPI) ListWorkforces(arg0 *sagemaker.ListWorkforcesInput) (*sagemaker.ListWorkforcesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListWorkforces", arg0)
	ret0, _ := ret[0].(*sagemaker.ListWorkforcesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListWorkforces indicates an expected call of ListWorkforces.
func (mr *MockSageMakerAPIMockRecorder) ListWorkforces(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListWorkforces", reflect.TypeOf((*MockSageMakerAPI)(nil).ListWorkforces), arg0)
}

// ListWorkforcesPages mocks base method.
func (m *MockSageMakerAPI) ListWorkforcesPages(arg0 *sagemaker.ListWorkforcesInput, arg1 func(*sagemaker.ListWorkforcesOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListWorkforcesPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListWorkforcesPages indicates an expected call of ListWorkforcesPages.
func (mr *MockSageMakerAPIMockRecorder) ListWorkforcesPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListWorkforcesPages", reflect.TypeOf((*MockSageMakerAPI)(nil).ListWorkforcesPages), arg0, arg1)
}

// ListWorkforcesPagesWithContext mocks base method.
func (m *MockSageMakerAPI) ListWorkforcesPagesWithContext(arg0 aws.Context, arg1 *sagemaker.ListWorkforcesInput, arg2 func(*sagemaker.ListWorkforcesOutput, 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, "ListWorkforcesPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListWorkforcesPagesWithContext indicates an expected call of ListWorkforcesPagesWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListWorkforcesPagesWithContext(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, "ListWorkforcesPagesWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListWorkforcesPagesWithContext), varargs...)
}

// ListWorkforcesRequest mocks base method.
func (m *MockSageMakerAPI) ListWorkforcesRequest(arg0 *sagemaker.ListWorkforcesInput) (*request.Request, *sagemaker.ListWorkforcesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListWorkforcesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.ListWorkforcesOutput)
	return ret0, ret1
}

// ListWorkforcesRequest indicates an expected call of ListWorkforcesRequest.
func (mr *MockSageMakerAPIMockRecorder) ListWorkforcesRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListWorkforcesRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).ListWorkforcesRequest), arg0)
}

// ListWorkforcesWithContext mocks base method.
func (m *MockSageMakerAPI) ListWorkforcesWithContext(arg0 aws.Context, arg1 *sagemaker.ListWorkforcesInput, arg2 ...request.Option) (*sagemaker.ListWorkforcesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListWorkforcesWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.ListWorkforcesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListWorkforcesWithContext indicates an expected call of ListWorkforcesWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListWorkforcesWithContext(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, "ListWorkforcesWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListWorkforcesWithContext), varargs...)
}

// ListWorkteams mocks base method.
func (m *MockSageMakerAPI) ListWorkteams(arg0 *sagemaker.ListWorkteamsInput) (*sagemaker.ListWorkteamsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListWorkteams", arg0)
	ret0, _ := ret[0].(*sagemaker.ListWorkteamsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListWorkteams indicates an expected call of ListWorkteams.
func (mr *MockSageMakerAPIMockRecorder) ListWorkteams(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListWorkteams", reflect.TypeOf((*MockSageMakerAPI)(nil).ListWorkteams), arg0)
}

// ListWorkteamsPages mocks base method.
func (m *MockSageMakerAPI) ListWorkteamsPages(arg0 *sagemaker.ListWorkteamsInput, arg1 func(*sagemaker.ListWorkteamsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListWorkteamsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListWorkteamsPages indicates an expected call of ListWorkteamsPages.
func (mr *MockSageMakerAPIMockRecorder) ListWorkteamsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListWorkteamsPages", reflect.TypeOf((*MockSageMakerAPI)(nil).ListWorkteamsPages), arg0, arg1)
}

// ListWorkteamsPagesWithContext mocks base method.
func (m *MockSageMakerAPI) ListWorkteamsPagesWithContext(arg0 aws.Context, arg1 *sagemaker.ListWorkteamsInput, arg2 func(*sagemaker.ListWorkteamsOutput, 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, "ListWorkteamsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListWorkteamsPagesWithContext indicates an expected call of ListWorkteamsPagesWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListWorkteamsPagesWithContext(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, "ListWorkteamsPagesWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListWorkteamsPagesWithContext), varargs...)
}

// ListWorkteamsRequest mocks base method.
func (m *MockSageMakerAPI) ListWorkteamsRequest(arg0 *sagemaker.ListWorkteamsInput) (*request.Request, *sagemaker.ListWorkteamsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListWorkteamsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.ListWorkteamsOutput)
	return ret0, ret1
}

// ListWorkteamsRequest indicates an expected call of ListWorkteamsRequest.
func (mr *MockSageMakerAPIMockRecorder) ListWorkteamsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListWorkteamsRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).ListWorkteamsRequest), arg0)
}

// ListWorkteamsWithContext mocks base method.
func (m *MockSageMakerAPI) ListWorkteamsWithContext(arg0 aws.Context, arg1 *sagemaker.ListWorkteamsInput, arg2 ...request.Option) (*sagemaker.ListWorkteamsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListWorkteamsWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.ListWorkteamsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListWorkteamsWithContext indicates an expected call of ListWorkteamsWithContext.
func (mr *MockSageMakerAPIMockRecorder) ListWorkteamsWithContext(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, "ListWorkteamsWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).ListWorkteamsWithContext), varargs...)
}

// PutModelPackageGroupPolicy mocks base method.
func (m *MockSageMakerAPI) PutModelPackageGroupPolicy(arg0 *sagemaker.PutModelPackageGroupPolicyInput) (*sagemaker.PutModelPackageGroupPolicyOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutModelPackageGroupPolicy", arg0)
	ret0, _ := ret[0].(*sagemaker.PutModelPackageGroupPolicyOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PutModelPackageGroupPolicy indicates an expected call of PutModelPackageGroupPolicy.
func (mr *MockSageMakerAPIMockRecorder) PutModelPackageGroupPolicy(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutModelPackageGroupPolicy", reflect.TypeOf((*MockSageMakerAPI)(nil).PutModelPackageGroupPolicy), arg0)
}

// PutModelPackageGroupPolicyRequest mocks base method.
func (m *MockSageMakerAPI) PutModelPackageGroupPolicyRequest(arg0 *sagemaker.PutModelPackageGroupPolicyInput) (*request.Request, *sagemaker.PutModelPackageGroupPolicyOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutModelPackageGroupPolicyRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.PutModelPackageGroupPolicyOutput)
	return ret0, ret1
}

// PutModelPackageGroupPolicyRequest indicates an expected call of PutModelPackageGroupPolicyRequest.
func (mr *MockSageMakerAPIMockRecorder) PutModelPackageGroupPolicyRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutModelPackageGroupPolicyRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).PutModelPackageGroupPolicyRequest), arg0)
}

// PutModelPackageGroupPolicyWithContext mocks base method.
func (m *MockSageMakerAPI) PutModelPackageGroupPolicyWithContext(arg0 aws.Context, arg1 *sagemaker.PutModelPackageGroupPolicyInput, arg2 ...request.Option) (*sagemaker.PutModelPackageGroupPolicyOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PutModelPackageGroupPolicyWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.PutModelPackageGroupPolicyOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PutModelPackageGroupPolicyWithContext indicates an expected call of PutModelPackageGroupPolicyWithContext.
func (mr *MockSageMakerAPIMockRecorder) PutModelPackageGroupPolicyWithContext(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, "PutModelPackageGroupPolicyWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).PutModelPackageGroupPolicyWithContext), varargs...)
}

// QueryLineage mocks base method.
func (m *MockSageMakerAPI) QueryLineage(arg0 *sagemaker.QueryLineageInput) (*sagemaker.QueryLineageOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "QueryLineage", arg0)
	ret0, _ := ret[0].(*sagemaker.QueryLineageOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// QueryLineage indicates an expected call of QueryLineage.
func (mr *MockSageMakerAPIMockRecorder) QueryLineage(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryLineage", reflect.TypeOf((*MockSageMakerAPI)(nil).QueryLineage), arg0)
}

// QueryLineagePages mocks base method.
func (m *MockSageMakerAPI) QueryLineagePages(arg0 *sagemaker.QueryLineageInput, arg1 func(*sagemaker.QueryLineageOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "QueryLineagePages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// QueryLineagePages indicates an expected call of QueryLineagePages.
func (mr *MockSageMakerAPIMockRecorder) QueryLineagePages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryLineagePages", reflect.TypeOf((*MockSageMakerAPI)(nil).QueryLineagePages), arg0, arg1)
}

// QueryLineagePagesWithContext mocks base method.
func (m *MockSageMakerAPI) QueryLineagePagesWithContext(arg0 aws.Context, arg1 *sagemaker.QueryLineageInput, arg2 func(*sagemaker.QueryLineageOutput, 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, "QueryLineagePagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// QueryLineagePagesWithContext indicates an expected call of QueryLineagePagesWithContext.
func (mr *MockSageMakerAPIMockRecorder) QueryLineagePagesWithContext(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, "QueryLineagePagesWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).QueryLineagePagesWithContext), varargs...)
}

// QueryLineageRequest mocks base method.
func (m *MockSageMakerAPI) QueryLineageRequest(arg0 *sagemaker.QueryLineageInput) (*request.Request, *sagemaker.QueryLineageOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "QueryLineageRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.QueryLineageOutput)
	return ret0, ret1
}

// QueryLineageRequest indicates an expected call of QueryLineageRequest.
func (mr *MockSageMakerAPIMockRecorder) QueryLineageRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryLineageRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).QueryLineageRequest), arg0)
}

// QueryLineageWithContext mocks base method.
func (m *MockSageMakerAPI) QueryLineageWithContext(arg0 aws.Context, arg1 *sagemaker.QueryLineageInput, arg2 ...request.Option) (*sagemaker.QueryLineageOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "QueryLineageWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.QueryLineageOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// QueryLineageWithContext indicates an expected call of QueryLineageWithContext.
func (mr *MockSageMakerAPIMockRecorder) QueryLineageWithContext(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, "QueryLineageWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).QueryLineageWithContext), varargs...)
}

// RegisterDevices mocks base method.
func (m *MockSageMakerAPI) RegisterDevices(arg0 *sagemaker.RegisterDevicesInput) (*sagemaker.RegisterDevicesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RegisterDevices", arg0)
	ret0, _ := ret[0].(*sagemaker.RegisterDevicesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RegisterDevices indicates an expected call of RegisterDevices.
func (mr *MockSageMakerAPIMockRecorder) RegisterDevices(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterDevices", reflect.TypeOf((*MockSageMakerAPI)(nil).RegisterDevices), arg0)
}

// RegisterDevicesRequest mocks base method.
func (m *MockSageMakerAPI) RegisterDevicesRequest(arg0 *sagemaker.RegisterDevicesInput) (*request.Request, *sagemaker.RegisterDevicesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RegisterDevicesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.RegisterDevicesOutput)
	return ret0, ret1
}

// RegisterDevicesRequest indicates an expected call of RegisterDevicesRequest.
func (mr *MockSageMakerAPIMockRecorder) RegisterDevicesRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterDevicesRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).RegisterDevicesRequest), arg0)
}

// RegisterDevicesWithContext mocks base method.
func (m *MockSageMakerAPI) RegisterDevicesWithContext(arg0 aws.Context, arg1 *sagemaker.RegisterDevicesInput, arg2 ...request.Option) (*sagemaker.RegisterDevicesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RegisterDevicesWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.RegisterDevicesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RegisterDevicesWithContext indicates an expected call of RegisterDevicesWithContext.
func (mr *MockSageMakerAPIMockRecorder) RegisterDevicesWithContext(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, "RegisterDevicesWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).RegisterDevicesWithContext), varargs...)
}

// RenderUiTemplate mocks base method.
func (m *MockSageMakerAPI) RenderUiTemplate(arg0 *sagemaker.RenderUiTemplateInput) (*sagemaker.RenderUiTemplateOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RenderUiTemplate", arg0)
	ret0, _ := ret[0].(*sagemaker.RenderUiTemplateOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RenderUiTemplate indicates an expected call of RenderUiTemplate.
func (mr *MockSageMakerAPIMockRecorder) RenderUiTemplate(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RenderUiTemplate", reflect.TypeOf((*MockSageMakerAPI)(nil).RenderUiTemplate), arg0)
}

// RenderUiTemplateRequest mocks base method.
func (m *MockSageMakerAPI) RenderUiTemplateRequest(arg0 *sagemaker.RenderUiTemplateInput) (*request.Request, *sagemaker.RenderUiTemplateOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RenderUiTemplateRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.RenderUiTemplateOutput)
	return ret0, ret1
}

// RenderUiTemplateRequest indicates an expected call of RenderUiTemplateRequest.
func (mr *MockSageMakerAPIMockRecorder) RenderUiTemplateRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RenderUiTemplateRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).RenderUiTemplateRequest), arg0)
}

// RenderUiTemplateWithContext mocks base method.
func (m *MockSageMakerAPI) RenderUiTemplateWithContext(arg0 aws.Context, arg1 *sagemaker.RenderUiTemplateInput, arg2 ...request.Option) (*sagemaker.RenderUiTemplateOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RenderUiTemplateWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.RenderUiTemplateOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RenderUiTemplateWithContext indicates an expected call of RenderUiTemplateWithContext.
func (mr *MockSageMakerAPIMockRecorder) RenderUiTemplateWithContext(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, "RenderUiTemplateWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).RenderUiTemplateWithContext), varargs...)
}

// RetryPipelineExecution mocks base method.
func (m *MockSageMakerAPI) RetryPipelineExecution(arg0 *sagemaker.RetryPipelineExecutionInput) (*sagemaker.RetryPipelineExecutionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RetryPipelineExecution", arg0)
	ret0, _ := ret[0].(*sagemaker.RetryPipelineExecutionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RetryPipelineExecution indicates an expected call of RetryPipelineExecution.
func (mr *MockSageMakerAPIMockRecorder) RetryPipelineExecution(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RetryPipelineExecution", reflect.TypeOf((*MockSageMakerAPI)(nil).RetryPipelineExecution), arg0)
}

// RetryPipelineExecutionRequest mocks base method.
func (m *MockSageMakerAPI) RetryPipelineExecutionRequest(arg0 *sagemaker.RetryPipelineExecutionInput) (*request.Request, *sagemaker.RetryPipelineExecutionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RetryPipelineExecutionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.RetryPipelineExecutionOutput)
	return ret0, ret1
}

// RetryPipelineExecutionRequest indicates an expected call of RetryPipelineExecutionRequest.
func (mr *MockSageMakerAPIMockRecorder) RetryPipelineExecutionRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RetryPipelineExecutionRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).RetryPipelineExecutionRequest), arg0)
}

// RetryPipelineExecutionWithContext mocks base method.
func (m *MockSageMakerAPI) RetryPipelineExecutionWithContext(arg0 aws.Context, arg1 *sagemaker.RetryPipelineExecutionInput, arg2 ...request.Option) (*sagemaker.RetryPipelineExecutionOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RetryPipelineExecutionWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.RetryPipelineExecutionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RetryPipelineExecutionWithContext indicates an expected call of RetryPipelineExecutionWithContext.
func (mr *MockSageMakerAPIMockRecorder) RetryPipelineExecutionWithContext(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, "RetryPipelineExecutionWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).RetryPipelineExecutionWithContext), varargs...)
}

// Search mocks base method.
func (m *MockSageMakerAPI) Search(arg0 *sagemaker.SearchInput) (*sagemaker.SearchOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Search", arg0)
	ret0, _ := ret[0].(*sagemaker.SearchOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Search indicates an expected call of Search.
func (mr *MockSageMakerAPIMockRecorder) Search(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Search", reflect.TypeOf((*MockSageMakerAPI)(nil).Search), arg0)
}

// SearchPages mocks base method.
func (m *MockSageMakerAPI) SearchPages(arg0 *sagemaker.SearchInput, arg1 func(*sagemaker.SearchOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SearchPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// SearchPages indicates an expected call of SearchPages.
func (mr *MockSageMakerAPIMockRecorder) SearchPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchPages", reflect.TypeOf((*MockSageMakerAPI)(nil).SearchPages), arg0, arg1)
}

// SearchPagesWithContext mocks base method.
func (m *MockSageMakerAPI) SearchPagesWithContext(arg0 aws.Context, arg1 *sagemaker.SearchInput, arg2 func(*sagemaker.SearchOutput, 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, "SearchPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// SearchPagesWithContext indicates an expected call of SearchPagesWithContext.
func (mr *MockSageMakerAPIMockRecorder) SearchPagesWithContext(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, "SearchPagesWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).SearchPagesWithContext), varargs...)
}

// SearchRequest mocks base method.
func (m *MockSageMakerAPI) SearchRequest(arg0 *sagemaker.SearchInput) (*request.Request, *sagemaker.SearchOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SearchRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.SearchOutput)
	return ret0, ret1
}

// SearchRequest indicates an expected call of SearchRequest.
func (mr *MockSageMakerAPIMockRecorder) SearchRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).SearchRequest), arg0)
}

// SearchWithContext mocks base method.
func (m *MockSageMakerAPI) SearchWithContext(arg0 aws.Context, arg1 *sagemaker.SearchInput, arg2 ...request.Option) (*sagemaker.SearchOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SearchWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.SearchOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SearchWithContext indicates an expected call of SearchWithContext.
func (mr *MockSageMakerAPIMockRecorder) SearchWithContext(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, "SearchWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).SearchWithContext), varargs...)
}

// SendPipelineExecutionStepFailure mocks base method.
func (m *MockSageMakerAPI) SendPipelineExecutionStepFailure(arg0 *sagemaker.SendPipelineExecutionStepFailureInput) (*sagemaker.SendPipelineExecutionStepFailureOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SendPipelineExecutionStepFailure", arg0)
	ret0, _ := ret[0].(*sagemaker.SendPipelineExecutionStepFailureOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SendPipelineExecutionStepFailure indicates an expected call of SendPipelineExecutionStepFailure.
func (mr *MockSageMakerAPIMockRecorder) SendPipelineExecutionStepFailure(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendPipelineExecutionStepFailure", reflect.TypeOf((*MockSageMakerAPI)(nil).SendPipelineExecutionStepFailure), arg0)
}

// SendPipelineExecutionStepFailureRequest mocks base method.
func (m *MockSageMakerAPI) SendPipelineExecutionStepFailureRequest(arg0 *sagemaker.SendPipelineExecutionStepFailureInput) (*request.Request, *sagemaker.SendPipelineExecutionStepFailureOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SendPipelineExecutionStepFailureRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.SendPipelineExecutionStepFailureOutput)
	return ret0, ret1
}

// SendPipelineExecutionStepFailureRequest indicates an expected call of SendPipelineExecutionStepFailureRequest.
func (mr *MockSageMakerAPIMockRecorder) SendPipelineExecutionStepFailureRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendPipelineExecutionStepFailureRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).SendPipelineExecutionStepFailureRequest), arg0)
}

// SendPipelineExecutionStepFailureWithContext mocks base method.
func (m *MockSageMakerAPI) SendPipelineExecutionStepFailureWithContext(arg0 aws.Context, arg1 *sagemaker.SendPipelineExecutionStepFailureInput, arg2 ...request.Option) (*sagemaker.SendPipelineExecutionStepFailureOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SendPipelineExecutionStepFailureWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.SendPipelineExecutionStepFailureOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SendPipelineExecutionStepFailureWithContext indicates an expected call of SendPipelineExecutionStepFailureWithContext.
func (mr *MockSageMakerAPIMockRecorder) SendPipelineExecutionStepFailureWithContext(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, "SendPipelineExecutionStepFailureWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).SendPipelineExecutionStepFailureWithContext), varargs...)
}

// SendPipelineExecutionStepSuccess mocks base method.
func (m *MockSageMakerAPI) SendPipelineExecutionStepSuccess(arg0 *sagemaker.SendPipelineExecutionStepSuccessInput) (*sagemaker.SendPipelineExecutionStepSuccessOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SendPipelineExecutionStepSuccess", arg0)
	ret0, _ := ret[0].(*sagemaker.SendPipelineExecutionStepSuccessOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SendPipelineExecutionStepSuccess indicates an expected call of SendPipelineExecutionStepSuccess.
func (mr *MockSageMakerAPIMockRecorder) SendPipelineExecutionStepSuccess(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendPipelineExecutionStepSuccess", reflect.TypeOf((*MockSageMakerAPI)(nil).SendPipelineExecutionStepSuccess), arg0)
}

// SendPipelineExecutionStepSuccessRequest mocks base method.
func (m *MockSageMakerAPI) SendPipelineExecutionStepSuccessRequest(arg0 *sagemaker.SendPipelineExecutionStepSuccessInput) (*request.Request, *sagemaker.SendPipelineExecutionStepSuccessOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SendPipelineExecutionStepSuccessRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.SendPipelineExecutionStepSuccessOutput)
	return ret0, ret1
}

// SendPipelineExecutionStepSuccessRequest indicates an expected call of SendPipelineExecutionStepSuccessRequest.
func (mr *MockSageMakerAPIMockRecorder) SendPipelineExecutionStepSuccessRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendPipelineExecutionStepSuccessRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).SendPipelineExecutionStepSuccessRequest), arg0)
}

// SendPipelineExecutionStepSuccessWithContext mocks base method.
func (m *MockSageMakerAPI) SendPipelineExecutionStepSuccessWithContext(arg0 aws.Context, arg1 *sagemaker.SendPipelineExecutionStepSuccessInput, arg2 ...request.Option) (*sagemaker.SendPipelineExecutionStepSuccessOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SendPipelineExecutionStepSuccessWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.SendPipelineExecutionStepSuccessOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SendPipelineExecutionStepSuccessWithContext indicates an expected call of SendPipelineExecutionStepSuccessWithContext.
func (mr *MockSageMakerAPIMockRecorder) SendPipelineExecutionStepSuccessWithContext(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, "SendPipelineExecutionStepSuccessWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).SendPipelineExecutionStepSuccessWithContext), varargs...)
}

// StartEdgeDeploymentStage mocks base method.
func (m *MockSageMakerAPI) StartEdgeDeploymentStage(arg0 *sagemaker.StartEdgeDeploymentStageInput) (*sagemaker.StartEdgeDeploymentStageOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StartEdgeDeploymentStage", arg0)
	ret0, _ := ret[0].(*sagemaker.StartEdgeDeploymentStageOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// StartEdgeDeploymentStage indicates an expected call of StartEdgeDeploymentStage.
func (mr *MockSageMakerAPIMockRecorder) StartEdgeDeploymentStage(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartEdgeDeploymentStage", reflect.TypeOf((*MockSageMakerAPI)(nil).StartEdgeDeploymentStage), arg0)
}

// StartEdgeDeploymentStageRequest mocks base method.
func (m *MockSageMakerAPI) StartEdgeDeploymentStageRequest(arg0 *sagemaker.StartEdgeDeploymentStageInput) (*request.Request, *sagemaker.StartEdgeDeploymentStageOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StartEdgeDeploymentStageRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.StartEdgeDeploymentStageOutput)
	return ret0, ret1
}

// StartEdgeDeploymentStageRequest indicates an expected call of StartEdgeDeploymentStageRequest.
func (mr *MockSageMakerAPIMockRecorder) StartEdgeDeploymentStageRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartEdgeDeploymentStageRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).StartEdgeDeploymentStageRequest), arg0)
}

// StartEdgeDeploymentStageWithContext mocks base method.
func (m *MockSageMakerAPI) StartEdgeDeploymentStageWithContext(arg0 aws.Context, arg1 *sagemaker.StartEdgeDeploymentStageInput, arg2 ...request.Option) (*sagemaker.StartEdgeDeploymentStageOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "StartEdgeDeploymentStageWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.StartEdgeDeploymentStageOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// StartEdgeDeploymentStageWithContext indicates an expected call of StartEdgeDeploymentStageWithContext.
func (mr *MockSageMakerAPIMockRecorder) StartEdgeDeploymentStageWithContext(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, "StartEdgeDeploymentStageWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).StartEdgeDeploymentStageWithContext), varargs...)
}

// StartInferenceExperiment mocks base method.
func (m *MockSageMakerAPI) StartInferenceExperiment(arg0 *sagemaker.StartInferenceExperimentInput) (*sagemaker.StartInferenceExperimentOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StartInferenceExperiment", arg0)
	ret0, _ := ret[0].(*sagemaker.StartInferenceExperimentOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// StartInferenceExperiment indicates an expected call of StartInferenceExperiment.
func (mr *MockSageMakerAPIMockRecorder) StartInferenceExperiment(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartInferenceExperiment", reflect.TypeOf((*MockSageMakerAPI)(nil).StartInferenceExperiment), arg0)
}

// StartInferenceExperimentRequest mocks base method.
func (m *MockSageMakerAPI) StartInferenceExperimentRequest(arg0 *sagemaker.StartInferenceExperimentInput) (*request.Request, *sagemaker.StartInferenceExperimentOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StartInferenceExperimentRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.StartInferenceExperimentOutput)
	return ret0, ret1
}

// StartInferenceExperimentRequest indicates an expected call of StartInferenceExperimentRequest.
func (mr *MockSageMakerAPIMockRecorder) StartInferenceExperimentRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartInferenceExperimentRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).StartInferenceExperimentRequest), arg0)
}

// StartInferenceExperimentWithContext mocks base method.
func (m *MockSageMakerAPI) StartInferenceExperimentWithContext(arg0 aws.Context, arg1 *sagemaker.StartInferenceExperimentInput, arg2 ...request.Option) (*sagemaker.StartInferenceExperimentOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "StartInferenceExperimentWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.StartInferenceExperimentOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// StartInferenceExperimentWithContext indicates an expected call of StartInferenceExperimentWithContext.
func (mr *MockSageMakerAPIMockRecorder) StartInferenceExperimentWithContext(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, "StartInferenceExperimentWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).StartInferenceExperimentWithContext), varargs...)
}

// StartMlflowTrackingServer mocks base method.
func (m *MockSageMakerAPI) StartMlflowTrackingServer(arg0 *sagemaker.StartMlflowTrackingServerInput) (*sagemaker.StartMlflowTrackingServerOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StartMlflowTrackingServer", arg0)
	ret0, _ := ret[0].(*sagemaker.StartMlflowTrackingServerOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// StartMlflowTrackingServer indicates an expected call of StartMlflowTrackingServer.
func (mr *MockSageMakerAPIMockRecorder) StartMlflowTrackingServer(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartMlflowTrackingServer", reflect.TypeOf((*MockSageMakerAPI)(nil).StartMlflowTrackingServer), arg0)
}

// StartMlflowTrackingServerRequest mocks base method.
func (m *MockSageMakerAPI) StartMlflowTrackingServerRequest(arg0 *sagemaker.StartMlflowTrackingServerInput) (*request.Request, *sagemaker.StartMlflowTrackingServerOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StartMlflowTrackingServerRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.StartMlflowTrackingServerOutput)
	return ret0, ret1
}

// StartMlflowTrackingServerRequest indicates an expected call of StartMlflowTrackingServerRequest.
func (mr *MockSageMakerAPIMockRecorder) StartMlflowTrackingServerRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartMlflowTrackingServerRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).StartMlflowTrackingServerRequest), arg0)
}

// StartMlflowTrackingServerWithContext mocks base method.
func (m *MockSageMakerAPI) StartMlflowTrackingServerWithContext(arg0 aws.Context, arg1 *sagemaker.StartMlflowTrackingServerInput, arg2 ...request.Option) (*sagemaker.StartMlflowTrackingServerOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "StartMlflowTrackingServerWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.StartMlflowTrackingServerOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// StartMlflowTrackingServerWithContext indicates an expected call of StartMlflowTrackingServerWithContext.
func (mr *MockSageMakerAPIMockRecorder) StartMlflowTrackingServerWithContext(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, "StartMlflowTrackingServerWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).StartMlflowTrackingServerWithContext), varargs...)
}

// StartMonitoringSchedule mocks base method.
func (m *MockSageMakerAPI) StartMonitoringSchedule(arg0 *sagemaker.StartMonitoringScheduleInput) (*sagemaker.StartMonitoringScheduleOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StartMonitoringSchedule", arg0)
	ret0, _ := ret[0].(*sagemaker.StartMonitoringScheduleOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// StartMonitoringSchedule indicates an expected call of StartMonitoringSchedule.
func (mr *MockSageMakerAPIMockRecorder) StartMonitoringSchedule(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartMonitoringSchedule", reflect.TypeOf((*MockSageMakerAPI)(nil).StartMonitoringSchedule), arg0)
}

// StartMonitoringScheduleRequest mocks base method.
func (m *MockSageMakerAPI) StartMonitoringScheduleRequest(arg0 *sagemaker.StartMonitoringScheduleInput) (*request.Request, *sagemaker.StartMonitoringScheduleOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StartMonitoringScheduleRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.StartMonitoringScheduleOutput)
	return ret0, ret1
}

// StartMonitoringScheduleRequest indicates an expected call of StartMonitoringScheduleRequest.
func (mr *MockSageMakerAPIMockRecorder) StartMonitoringScheduleRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartMonitoringScheduleRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).StartMonitoringScheduleRequest), arg0)
}

// StartMonitoringScheduleWithContext mocks base method.
func (m *MockSageMakerAPI) StartMonitoringScheduleWithContext(arg0 aws.Context, arg1 *sagemaker.StartMonitoringScheduleInput, arg2 ...request.Option) (*sagemaker.StartMonitoringScheduleOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "StartMonitoringScheduleWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.StartMonitoringScheduleOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// StartMonitoringScheduleWithContext indicates an expected call of StartMonitoringScheduleWithContext.
func (mr *MockSageMakerAPIMockRecorder) StartMonitoringScheduleWithContext(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, "StartMonitoringScheduleWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).StartMonitoringScheduleWithContext), varargs...)
}

// StartNotebookInstance mocks base method.
func (m *MockSageMakerAPI) StartNotebookInstance(arg0 *sagemaker.StartNotebookInstanceInput) (*sagemaker.StartNotebookInstanceOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StartNotebookInstance", arg0)
	ret0, _ := ret[0].(*sagemaker.StartNotebookInstanceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// StartNotebookInstance indicates an expected call of StartNotebookInstance.
func (mr *MockSageMakerAPIMockRecorder) StartNotebookInstance(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartNotebookInstance", reflect.TypeOf((*MockSageMakerAPI)(nil).StartNotebookInstance), arg0)
}

// StartNotebookInstanceRequest mocks base method.
func (m *MockSageMakerAPI) StartNotebookInstanceRequest(arg0 *sagemaker.StartNotebookInstanceInput) (*request.Request, *sagemaker.StartNotebookInstanceOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StartNotebookInstanceRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.StartNotebookInstanceOutput)
	return ret0, ret1
}

// StartNotebookInstanceRequest indicates an expected call of StartNotebookInstanceRequest.
func (mr *MockSageMakerAPIMockRecorder) StartNotebookInstanceRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartNotebookInstanceRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).StartNotebookInstanceRequest), arg0)
}

// StartNotebookInstanceWithContext mocks base method.
func (m *MockSageMakerAPI) StartNotebookInstanceWithContext(arg0 aws.Context, arg1 *sagemaker.StartNotebookInstanceInput, arg2 ...request.Option) (*sagemaker.StartNotebookInstanceOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "StartNotebookInstanceWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.StartNotebookInstanceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// StartNotebookInstanceWithContext indicates an expected call of StartNotebookInstanceWithContext.
func (mr *MockSageMakerAPIMockRecorder) StartNotebookInstanceWithContext(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, "StartNotebookInstanceWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).StartNotebookInstanceWithContext), varargs...)
}

// StartPipelineExecution mocks base method.
func (m *MockSageMakerAPI) StartPipelineExecution(arg0 *sagemaker.StartPipelineExecutionInput) (*sagemaker.StartPipelineExecutionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StartPipelineExecution", arg0)
	ret0, _ := ret[0].(*sagemaker.StartPipelineExecutionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// StartPipelineExecution indicates an expected call of StartPipelineExecution.
func (mr *MockSageMakerAPIMockRecorder) StartPipelineExecution(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartPipelineExecution", reflect.TypeOf((*MockSageMakerAPI)(nil).StartPipelineExecution), arg0)
}

// StartPipelineExecutionRequest mocks base method.
func (m *MockSageMakerAPI) StartPipelineExecutionRequest(arg0 *sagemaker.StartPipelineExecutionInput) (*request.Request, *sagemaker.StartPipelineExecutionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StartPipelineExecutionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.StartPipelineExecutionOutput)
	return ret0, ret1
}

// StartPipelineExecutionRequest indicates an expected call of StartPipelineExecutionRequest.
func (mr *MockSageMakerAPIMockRecorder) StartPipelineExecutionRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartPipelineExecutionRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).StartPipelineExecutionRequest), arg0)
}

// StartPipelineExecutionWithContext mocks base method.
func (m *MockSageMakerAPI) StartPipelineExecutionWithContext(arg0 aws.Context, arg1 *sagemaker.StartPipelineExecutionInput, arg2 ...request.Option) (*sagemaker.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].(*sagemaker.StartPipelineExecutionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// StartPipelineExecutionWithContext indicates an expected call of StartPipelineExecutionWithContext.
func (mr *MockSageMakerAPIMockRecorder) 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((*MockSageMakerAPI)(nil).StartPipelineExecutionWithContext), varargs...)
}

// StopAutoMLJob mocks base method.
func (m *MockSageMakerAPI) StopAutoMLJob(arg0 *sagemaker.StopAutoMLJobInput) (*sagemaker.StopAutoMLJobOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StopAutoMLJob", arg0)
	ret0, _ := ret[0].(*sagemaker.StopAutoMLJobOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// StopAutoMLJob indicates an expected call of StopAutoMLJob.
func (mr *MockSageMakerAPIMockRecorder) StopAutoMLJob(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopAutoMLJob", reflect.TypeOf((*MockSageMakerAPI)(nil).StopAutoMLJob), arg0)
}

// StopAutoMLJobRequest mocks base method.
func (m *MockSageMakerAPI) StopAutoMLJobRequest(arg0 *sagemaker.StopAutoMLJobInput) (*request.Request, *sagemaker.StopAutoMLJobOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StopAutoMLJobRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.StopAutoMLJobOutput)
	return ret0, ret1
}

// StopAutoMLJobRequest indicates an expected call of StopAutoMLJobRequest.
func (mr *MockSageMakerAPIMockRecorder) StopAutoMLJobRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopAutoMLJobRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).StopAutoMLJobRequest), arg0)
}

// StopAutoMLJobWithContext mocks base method.
func (m *MockSageMakerAPI) StopAutoMLJobWithContext(arg0 aws.Context, arg1 *sagemaker.StopAutoMLJobInput, arg2 ...request.Option) (*sagemaker.StopAutoMLJobOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "StopAutoMLJobWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.StopAutoMLJobOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// StopAutoMLJobWithContext indicates an expected call of StopAutoMLJobWithContext.
func (mr *MockSageMakerAPIMockRecorder) StopAutoMLJobWithContext(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, "StopAutoMLJobWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).StopAutoMLJobWithContext), varargs...)
}

// StopCompilationJob mocks base method.
func (m *MockSageMakerAPI) StopCompilationJob(arg0 *sagemaker.StopCompilationJobInput) (*sagemaker.StopCompilationJobOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StopCompilationJob", arg0)
	ret0, _ := ret[0].(*sagemaker.StopCompilationJobOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// StopCompilationJob indicates an expected call of StopCompilationJob.
func (mr *MockSageMakerAPIMockRecorder) StopCompilationJob(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopCompilationJob", reflect.TypeOf((*MockSageMakerAPI)(nil).StopCompilationJob), arg0)
}

// StopCompilationJobRequest mocks base method.
func (m *MockSageMakerAPI) StopCompilationJobRequest(arg0 *sagemaker.StopCompilationJobInput) (*request.Request, *sagemaker.StopCompilationJobOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StopCompilationJobRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.StopCompilationJobOutput)
	return ret0, ret1
}

// StopCompilationJobRequest indicates an expected call of StopCompilationJobRequest.
func (mr *MockSageMakerAPIMockRecorder) StopCompilationJobRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopCompilationJobRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).StopCompilationJobRequest), arg0)
}

// StopCompilationJobWithContext mocks base method.
func (m *MockSageMakerAPI) StopCompilationJobWithContext(arg0 aws.Context, arg1 *sagemaker.StopCompilationJobInput, arg2 ...request.Option) (*sagemaker.StopCompilationJobOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "StopCompilationJobWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.StopCompilationJobOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// StopCompilationJobWithContext indicates an expected call of StopCompilationJobWithContext.
func (mr *MockSageMakerAPIMockRecorder) StopCompilationJobWithContext(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, "StopCompilationJobWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).StopCompilationJobWithContext), varargs...)
}

// StopEdgeDeploymentStage mocks base method.
func (m *MockSageMakerAPI) StopEdgeDeploymentStage(arg0 *sagemaker.StopEdgeDeploymentStageInput) (*sagemaker.StopEdgeDeploymentStageOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StopEdgeDeploymentStage", arg0)
	ret0, _ := ret[0].(*sagemaker.StopEdgeDeploymentStageOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// StopEdgeDeploymentStage indicates an expected call of StopEdgeDeploymentStage.
func (mr *MockSageMakerAPIMockRecorder) StopEdgeDeploymentStage(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopEdgeDeploymentStage", reflect.TypeOf((*MockSageMakerAPI)(nil).StopEdgeDeploymentStage), arg0)
}

// StopEdgeDeploymentStageRequest mocks base method.
func (m *MockSageMakerAPI) StopEdgeDeploymentStageRequest(arg0 *sagemaker.StopEdgeDeploymentStageInput) (*request.Request, *sagemaker.StopEdgeDeploymentStageOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StopEdgeDeploymentStageRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.StopEdgeDeploymentStageOutput)
	return ret0, ret1
}

// StopEdgeDeploymentStageRequest indicates an expected call of StopEdgeDeploymentStageRequest.
func (mr *MockSageMakerAPIMockRecorder) StopEdgeDeploymentStageRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopEdgeDeploymentStageRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).StopEdgeDeploymentStageRequest), arg0)
}

// StopEdgeDeploymentStageWithContext mocks base method.
func (m *MockSageMakerAPI) StopEdgeDeploymentStageWithContext(arg0 aws.Context, arg1 *sagemaker.StopEdgeDeploymentStageInput, arg2 ...request.Option) (*sagemaker.StopEdgeDeploymentStageOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "StopEdgeDeploymentStageWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.StopEdgeDeploymentStageOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// StopEdgeDeploymentStageWithContext indicates an expected call of StopEdgeDeploymentStageWithContext.
func (mr *MockSageMakerAPIMockRecorder) StopEdgeDeploymentStageWithContext(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, "StopEdgeDeploymentStageWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).StopEdgeDeploymentStageWithContext), varargs...)
}

// StopEdgePackagingJob mocks base method.
func (m *MockSageMakerAPI) StopEdgePackagingJob(arg0 *sagemaker.StopEdgePackagingJobInput) (*sagemaker.StopEdgePackagingJobOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StopEdgePackagingJob", arg0)
	ret0, _ := ret[0].(*sagemaker.StopEdgePackagingJobOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// StopEdgePackagingJob indicates an expected call of StopEdgePackagingJob.
func (mr *MockSageMakerAPIMockRecorder) StopEdgePackagingJob(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopEdgePackagingJob", reflect.TypeOf((*MockSageMakerAPI)(nil).StopEdgePackagingJob), arg0)
}

// StopEdgePackagingJobRequest mocks base method.
func (m *MockSageMakerAPI) StopEdgePackagingJobRequest(arg0 *sagemaker.StopEdgePackagingJobInput) (*request.Request, *sagemaker.StopEdgePackagingJobOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StopEdgePackagingJobRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.StopEdgePackagingJobOutput)
	return ret0, ret1
}

// StopEdgePackagingJobRequest indicates an expected call of StopEdgePackagingJobRequest.
func (mr *MockSageMakerAPIMockRecorder) StopEdgePackagingJobRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopEdgePackagingJobRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).StopEdgePackagingJobRequest), arg0)
}

// StopEdgePackagingJobWithContext mocks base method.
func (m *MockSageMakerAPI) StopEdgePackagingJobWithContext(arg0 aws.Context, arg1 *sagemaker.StopEdgePackagingJobInput, arg2 ...request.Option) (*sagemaker.StopEdgePackagingJobOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "StopEdgePackagingJobWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.StopEdgePackagingJobOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// StopEdgePackagingJobWithContext indicates an expected call of StopEdgePackagingJobWithContext.
func (mr *MockSageMakerAPIMockRecorder) StopEdgePackagingJobWithContext(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, "StopEdgePackagingJobWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).StopEdgePackagingJobWithContext), varargs...)
}

// StopHyperParameterTuningJob mocks base method.
func (m *MockSageMakerAPI) StopHyperParameterTuningJob(arg0 *sagemaker.StopHyperParameterTuningJobInput) (*sagemaker.StopHyperParameterTuningJobOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StopHyperParameterTuningJob", arg0)
	ret0, _ := ret[0].(*sagemaker.StopHyperParameterTuningJobOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// StopHyperParameterTuningJob indicates an expected call of StopHyperParameterTuningJob.
func (mr *MockSageMakerAPIMockRecorder) StopHyperParameterTuningJob(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopHyperParameterTuningJob", reflect.TypeOf((*MockSageMakerAPI)(nil).StopHyperParameterTuningJob), arg0)
}

// StopHyperParameterTuningJobRequest mocks base method.
func (m *MockSageMakerAPI) StopHyperParameterTuningJobRequest(arg0 *sagemaker.StopHyperParameterTuningJobInput) (*request.Request, *sagemaker.StopHyperParameterTuningJobOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StopHyperParameterTuningJobRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.StopHyperParameterTuningJobOutput)
	return ret0, ret1
}

// StopHyperParameterTuningJobRequest indicates an expected call of StopHyperParameterTuningJobRequest.
func (mr *MockSageMakerAPIMockRecorder) StopHyperParameterTuningJobRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopHyperParameterTuningJobRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).StopHyperParameterTuningJobRequest), arg0)
}

// StopHyperParameterTuningJobWithContext mocks base method.
func (m *MockSageMakerAPI) StopHyperParameterTuningJobWithContext(arg0 aws.Context, arg1 *sagemaker.StopHyperParameterTuningJobInput, arg2 ...request.Option) (*sagemaker.StopHyperParameterTuningJobOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "StopHyperParameterTuningJobWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.StopHyperParameterTuningJobOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// StopHyperParameterTuningJobWithContext indicates an expected call of StopHyperParameterTuningJobWithContext.
func (mr *MockSageMakerAPIMockRecorder) StopHyperParameterTuningJobWithContext(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, "StopHyperParameterTuningJobWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).StopHyperParameterTuningJobWithContext), varargs...)
}

// StopInferenceExperiment mocks base method.
func (m *MockSageMakerAPI) StopInferenceExperiment(arg0 *sagemaker.StopInferenceExperimentInput) (*sagemaker.StopInferenceExperimentOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StopInferenceExperiment", arg0)
	ret0, _ := ret[0].(*sagemaker.StopInferenceExperimentOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// StopInferenceExperiment indicates an expected call of StopInferenceExperiment.
func (mr *MockSageMakerAPIMockRecorder) StopInferenceExperiment(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopInferenceExperiment", reflect.TypeOf((*MockSageMakerAPI)(nil).StopInferenceExperiment), arg0)
}

// StopInferenceExperimentRequest mocks base method.
func (m *MockSageMakerAPI) StopInferenceExperimentRequest(arg0 *sagemaker.StopInferenceExperimentInput) (*request.Request, *sagemaker.StopInferenceExperimentOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StopInferenceExperimentRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.StopInferenceExperimentOutput)
	return ret0, ret1
}

// StopInferenceExperimentRequest indicates an expected call of StopInferenceExperimentRequest.
func (mr *MockSageMakerAPIMockRecorder) StopInferenceExperimentRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopInferenceExperimentRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).StopInferenceExperimentRequest), arg0)
}

// StopInferenceExperimentWithContext mocks base method.
func (m *MockSageMakerAPI) StopInferenceExperimentWithContext(arg0 aws.Context, arg1 *sagemaker.StopInferenceExperimentInput, arg2 ...request.Option) (*sagemaker.StopInferenceExperimentOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "StopInferenceExperimentWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.StopInferenceExperimentOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// StopInferenceExperimentWithContext indicates an expected call of StopInferenceExperimentWithContext.
func (mr *MockSageMakerAPIMockRecorder) StopInferenceExperimentWithContext(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, "StopInferenceExperimentWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).StopInferenceExperimentWithContext), varargs...)
}

// StopInferenceRecommendationsJob mocks base method.
func (m *MockSageMakerAPI) StopInferenceRecommendationsJob(arg0 *sagemaker.StopInferenceRecommendationsJobInput) (*sagemaker.StopInferenceRecommendationsJobOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StopInferenceRecommendationsJob", arg0)
	ret0, _ := ret[0].(*sagemaker.StopInferenceRecommendationsJobOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// StopInferenceRecommendationsJob indicates an expected call of StopInferenceRecommendationsJob.
func (mr *MockSageMakerAPIMockRecorder) StopInferenceRecommendationsJob(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopInferenceRecommendationsJob", reflect.TypeOf((*MockSageMakerAPI)(nil).StopInferenceRecommendationsJob), arg0)
}

// StopInferenceRecommendationsJobRequest mocks base method.
func (m *MockSageMakerAPI) StopInferenceRecommendationsJobRequest(arg0 *sagemaker.StopInferenceRecommendationsJobInput) (*request.Request, *sagemaker.StopInferenceRecommendationsJobOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StopInferenceRecommendationsJobRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.StopInferenceRecommendationsJobOutput)
	return ret0, ret1
}

// StopInferenceRecommendationsJobRequest indicates an expected call of StopInferenceRecommendationsJobRequest.
func (mr *MockSageMakerAPIMockRecorder) StopInferenceRecommendationsJobRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopInferenceRecommendationsJobRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).StopInferenceRecommendationsJobRequest), arg0)
}

// StopInferenceRecommendationsJobWithContext mocks base method.
func (m *MockSageMakerAPI) StopInferenceRecommendationsJobWithContext(arg0 aws.Context, arg1 *sagemaker.StopInferenceRecommendationsJobInput, arg2 ...request.Option) (*sagemaker.StopInferenceRecommendationsJobOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "StopInferenceRecommendationsJobWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.StopInferenceRecommendationsJobOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// StopInferenceRecommendationsJobWithContext indicates an expected call of StopInferenceRecommendationsJobWithContext.
func (mr *MockSageMakerAPIMockRecorder) StopInferenceRecommendationsJobWithContext(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, "StopInferenceRecommendationsJobWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).StopInferenceRecommendationsJobWithContext), varargs...)
}

// StopLabelingJob mocks base method.
func (m *MockSageMakerAPI) StopLabelingJob(arg0 *sagemaker.StopLabelingJobInput) (*sagemaker.StopLabelingJobOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StopLabelingJob", arg0)
	ret0, _ := ret[0].(*sagemaker.StopLabelingJobOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// StopLabelingJob indicates an expected call of StopLabelingJob.
func (mr *MockSageMakerAPIMockRecorder) StopLabelingJob(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopLabelingJob", reflect.TypeOf((*MockSageMakerAPI)(nil).StopLabelingJob), arg0)
}

// StopLabelingJobRequest mocks base method.
func (m *MockSageMakerAPI) StopLabelingJobRequest(arg0 *sagemaker.StopLabelingJobInput) (*request.Request, *sagemaker.StopLabelingJobOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StopLabelingJobRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.StopLabelingJobOutput)
	return ret0, ret1
}

// StopLabelingJobRequest indicates an expected call of StopLabelingJobRequest.
func (mr *MockSageMakerAPIMockRecorder) StopLabelingJobRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopLabelingJobRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).StopLabelingJobRequest), arg0)
}

// StopLabelingJobWithContext mocks base method.
func (m *MockSageMakerAPI) StopLabelingJobWithContext(arg0 aws.Context, arg1 *sagemaker.StopLabelingJobInput, arg2 ...request.Option) (*sagemaker.StopLabelingJobOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "StopLabelingJobWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.StopLabelingJobOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// StopLabelingJobWithContext indicates an expected call of StopLabelingJobWithContext.
func (mr *MockSageMakerAPIMockRecorder) StopLabelingJobWithContext(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, "StopLabelingJobWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).StopLabelingJobWithContext), varargs...)
}

// StopMlflowTrackingServer mocks base method.
func (m *MockSageMakerAPI) StopMlflowTrackingServer(arg0 *sagemaker.StopMlflowTrackingServerInput) (*sagemaker.StopMlflowTrackingServerOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StopMlflowTrackingServer", arg0)
	ret0, _ := ret[0].(*sagemaker.StopMlflowTrackingServerOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// StopMlflowTrackingServer indicates an expected call of StopMlflowTrackingServer.
func (mr *MockSageMakerAPIMockRecorder) StopMlflowTrackingServer(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopMlflowTrackingServer", reflect.TypeOf((*MockSageMakerAPI)(nil).StopMlflowTrackingServer), arg0)
}

// StopMlflowTrackingServerRequest mocks base method.
func (m *MockSageMakerAPI) StopMlflowTrackingServerRequest(arg0 *sagemaker.StopMlflowTrackingServerInput) (*request.Request, *sagemaker.StopMlflowTrackingServerOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StopMlflowTrackingServerRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.StopMlflowTrackingServerOutput)
	return ret0, ret1
}

// StopMlflowTrackingServerRequest indicates an expected call of StopMlflowTrackingServerRequest.
func (mr *MockSageMakerAPIMockRecorder) StopMlflowTrackingServerRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopMlflowTrackingServerRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).StopMlflowTrackingServerRequest), arg0)
}

// StopMlflowTrackingServerWithContext mocks base method.
func (m *MockSageMakerAPI) StopMlflowTrackingServerWithContext(arg0 aws.Context, arg1 *sagemaker.StopMlflowTrackingServerInput, arg2 ...request.Option) (*sagemaker.StopMlflowTrackingServerOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "StopMlflowTrackingServerWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.StopMlflowTrackingServerOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// StopMlflowTrackingServerWithContext indicates an expected call of StopMlflowTrackingServerWithContext.
func (mr *MockSageMakerAPIMockRecorder) StopMlflowTrackingServerWithContext(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, "StopMlflowTrackingServerWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).StopMlflowTrackingServerWithContext), varargs...)
}

// StopMonitoringSchedule mocks base method.
func (m *MockSageMakerAPI) StopMonitoringSchedule(arg0 *sagemaker.StopMonitoringScheduleInput) (*sagemaker.StopMonitoringScheduleOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StopMonitoringSchedule", arg0)
	ret0, _ := ret[0].(*sagemaker.StopMonitoringScheduleOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// StopMonitoringSchedule indicates an expected call of StopMonitoringSchedule.
func (mr *MockSageMakerAPIMockRecorder) StopMonitoringSchedule(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopMonitoringSchedule", reflect.TypeOf((*MockSageMakerAPI)(nil).StopMonitoringSchedule), arg0)
}

// StopMonitoringScheduleRequest mocks base method.
func (m *MockSageMakerAPI) StopMonitoringScheduleRequest(arg0 *sagemaker.StopMonitoringScheduleInput) (*request.Request, *sagemaker.StopMonitoringScheduleOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StopMonitoringScheduleRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.StopMonitoringScheduleOutput)
	return ret0, ret1
}

// StopMonitoringScheduleRequest indicates an expected call of StopMonitoringScheduleRequest.
func (mr *MockSageMakerAPIMockRecorder) StopMonitoringScheduleRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopMonitoringScheduleRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).StopMonitoringScheduleRequest), arg0)
}

// StopMonitoringScheduleWithContext mocks base method.
func (m *MockSageMakerAPI) StopMonitoringScheduleWithContext(arg0 aws.Context, arg1 *sagemaker.StopMonitoringScheduleInput, arg2 ...request.Option) (*sagemaker.StopMonitoringScheduleOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "StopMonitoringScheduleWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.StopMonitoringScheduleOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// StopMonitoringScheduleWithContext indicates an expected call of StopMonitoringScheduleWithContext.
func (mr *MockSageMakerAPIMockRecorder) StopMonitoringScheduleWithContext(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, "StopMonitoringScheduleWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).StopMonitoringScheduleWithContext), varargs...)
}

// StopNotebookInstance mocks base method.
func (m *MockSageMakerAPI) StopNotebookInstance(arg0 *sagemaker.StopNotebookInstanceInput) (*sagemaker.StopNotebookInstanceOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StopNotebookInstance", arg0)
	ret0, _ := ret[0].(*sagemaker.StopNotebookInstanceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// StopNotebookInstance indicates an expected call of StopNotebookInstance.
func (mr *MockSageMakerAPIMockRecorder) StopNotebookInstance(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopNotebookInstance", reflect.TypeOf((*MockSageMakerAPI)(nil).StopNotebookInstance), arg0)
}

// StopNotebookInstanceRequest mocks base method.
func (m *MockSageMakerAPI) StopNotebookInstanceRequest(arg0 *sagemaker.StopNotebookInstanceInput) (*request.Request, *sagemaker.StopNotebookInstanceOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StopNotebookInstanceRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.StopNotebookInstanceOutput)
	return ret0, ret1
}

// StopNotebookInstanceRequest indicates an expected call of StopNotebookInstanceRequest.
func (mr *MockSageMakerAPIMockRecorder) StopNotebookInstanceRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopNotebookInstanceRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).StopNotebookInstanceRequest), arg0)
}

// StopNotebookInstanceWithContext mocks base method.
func (m *MockSageMakerAPI) StopNotebookInstanceWithContext(arg0 aws.Context, arg1 *sagemaker.StopNotebookInstanceInput, arg2 ...request.Option) (*sagemaker.StopNotebookInstanceOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "StopNotebookInstanceWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.StopNotebookInstanceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// StopNotebookInstanceWithContext indicates an expected call of StopNotebookInstanceWithContext.
func (mr *MockSageMakerAPIMockRecorder) StopNotebookInstanceWithContext(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, "StopNotebookInstanceWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).StopNotebookInstanceWithContext), varargs...)
}

// StopOptimizationJob mocks base method.
func (m *MockSageMakerAPI) StopOptimizationJob(arg0 *sagemaker.StopOptimizationJobInput) (*sagemaker.StopOptimizationJobOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StopOptimizationJob", arg0)
	ret0, _ := ret[0].(*sagemaker.StopOptimizationJobOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// StopOptimizationJob indicates an expected call of StopOptimizationJob.
func (mr *MockSageMakerAPIMockRecorder) StopOptimizationJob(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopOptimizationJob", reflect.TypeOf((*MockSageMakerAPI)(nil).StopOptimizationJob), arg0)
}

// StopOptimizationJobRequest mocks base method.
func (m *MockSageMakerAPI) StopOptimizationJobRequest(arg0 *sagemaker.StopOptimizationJobInput) (*request.Request, *sagemaker.StopOptimizationJobOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StopOptimizationJobRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.StopOptimizationJobOutput)
	return ret0, ret1
}

// StopOptimizationJobRequest indicates an expected call of StopOptimizationJobRequest.
func (mr *MockSageMakerAPIMockRecorder) StopOptimizationJobRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopOptimizationJobRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).StopOptimizationJobRequest), arg0)
}

// StopOptimizationJobWithContext mocks base method.
func (m *MockSageMakerAPI) StopOptimizationJobWithContext(arg0 aws.Context, arg1 *sagemaker.StopOptimizationJobInput, arg2 ...request.Option) (*sagemaker.StopOptimizationJobOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "StopOptimizationJobWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.StopOptimizationJobOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// StopOptimizationJobWithContext indicates an expected call of StopOptimizationJobWithContext.
func (mr *MockSageMakerAPIMockRecorder) StopOptimizationJobWithContext(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, "StopOptimizationJobWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).StopOptimizationJobWithContext), varargs...)
}

// StopPipelineExecution mocks base method.
func (m *MockSageMakerAPI) StopPipelineExecution(arg0 *sagemaker.StopPipelineExecutionInput) (*sagemaker.StopPipelineExecutionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StopPipelineExecution", arg0)
	ret0, _ := ret[0].(*sagemaker.StopPipelineExecutionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// StopPipelineExecution indicates an expected call of StopPipelineExecution.
func (mr *MockSageMakerAPIMockRecorder) StopPipelineExecution(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopPipelineExecution", reflect.TypeOf((*MockSageMakerAPI)(nil).StopPipelineExecution), arg0)
}

// StopPipelineExecutionRequest mocks base method.
func (m *MockSageMakerAPI) StopPipelineExecutionRequest(arg0 *sagemaker.StopPipelineExecutionInput) (*request.Request, *sagemaker.StopPipelineExecutionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StopPipelineExecutionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.StopPipelineExecutionOutput)
	return ret0, ret1
}

// StopPipelineExecutionRequest indicates an expected call of StopPipelineExecutionRequest.
func (mr *MockSageMakerAPIMockRecorder) StopPipelineExecutionRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopPipelineExecutionRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).StopPipelineExecutionRequest), arg0)
}

// StopPipelineExecutionWithContext mocks base method.
func (m *MockSageMakerAPI) StopPipelineExecutionWithContext(arg0 aws.Context, arg1 *sagemaker.StopPipelineExecutionInput, arg2 ...request.Option) (*sagemaker.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].(*sagemaker.StopPipelineExecutionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// StopPipelineExecutionWithContext indicates an expected call of StopPipelineExecutionWithContext.
func (mr *MockSageMakerAPIMockRecorder) 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((*MockSageMakerAPI)(nil).StopPipelineExecutionWithContext), varargs...)
}

// StopProcessingJob mocks base method.
func (m *MockSageMakerAPI) StopProcessingJob(arg0 *sagemaker.StopProcessingJobInput) (*sagemaker.StopProcessingJobOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StopProcessingJob", arg0)
	ret0, _ := ret[0].(*sagemaker.StopProcessingJobOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// StopProcessingJob indicates an expected call of StopProcessingJob.
func (mr *MockSageMakerAPIMockRecorder) StopProcessingJob(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopProcessingJob", reflect.TypeOf((*MockSageMakerAPI)(nil).StopProcessingJob), arg0)
}

// StopProcessingJobRequest mocks base method.
func (m *MockSageMakerAPI) StopProcessingJobRequest(arg0 *sagemaker.StopProcessingJobInput) (*request.Request, *sagemaker.StopProcessingJobOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StopProcessingJobRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.StopProcessingJobOutput)
	return ret0, ret1
}

// StopProcessingJobRequest indicates an expected call of StopProcessingJobRequest.
func (mr *MockSageMakerAPIMockRecorder) StopProcessingJobRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopProcessingJobRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).StopProcessingJobRequest), arg0)
}

// StopProcessingJobWithContext mocks base method.
func (m *MockSageMakerAPI) StopProcessingJobWithContext(arg0 aws.Context, arg1 *sagemaker.StopProcessingJobInput, arg2 ...request.Option) (*sagemaker.StopProcessingJobOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "StopProcessingJobWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.StopProcessingJobOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// StopProcessingJobWithContext indicates an expected call of StopProcessingJobWithContext.
func (mr *MockSageMakerAPIMockRecorder) StopProcessingJobWithContext(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, "StopProcessingJobWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).StopProcessingJobWithContext), varargs...)
}

// StopTrainingJob mocks base method.
func (m *MockSageMakerAPI) StopTrainingJob(arg0 *sagemaker.StopTrainingJobInput) (*sagemaker.StopTrainingJobOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StopTrainingJob", arg0)
	ret0, _ := ret[0].(*sagemaker.StopTrainingJobOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// StopTrainingJob indicates an expected call of StopTrainingJob.
func (mr *MockSageMakerAPIMockRecorder) StopTrainingJob(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopTrainingJob", reflect.TypeOf((*MockSageMakerAPI)(nil).StopTrainingJob), arg0)
}

// StopTrainingJobRequest mocks base method.
func (m *MockSageMakerAPI) StopTrainingJobRequest(arg0 *sagemaker.StopTrainingJobInput) (*request.Request, *sagemaker.StopTrainingJobOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StopTrainingJobRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.StopTrainingJobOutput)
	return ret0, ret1
}

// StopTrainingJobRequest indicates an expected call of StopTrainingJobRequest.
func (mr *MockSageMakerAPIMockRecorder) StopTrainingJobRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopTrainingJobRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).StopTrainingJobRequest), arg0)
}

// StopTrainingJobWithContext mocks base method.
func (m *MockSageMakerAPI) StopTrainingJobWithContext(arg0 aws.Context, arg1 *sagemaker.StopTrainingJobInput, arg2 ...request.Option) (*sagemaker.StopTrainingJobOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "StopTrainingJobWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.StopTrainingJobOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// StopTrainingJobWithContext indicates an expected call of StopTrainingJobWithContext.
func (mr *MockSageMakerAPIMockRecorder) StopTrainingJobWithContext(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, "StopTrainingJobWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).StopTrainingJobWithContext), varargs...)
}

// StopTransformJob mocks base method.
func (m *MockSageMakerAPI) StopTransformJob(arg0 *sagemaker.StopTransformJobInput) (*sagemaker.StopTransformJobOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StopTransformJob", arg0)
	ret0, _ := ret[0].(*sagemaker.StopTransformJobOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// StopTransformJob indicates an expected call of StopTransformJob.
func (mr *MockSageMakerAPIMockRecorder) StopTransformJob(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopTransformJob", reflect.TypeOf((*MockSageMakerAPI)(nil).StopTransformJob), arg0)
}

// StopTransformJobRequest mocks base method.
func (m *MockSageMakerAPI) StopTransformJobRequest(arg0 *sagemaker.StopTransformJobInput) (*request.Request, *sagemaker.StopTransformJobOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StopTransformJobRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.StopTransformJobOutput)
	return ret0, ret1
}

// StopTransformJobRequest indicates an expected call of StopTransformJobRequest.
func (mr *MockSageMakerAPIMockRecorder) StopTransformJobRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopTransformJobRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).StopTransformJobRequest), arg0)
}

// StopTransformJobWithContext mocks base method.
func (m *MockSageMakerAPI) StopTransformJobWithContext(arg0 aws.Context, arg1 *sagemaker.StopTransformJobInput, arg2 ...request.Option) (*sagemaker.StopTransformJobOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "StopTransformJobWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.StopTransformJobOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// StopTransformJobWithContext indicates an expected call of StopTransformJobWithContext.
func (mr *MockSageMakerAPIMockRecorder) StopTransformJobWithContext(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, "StopTransformJobWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).StopTransformJobWithContext), varargs...)
}

// UpdateAction mocks base method.
func (m *MockSageMakerAPI) UpdateAction(arg0 *sagemaker.UpdateActionInput) (*sagemaker.UpdateActionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateAction", arg0)
	ret0, _ := ret[0].(*sagemaker.UpdateActionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateAction indicates an expected call of UpdateAction.
func (mr *MockSageMakerAPIMockRecorder) UpdateAction(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateAction", reflect.TypeOf((*MockSageMakerAPI)(nil).UpdateAction), arg0)
}

// UpdateActionRequest mocks base method.
func (m *MockSageMakerAPI) UpdateActionRequest(arg0 *sagemaker.UpdateActionInput) (*request.Request, *sagemaker.UpdateActionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateActionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.UpdateActionOutput)
	return ret0, ret1
}

// UpdateActionRequest indicates an expected call of UpdateActionRequest.
func (mr *MockSageMakerAPIMockRecorder) UpdateActionRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateActionRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).UpdateActionRequest), arg0)
}

// UpdateActionWithContext mocks base method.
func (m *MockSageMakerAPI) UpdateActionWithContext(arg0 aws.Context, arg1 *sagemaker.UpdateActionInput, arg2 ...request.Option) (*sagemaker.UpdateActionOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateActionWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.UpdateActionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateActionWithContext indicates an expected call of UpdateActionWithContext.
func (mr *MockSageMakerAPIMockRecorder) UpdateActionWithContext(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, "UpdateActionWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).UpdateActionWithContext), varargs...)
}

// UpdateAppImageConfig mocks base method.
func (m *MockSageMakerAPI) UpdateAppImageConfig(arg0 *sagemaker.UpdateAppImageConfigInput) (*sagemaker.UpdateAppImageConfigOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateAppImageConfig", arg0)
	ret0, _ := ret[0].(*sagemaker.UpdateAppImageConfigOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateAppImageConfig indicates an expected call of UpdateAppImageConfig.
func (mr *MockSageMakerAPIMockRecorder) UpdateAppImageConfig(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateAppImageConfig", reflect.TypeOf((*MockSageMakerAPI)(nil).UpdateAppImageConfig), arg0)
}

// UpdateAppImageConfigRequest mocks base method.
func (m *MockSageMakerAPI) UpdateAppImageConfigRequest(arg0 *sagemaker.UpdateAppImageConfigInput) (*request.Request, *sagemaker.UpdateAppImageConfigOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateAppImageConfigRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.UpdateAppImageConfigOutput)
	return ret0, ret1
}

// UpdateAppImageConfigRequest indicates an expected call of UpdateAppImageConfigRequest.
func (mr *MockSageMakerAPIMockRecorder) UpdateAppImageConfigRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateAppImageConfigRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).UpdateAppImageConfigRequest), arg0)
}

// UpdateAppImageConfigWithContext mocks base method.
func (m *MockSageMakerAPI) UpdateAppImageConfigWithContext(arg0 aws.Context, arg1 *sagemaker.UpdateAppImageConfigInput, arg2 ...request.Option) (*sagemaker.UpdateAppImageConfigOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateAppImageConfigWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.UpdateAppImageConfigOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateAppImageConfigWithContext indicates an expected call of UpdateAppImageConfigWithContext.
func (mr *MockSageMakerAPIMockRecorder) UpdateAppImageConfigWithContext(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, "UpdateAppImageConfigWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).UpdateAppImageConfigWithContext), varargs...)
}

// UpdateArtifact mocks base method.
func (m *MockSageMakerAPI) UpdateArtifact(arg0 *sagemaker.UpdateArtifactInput) (*sagemaker.UpdateArtifactOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateArtifact", arg0)
	ret0, _ := ret[0].(*sagemaker.UpdateArtifactOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateArtifact indicates an expected call of UpdateArtifact.
func (mr *MockSageMakerAPIMockRecorder) UpdateArtifact(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateArtifact", reflect.TypeOf((*MockSageMakerAPI)(nil).UpdateArtifact), arg0)
}

// UpdateArtifactRequest mocks base method.
func (m *MockSageMakerAPI) UpdateArtifactRequest(arg0 *sagemaker.UpdateArtifactInput) (*request.Request, *sagemaker.UpdateArtifactOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateArtifactRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.UpdateArtifactOutput)
	return ret0, ret1
}

// UpdateArtifactRequest indicates an expected call of UpdateArtifactRequest.
func (mr *MockSageMakerAPIMockRecorder) UpdateArtifactRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateArtifactRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).UpdateArtifactRequest), arg0)
}

// UpdateArtifactWithContext mocks base method.
func (m *MockSageMakerAPI) UpdateArtifactWithContext(arg0 aws.Context, arg1 *sagemaker.UpdateArtifactInput, arg2 ...request.Option) (*sagemaker.UpdateArtifactOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateArtifactWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.UpdateArtifactOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateArtifactWithContext indicates an expected call of UpdateArtifactWithContext.
func (mr *MockSageMakerAPIMockRecorder) UpdateArtifactWithContext(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, "UpdateArtifactWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).UpdateArtifactWithContext), varargs...)
}

// UpdateCluster mocks base method.
func (m *MockSageMakerAPI) UpdateCluster(arg0 *sagemaker.UpdateClusterInput) (*sagemaker.UpdateClusterOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateCluster", arg0)
	ret0, _ := ret[0].(*sagemaker.UpdateClusterOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateCluster indicates an expected call of UpdateCluster.
func (mr *MockSageMakerAPIMockRecorder) UpdateCluster(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateCluster", reflect.TypeOf((*MockSageMakerAPI)(nil).UpdateCluster), arg0)
}

// UpdateClusterRequest mocks base method.
func (m *MockSageMakerAPI) UpdateClusterRequest(arg0 *sagemaker.UpdateClusterInput) (*request.Request, *sagemaker.UpdateClusterOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateClusterRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.UpdateClusterOutput)
	return ret0, ret1
}

// UpdateClusterRequest indicates an expected call of UpdateClusterRequest.
func (mr *MockSageMakerAPIMockRecorder) UpdateClusterRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateClusterRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).UpdateClusterRequest), arg0)
}

// UpdateClusterSoftware mocks base method.
func (m *MockSageMakerAPI) UpdateClusterSoftware(arg0 *sagemaker.UpdateClusterSoftwareInput) (*sagemaker.UpdateClusterSoftwareOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateClusterSoftware", arg0)
	ret0, _ := ret[0].(*sagemaker.UpdateClusterSoftwareOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateClusterSoftware indicates an expected call of UpdateClusterSoftware.
func (mr *MockSageMakerAPIMockRecorder) UpdateClusterSoftware(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateClusterSoftware", reflect.TypeOf((*MockSageMakerAPI)(nil).UpdateClusterSoftware), arg0)
}

// UpdateClusterSoftwareRequest mocks base method.
func (m *MockSageMakerAPI) UpdateClusterSoftwareRequest(arg0 *sagemaker.UpdateClusterSoftwareInput) (*request.Request, *sagemaker.UpdateClusterSoftwareOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateClusterSoftwareRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.UpdateClusterSoftwareOutput)
	return ret0, ret1
}

// UpdateClusterSoftwareRequest indicates an expected call of UpdateClusterSoftwareRequest.
func (mr *MockSageMakerAPIMockRecorder) UpdateClusterSoftwareRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateClusterSoftwareRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).UpdateClusterSoftwareRequest), arg0)
}

// UpdateClusterSoftwareWithContext mocks base method.
func (m *MockSageMakerAPI) UpdateClusterSoftwareWithContext(arg0 aws.Context, arg1 *sagemaker.UpdateClusterSoftwareInput, arg2 ...request.Option) (*sagemaker.UpdateClusterSoftwareOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateClusterSoftwareWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.UpdateClusterSoftwareOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateClusterSoftwareWithContext indicates an expected call of UpdateClusterSoftwareWithContext.
func (mr *MockSageMakerAPIMockRecorder) UpdateClusterSoftwareWithContext(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, "UpdateClusterSoftwareWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).UpdateClusterSoftwareWithContext), varargs...)
}

// UpdateClusterWithContext mocks base method.
func (m *MockSageMakerAPI) UpdateClusterWithContext(arg0 aws.Context, arg1 *sagemaker.UpdateClusterInput, arg2 ...request.Option) (*sagemaker.UpdateClusterOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateClusterWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.UpdateClusterOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateClusterWithContext indicates an expected call of UpdateClusterWithContext.
func (mr *MockSageMakerAPIMockRecorder) UpdateClusterWithContext(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, "UpdateClusterWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).UpdateClusterWithContext), varargs...)
}

// UpdateCodeRepository mocks base method.
func (m *MockSageMakerAPI) UpdateCodeRepository(arg0 *sagemaker.UpdateCodeRepositoryInput) (*sagemaker.UpdateCodeRepositoryOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateCodeRepository", arg0)
	ret0, _ := ret[0].(*sagemaker.UpdateCodeRepositoryOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateCodeRepository indicates an expected call of UpdateCodeRepository.
func (mr *MockSageMakerAPIMockRecorder) UpdateCodeRepository(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateCodeRepository", reflect.TypeOf((*MockSageMakerAPI)(nil).UpdateCodeRepository), arg0)
}

// UpdateCodeRepositoryRequest mocks base method.
func (m *MockSageMakerAPI) UpdateCodeRepositoryRequest(arg0 *sagemaker.UpdateCodeRepositoryInput) (*request.Request, *sagemaker.UpdateCodeRepositoryOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateCodeRepositoryRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.UpdateCodeRepositoryOutput)
	return ret0, ret1
}

// UpdateCodeRepositoryRequest indicates an expected call of UpdateCodeRepositoryRequest.
func (mr *MockSageMakerAPIMockRecorder) UpdateCodeRepositoryRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateCodeRepositoryRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).UpdateCodeRepositoryRequest), arg0)
}

// UpdateCodeRepositoryWithContext mocks base method.
func (m *MockSageMakerAPI) UpdateCodeRepositoryWithContext(arg0 aws.Context, arg1 *sagemaker.UpdateCodeRepositoryInput, arg2 ...request.Option) (*sagemaker.UpdateCodeRepositoryOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateCodeRepositoryWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.UpdateCodeRepositoryOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateCodeRepositoryWithContext indicates an expected call of UpdateCodeRepositoryWithContext.
func (mr *MockSageMakerAPIMockRecorder) UpdateCodeRepositoryWithContext(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, "UpdateCodeRepositoryWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).UpdateCodeRepositoryWithContext), varargs...)
}

// UpdateContext mocks base method.
func (m *MockSageMakerAPI) UpdateContext(arg0 *sagemaker.UpdateContextInput) (*sagemaker.UpdateContextOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateContext", arg0)
	ret0, _ := ret[0].(*sagemaker.UpdateContextOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateContext indicates an expected call of UpdateContext.
func (mr *MockSageMakerAPIMockRecorder) UpdateContext(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateContext", reflect.TypeOf((*MockSageMakerAPI)(nil).UpdateContext), arg0)
}

// UpdateContextRequest mocks base method.
func (m *MockSageMakerAPI) UpdateContextRequest(arg0 *sagemaker.UpdateContextInput) (*request.Request, *sagemaker.UpdateContextOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateContextRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.UpdateContextOutput)
	return ret0, ret1
}

// UpdateContextRequest indicates an expected call of UpdateContextRequest.
func (mr *MockSageMakerAPIMockRecorder) UpdateContextRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateContextRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).UpdateContextRequest), arg0)
}

// UpdateContextWithContext mocks base method.
func (m *MockSageMakerAPI) UpdateContextWithContext(arg0 aws.Context, arg1 *sagemaker.UpdateContextInput, arg2 ...request.Option) (*sagemaker.UpdateContextOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateContextWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.UpdateContextOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateContextWithContext indicates an expected call of UpdateContextWithContext.
func (mr *MockSageMakerAPIMockRecorder) UpdateContextWithContext(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, "UpdateContextWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).UpdateContextWithContext), varargs...)
}

// UpdateDeviceFleet mocks base method.
func (m *MockSageMakerAPI) UpdateDeviceFleet(arg0 *sagemaker.UpdateDeviceFleetInput) (*sagemaker.UpdateDeviceFleetOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateDeviceFleet", arg0)
	ret0, _ := ret[0].(*sagemaker.UpdateDeviceFleetOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateDeviceFleet indicates an expected call of UpdateDeviceFleet.
func (mr *MockSageMakerAPIMockRecorder) UpdateDeviceFleet(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateDeviceFleet", reflect.TypeOf((*MockSageMakerAPI)(nil).UpdateDeviceFleet), arg0)
}

// UpdateDeviceFleetRequest mocks base method.
func (m *MockSageMakerAPI) UpdateDeviceFleetRequest(arg0 *sagemaker.UpdateDeviceFleetInput) (*request.Request, *sagemaker.UpdateDeviceFleetOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateDeviceFleetRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.UpdateDeviceFleetOutput)
	return ret0, ret1
}

// UpdateDeviceFleetRequest indicates an expected call of UpdateDeviceFleetRequest.
func (mr *MockSageMakerAPIMockRecorder) UpdateDeviceFleetRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateDeviceFleetRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).UpdateDeviceFleetRequest), arg0)
}

// UpdateDeviceFleetWithContext mocks base method.
func (m *MockSageMakerAPI) UpdateDeviceFleetWithContext(arg0 aws.Context, arg1 *sagemaker.UpdateDeviceFleetInput, arg2 ...request.Option) (*sagemaker.UpdateDeviceFleetOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateDeviceFleetWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.UpdateDeviceFleetOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateDeviceFleetWithContext indicates an expected call of UpdateDeviceFleetWithContext.
func (mr *MockSageMakerAPIMockRecorder) UpdateDeviceFleetWithContext(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, "UpdateDeviceFleetWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).UpdateDeviceFleetWithContext), varargs...)
}

// UpdateDevices mocks base method.
func (m *MockSageMakerAPI) UpdateDevices(arg0 *sagemaker.UpdateDevicesInput) (*sagemaker.UpdateDevicesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateDevices", arg0)
	ret0, _ := ret[0].(*sagemaker.UpdateDevicesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateDevices indicates an expected call of UpdateDevices.
func (mr *MockSageMakerAPIMockRecorder) UpdateDevices(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateDevices", reflect.TypeOf((*MockSageMakerAPI)(nil).UpdateDevices), arg0)
}

// UpdateDevicesRequest mocks base method.
func (m *MockSageMakerAPI) UpdateDevicesRequest(arg0 *sagemaker.UpdateDevicesInput) (*request.Request, *sagemaker.UpdateDevicesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateDevicesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.UpdateDevicesOutput)
	return ret0, ret1
}

// UpdateDevicesRequest indicates an expected call of UpdateDevicesRequest.
func (mr *MockSageMakerAPIMockRecorder) UpdateDevicesRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateDevicesRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).UpdateDevicesRequest), arg0)
}

// UpdateDevicesWithContext mocks base method.
func (m *MockSageMakerAPI) UpdateDevicesWithContext(arg0 aws.Context, arg1 *sagemaker.UpdateDevicesInput, arg2 ...request.Option) (*sagemaker.UpdateDevicesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateDevicesWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.UpdateDevicesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateDevicesWithContext indicates an expected call of UpdateDevicesWithContext.
func (mr *MockSageMakerAPIMockRecorder) UpdateDevicesWithContext(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, "UpdateDevicesWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).UpdateDevicesWithContext), varargs...)
}

// UpdateDomain mocks base method.
func (m *MockSageMakerAPI) UpdateDomain(arg0 *sagemaker.UpdateDomainInput) (*sagemaker.UpdateDomainOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateDomain", arg0)
	ret0, _ := ret[0].(*sagemaker.UpdateDomainOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateDomain indicates an expected call of UpdateDomain.
func (mr *MockSageMakerAPIMockRecorder) UpdateDomain(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateDomain", reflect.TypeOf((*MockSageMakerAPI)(nil).UpdateDomain), arg0)
}

// UpdateDomainRequest mocks base method.
func (m *MockSageMakerAPI) UpdateDomainRequest(arg0 *sagemaker.UpdateDomainInput) (*request.Request, *sagemaker.UpdateDomainOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateDomainRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.UpdateDomainOutput)
	return ret0, ret1
}

// UpdateDomainRequest indicates an expected call of UpdateDomainRequest.
func (mr *MockSageMakerAPIMockRecorder) UpdateDomainRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateDomainRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).UpdateDomainRequest), arg0)
}

// UpdateDomainWithContext mocks base method.
func (m *MockSageMakerAPI) UpdateDomainWithContext(arg0 aws.Context, arg1 *sagemaker.UpdateDomainInput, arg2 ...request.Option) (*sagemaker.UpdateDomainOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateDomainWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.UpdateDomainOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateDomainWithContext indicates an expected call of UpdateDomainWithContext.
func (mr *MockSageMakerAPIMockRecorder) UpdateDomainWithContext(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, "UpdateDomainWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).UpdateDomainWithContext), varargs...)
}

// UpdateEndpoint mocks base method.
func (m *MockSageMakerAPI) UpdateEndpoint(arg0 *sagemaker.UpdateEndpointInput) (*sagemaker.UpdateEndpointOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateEndpoint", arg0)
	ret0, _ := ret[0].(*sagemaker.UpdateEndpointOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateEndpoint indicates an expected call of UpdateEndpoint.
func (mr *MockSageMakerAPIMockRecorder) UpdateEndpoint(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateEndpoint", reflect.TypeOf((*MockSageMakerAPI)(nil).UpdateEndpoint), arg0)
}

// UpdateEndpointRequest mocks base method.
func (m *MockSageMakerAPI) UpdateEndpointRequest(arg0 *sagemaker.UpdateEndpointInput) (*request.Request, *sagemaker.UpdateEndpointOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateEndpointRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.UpdateEndpointOutput)
	return ret0, ret1
}

// UpdateEndpointRequest indicates an expected call of UpdateEndpointRequest.
func (mr *MockSageMakerAPIMockRecorder) UpdateEndpointRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateEndpointRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).UpdateEndpointRequest), arg0)
}

// UpdateEndpointWeightsAndCapacities mocks base method.
func (m *MockSageMakerAPI) UpdateEndpointWeightsAndCapacities(arg0 *sagemaker.UpdateEndpointWeightsAndCapacitiesInput) (*sagemaker.UpdateEndpointWeightsAndCapacitiesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateEndpointWeightsAndCapacities", arg0)
	ret0, _ := ret[0].(*sagemaker.UpdateEndpointWeightsAndCapacitiesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateEndpointWeightsAndCapacities indicates an expected call of UpdateEndpointWeightsAndCapacities.
func (mr *MockSageMakerAPIMockRecorder) UpdateEndpointWeightsAndCapacities(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateEndpointWeightsAndCapacities", reflect.TypeOf((*MockSageMakerAPI)(nil).UpdateEndpointWeightsAndCapacities), arg0)
}

// UpdateEndpointWeightsAndCapacitiesRequest mocks base method.
func (m *MockSageMakerAPI) UpdateEndpointWeightsAndCapacitiesRequest(arg0 *sagemaker.UpdateEndpointWeightsAndCapacitiesInput) (*request.Request, *sagemaker.UpdateEndpointWeightsAndCapacitiesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateEndpointWeightsAndCapacitiesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.UpdateEndpointWeightsAndCapacitiesOutput)
	return ret0, ret1
}

// UpdateEndpointWeightsAndCapacitiesRequest indicates an expected call of UpdateEndpointWeightsAndCapacitiesRequest.
func (mr *MockSageMakerAPIMockRecorder) UpdateEndpointWeightsAndCapacitiesRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateEndpointWeightsAndCapacitiesRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).UpdateEndpointWeightsAndCapacitiesRequest), arg0)
}

// UpdateEndpointWeightsAndCapacitiesWithContext mocks base method.
func (m *MockSageMakerAPI) UpdateEndpointWeightsAndCapacitiesWithContext(arg0 aws.Context, arg1 *sagemaker.UpdateEndpointWeightsAndCapacitiesInput, arg2 ...request.Option) (*sagemaker.UpdateEndpointWeightsAndCapacitiesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateEndpointWeightsAndCapacitiesWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.UpdateEndpointWeightsAndCapacitiesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateEndpointWeightsAndCapacitiesWithContext indicates an expected call of UpdateEndpointWeightsAndCapacitiesWithContext.
func (mr *MockSageMakerAPIMockRecorder) UpdateEndpointWeightsAndCapacitiesWithContext(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, "UpdateEndpointWeightsAndCapacitiesWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).UpdateEndpointWeightsAndCapacitiesWithContext), varargs...)
}

// UpdateEndpointWithContext mocks base method.
func (m *MockSageMakerAPI) UpdateEndpointWithContext(arg0 aws.Context, arg1 *sagemaker.UpdateEndpointInput, arg2 ...request.Option) (*sagemaker.UpdateEndpointOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateEndpointWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.UpdateEndpointOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateEndpointWithContext indicates an expected call of UpdateEndpointWithContext.
func (mr *MockSageMakerAPIMockRecorder) UpdateEndpointWithContext(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, "UpdateEndpointWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).UpdateEndpointWithContext), varargs...)
}

// UpdateExperiment mocks base method.
func (m *MockSageMakerAPI) UpdateExperiment(arg0 *sagemaker.UpdateExperimentInput) (*sagemaker.UpdateExperimentOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateExperiment", arg0)
	ret0, _ := ret[0].(*sagemaker.UpdateExperimentOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateExperiment indicates an expected call of UpdateExperiment.
func (mr *MockSageMakerAPIMockRecorder) UpdateExperiment(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateExperiment", reflect.TypeOf((*MockSageMakerAPI)(nil).UpdateExperiment), arg0)
}

// UpdateExperimentRequest mocks base method.
func (m *MockSageMakerAPI) UpdateExperimentRequest(arg0 *sagemaker.UpdateExperimentInput) (*request.Request, *sagemaker.UpdateExperimentOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateExperimentRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.UpdateExperimentOutput)
	return ret0, ret1
}

// UpdateExperimentRequest indicates an expected call of UpdateExperimentRequest.
func (mr *MockSageMakerAPIMockRecorder) UpdateExperimentRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateExperimentRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).UpdateExperimentRequest), arg0)
}

// UpdateExperimentWithContext mocks base method.
func (m *MockSageMakerAPI) UpdateExperimentWithContext(arg0 aws.Context, arg1 *sagemaker.UpdateExperimentInput, arg2 ...request.Option) (*sagemaker.UpdateExperimentOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateExperimentWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.UpdateExperimentOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateExperimentWithContext indicates an expected call of UpdateExperimentWithContext.
func (mr *MockSageMakerAPIMockRecorder) UpdateExperimentWithContext(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, "UpdateExperimentWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).UpdateExperimentWithContext), varargs...)
}

// UpdateFeatureGroup mocks base method.
func (m *MockSageMakerAPI) UpdateFeatureGroup(arg0 *sagemaker.UpdateFeatureGroupInput) (*sagemaker.UpdateFeatureGroupOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateFeatureGroup", arg0)
	ret0, _ := ret[0].(*sagemaker.UpdateFeatureGroupOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateFeatureGroup indicates an expected call of UpdateFeatureGroup.
func (mr *MockSageMakerAPIMockRecorder) UpdateFeatureGroup(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateFeatureGroup", reflect.TypeOf((*MockSageMakerAPI)(nil).UpdateFeatureGroup), arg0)
}

// UpdateFeatureGroupRequest mocks base method.
func (m *MockSageMakerAPI) UpdateFeatureGroupRequest(arg0 *sagemaker.UpdateFeatureGroupInput) (*request.Request, *sagemaker.UpdateFeatureGroupOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateFeatureGroupRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.UpdateFeatureGroupOutput)
	return ret0, ret1
}

// UpdateFeatureGroupRequest indicates an expected call of UpdateFeatureGroupRequest.
func (mr *MockSageMakerAPIMockRecorder) UpdateFeatureGroupRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateFeatureGroupRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).UpdateFeatureGroupRequest), arg0)
}

// UpdateFeatureGroupWithContext mocks base method.
func (m *MockSageMakerAPI) UpdateFeatureGroupWithContext(arg0 aws.Context, arg1 *sagemaker.UpdateFeatureGroupInput, arg2 ...request.Option) (*sagemaker.UpdateFeatureGroupOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateFeatureGroupWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.UpdateFeatureGroupOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateFeatureGroupWithContext indicates an expected call of UpdateFeatureGroupWithContext.
func (mr *MockSageMakerAPIMockRecorder) UpdateFeatureGroupWithContext(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, "UpdateFeatureGroupWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).UpdateFeatureGroupWithContext), varargs...)
}

// UpdateFeatureMetadata mocks base method.
func (m *MockSageMakerAPI) UpdateFeatureMetadata(arg0 *sagemaker.UpdateFeatureMetadataInput) (*sagemaker.UpdateFeatureMetadataOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateFeatureMetadata", arg0)
	ret0, _ := ret[0].(*sagemaker.UpdateFeatureMetadataOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateFeatureMetadata indicates an expected call of UpdateFeatureMetadata.
func (mr *MockSageMakerAPIMockRecorder) UpdateFeatureMetadata(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateFeatureMetadata", reflect.TypeOf((*MockSageMakerAPI)(nil).UpdateFeatureMetadata), arg0)
}

// UpdateFeatureMetadataRequest mocks base method.
func (m *MockSageMakerAPI) UpdateFeatureMetadataRequest(arg0 *sagemaker.UpdateFeatureMetadataInput) (*request.Request, *sagemaker.UpdateFeatureMetadataOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateFeatureMetadataRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.UpdateFeatureMetadataOutput)
	return ret0, ret1
}

// UpdateFeatureMetadataRequest indicates an expected call of UpdateFeatureMetadataRequest.
func (mr *MockSageMakerAPIMockRecorder) UpdateFeatureMetadataRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateFeatureMetadataRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).UpdateFeatureMetadataRequest), arg0)
}

// UpdateFeatureMetadataWithContext mocks base method.
func (m *MockSageMakerAPI) UpdateFeatureMetadataWithContext(arg0 aws.Context, arg1 *sagemaker.UpdateFeatureMetadataInput, arg2 ...request.Option) (*sagemaker.UpdateFeatureMetadataOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateFeatureMetadataWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.UpdateFeatureMetadataOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateFeatureMetadataWithContext indicates an expected call of UpdateFeatureMetadataWithContext.
func (mr *MockSageMakerAPIMockRecorder) UpdateFeatureMetadataWithContext(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, "UpdateFeatureMetadataWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).UpdateFeatureMetadataWithContext), varargs...)
}

// UpdateHub mocks base method.
func (m *MockSageMakerAPI) UpdateHub(arg0 *sagemaker.UpdateHubInput) (*sagemaker.UpdateHubOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateHub", arg0)
	ret0, _ := ret[0].(*sagemaker.UpdateHubOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateHub indicates an expected call of UpdateHub.
func (mr *MockSageMakerAPIMockRecorder) UpdateHub(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateHub", reflect.TypeOf((*MockSageMakerAPI)(nil).UpdateHub), arg0)
}

// UpdateHubRequest mocks base method.
func (m *MockSageMakerAPI) UpdateHubRequest(arg0 *sagemaker.UpdateHubInput) (*request.Request, *sagemaker.UpdateHubOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateHubRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.UpdateHubOutput)
	return ret0, ret1
}

// UpdateHubRequest indicates an expected call of UpdateHubRequest.
func (mr *MockSageMakerAPIMockRecorder) UpdateHubRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateHubRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).UpdateHubRequest), arg0)
}

// UpdateHubWithContext mocks base method.
func (m *MockSageMakerAPI) UpdateHubWithContext(arg0 aws.Context, arg1 *sagemaker.UpdateHubInput, arg2 ...request.Option) (*sagemaker.UpdateHubOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateHubWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.UpdateHubOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateHubWithContext indicates an expected call of UpdateHubWithContext.
func (mr *MockSageMakerAPIMockRecorder) UpdateHubWithContext(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, "UpdateHubWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).UpdateHubWithContext), varargs...)
}

// UpdateImage mocks base method.
func (m *MockSageMakerAPI) UpdateImage(arg0 *sagemaker.UpdateImageInput) (*sagemaker.UpdateImageOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateImage", arg0)
	ret0, _ := ret[0].(*sagemaker.UpdateImageOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateImage indicates an expected call of UpdateImage.
func (mr *MockSageMakerAPIMockRecorder) UpdateImage(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateImage", reflect.TypeOf((*MockSageMakerAPI)(nil).UpdateImage), arg0)
}

// UpdateImageRequest mocks base method.
func (m *MockSageMakerAPI) UpdateImageRequest(arg0 *sagemaker.UpdateImageInput) (*request.Request, *sagemaker.UpdateImageOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateImageRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.UpdateImageOutput)
	return ret0, ret1
}

// UpdateImageRequest indicates an expected call of UpdateImageRequest.
func (mr *MockSageMakerAPIMockRecorder) UpdateImageRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateImageRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).UpdateImageRequest), arg0)
}

// UpdateImageVersion mocks base method.
func (m *MockSageMakerAPI) UpdateImageVersion(arg0 *sagemaker.UpdateImageVersionInput) (*sagemaker.UpdateImageVersionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateImageVersion", arg0)
	ret0, _ := ret[0].(*sagemaker.UpdateImageVersionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateImageVersion indicates an expected call of UpdateImageVersion.
func (mr *MockSageMakerAPIMockRecorder) UpdateImageVersion(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateImageVersion", reflect.TypeOf((*MockSageMakerAPI)(nil).UpdateImageVersion), arg0)
}

// UpdateImageVersionRequest mocks base method.
func (m *MockSageMakerAPI) UpdateImageVersionRequest(arg0 *sagemaker.UpdateImageVersionInput) (*request.Request, *sagemaker.UpdateImageVersionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateImageVersionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.UpdateImageVersionOutput)
	return ret0, ret1
}

// UpdateImageVersionRequest indicates an expected call of UpdateImageVersionRequest.
func (mr *MockSageMakerAPIMockRecorder) UpdateImageVersionRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateImageVersionRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).UpdateImageVersionRequest), arg0)
}

// UpdateImageVersionWithContext mocks base method.
func (m *MockSageMakerAPI) UpdateImageVersionWithContext(arg0 aws.Context, arg1 *sagemaker.UpdateImageVersionInput, arg2 ...request.Option) (*sagemaker.UpdateImageVersionOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateImageVersionWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.UpdateImageVersionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateImageVersionWithContext indicates an expected call of UpdateImageVersionWithContext.
func (mr *MockSageMakerAPIMockRecorder) UpdateImageVersionWithContext(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, "UpdateImageVersionWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).UpdateImageVersionWithContext), varargs...)
}

// UpdateImageWithContext mocks base method.
func (m *MockSageMakerAPI) UpdateImageWithContext(arg0 aws.Context, arg1 *sagemaker.UpdateImageInput, arg2 ...request.Option) (*sagemaker.UpdateImageOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateImageWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.UpdateImageOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateImageWithContext indicates an expected call of UpdateImageWithContext.
func (mr *MockSageMakerAPIMockRecorder) UpdateImageWithContext(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, "UpdateImageWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).UpdateImageWithContext), varargs...)
}

// UpdateInferenceComponent mocks base method.
func (m *MockSageMakerAPI) UpdateInferenceComponent(arg0 *sagemaker.UpdateInferenceComponentInput) (*sagemaker.UpdateInferenceComponentOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateInferenceComponent", arg0)
	ret0, _ := ret[0].(*sagemaker.UpdateInferenceComponentOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateInferenceComponent indicates an expected call of UpdateInferenceComponent.
func (mr *MockSageMakerAPIMockRecorder) UpdateInferenceComponent(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateInferenceComponent", reflect.TypeOf((*MockSageMakerAPI)(nil).UpdateInferenceComponent), arg0)
}

// UpdateInferenceComponentRequest mocks base method.
func (m *MockSageMakerAPI) UpdateInferenceComponentRequest(arg0 *sagemaker.UpdateInferenceComponentInput) (*request.Request, *sagemaker.UpdateInferenceComponentOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateInferenceComponentRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.UpdateInferenceComponentOutput)
	return ret0, ret1
}

// UpdateInferenceComponentRequest indicates an expected call of UpdateInferenceComponentRequest.
func (mr *MockSageMakerAPIMockRecorder) UpdateInferenceComponentRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateInferenceComponentRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).UpdateInferenceComponentRequest), arg0)
}

// UpdateInferenceComponentRuntimeConfig mocks base method.
func (m *MockSageMakerAPI) UpdateInferenceComponentRuntimeConfig(arg0 *sagemaker.UpdateInferenceComponentRuntimeConfigInput) (*sagemaker.UpdateInferenceComponentRuntimeConfigOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateInferenceComponentRuntimeConfig", arg0)
	ret0, _ := ret[0].(*sagemaker.UpdateInferenceComponentRuntimeConfigOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateInferenceComponentRuntimeConfig indicates an expected call of UpdateInferenceComponentRuntimeConfig.
func (mr *MockSageMakerAPIMockRecorder) UpdateInferenceComponentRuntimeConfig(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateInferenceComponentRuntimeConfig", reflect.TypeOf((*MockSageMakerAPI)(nil).UpdateInferenceComponentRuntimeConfig), arg0)
}

// UpdateInferenceComponentRuntimeConfigRequest mocks base method.
func (m *MockSageMakerAPI) UpdateInferenceComponentRuntimeConfigRequest(arg0 *sagemaker.UpdateInferenceComponentRuntimeConfigInput) (*request.Request, *sagemaker.UpdateInferenceComponentRuntimeConfigOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateInferenceComponentRuntimeConfigRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.UpdateInferenceComponentRuntimeConfigOutput)
	return ret0, ret1
}

// UpdateInferenceComponentRuntimeConfigRequest indicates an expected call of UpdateInferenceComponentRuntimeConfigRequest.
func (mr *MockSageMakerAPIMockRecorder) UpdateInferenceComponentRuntimeConfigRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateInferenceComponentRuntimeConfigRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).UpdateInferenceComponentRuntimeConfigRequest), arg0)
}

// UpdateInferenceComponentRuntimeConfigWithContext mocks base method.
func (m *MockSageMakerAPI) UpdateInferenceComponentRuntimeConfigWithContext(arg0 aws.Context, arg1 *sagemaker.UpdateInferenceComponentRuntimeConfigInput, arg2 ...request.Option) (*sagemaker.UpdateInferenceComponentRuntimeConfigOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateInferenceComponentRuntimeConfigWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.UpdateInferenceComponentRuntimeConfigOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateInferenceComponentRuntimeConfigWithContext indicates an expected call of UpdateInferenceComponentRuntimeConfigWithContext.
func (mr *MockSageMakerAPIMockRecorder) UpdateInferenceComponentRuntimeConfigWithContext(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, "UpdateInferenceComponentRuntimeConfigWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).UpdateInferenceComponentRuntimeConfigWithContext), varargs...)
}

// UpdateInferenceComponentWithContext mocks base method.
func (m *MockSageMakerAPI) UpdateInferenceComponentWithContext(arg0 aws.Context, arg1 *sagemaker.UpdateInferenceComponentInput, arg2 ...request.Option) (*sagemaker.UpdateInferenceComponentOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateInferenceComponentWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.UpdateInferenceComponentOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateInferenceComponentWithContext indicates an expected call of UpdateInferenceComponentWithContext.
func (mr *MockSageMakerAPIMockRecorder) UpdateInferenceComponentWithContext(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, "UpdateInferenceComponentWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).UpdateInferenceComponentWithContext), varargs...)
}

// UpdateInferenceExperiment mocks base method.
func (m *MockSageMakerAPI) UpdateInferenceExperiment(arg0 *sagemaker.UpdateInferenceExperimentInput) (*sagemaker.UpdateInferenceExperimentOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateInferenceExperiment", arg0)
	ret0, _ := ret[0].(*sagemaker.UpdateInferenceExperimentOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateInferenceExperiment indicates an expected call of UpdateInferenceExperiment.
func (mr *MockSageMakerAPIMockRecorder) UpdateInferenceExperiment(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateInferenceExperiment", reflect.TypeOf((*MockSageMakerAPI)(nil).UpdateInferenceExperiment), arg0)
}

// UpdateInferenceExperimentRequest mocks base method.
func (m *MockSageMakerAPI) UpdateInferenceExperimentRequest(arg0 *sagemaker.UpdateInferenceExperimentInput) (*request.Request, *sagemaker.UpdateInferenceExperimentOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateInferenceExperimentRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.UpdateInferenceExperimentOutput)
	return ret0, ret1
}

// UpdateInferenceExperimentRequest indicates an expected call of UpdateInferenceExperimentRequest.
func (mr *MockSageMakerAPIMockRecorder) UpdateInferenceExperimentRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateInferenceExperimentRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).UpdateInferenceExperimentRequest), arg0)
}

// UpdateInferenceExperimentWithContext mocks base method.
func (m *MockSageMakerAPI) UpdateInferenceExperimentWithContext(arg0 aws.Context, arg1 *sagemaker.UpdateInferenceExperimentInput, arg2 ...request.Option) (*sagemaker.UpdateInferenceExperimentOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateInferenceExperimentWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.UpdateInferenceExperimentOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateInferenceExperimentWithContext indicates an expected call of UpdateInferenceExperimentWithContext.
func (mr *MockSageMakerAPIMockRecorder) UpdateInferenceExperimentWithContext(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, "UpdateInferenceExperimentWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).UpdateInferenceExperimentWithContext), varargs...)
}

// UpdateMlflowTrackingServer mocks base method.
func (m *MockSageMakerAPI) UpdateMlflowTrackingServer(arg0 *sagemaker.UpdateMlflowTrackingServerInput) (*sagemaker.UpdateMlflowTrackingServerOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateMlflowTrackingServer", arg0)
	ret0, _ := ret[0].(*sagemaker.UpdateMlflowTrackingServerOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateMlflowTrackingServer indicates an expected call of UpdateMlflowTrackingServer.
func (mr *MockSageMakerAPIMockRecorder) UpdateMlflowTrackingServer(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateMlflowTrackingServer", reflect.TypeOf((*MockSageMakerAPI)(nil).UpdateMlflowTrackingServer), arg0)
}

// UpdateMlflowTrackingServerRequest mocks base method.
func (m *MockSageMakerAPI) UpdateMlflowTrackingServerRequest(arg0 *sagemaker.UpdateMlflowTrackingServerInput) (*request.Request, *sagemaker.UpdateMlflowTrackingServerOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateMlflowTrackingServerRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.UpdateMlflowTrackingServerOutput)
	return ret0, ret1
}

// UpdateMlflowTrackingServerRequest indicates an expected call of UpdateMlflowTrackingServerRequest.
func (mr *MockSageMakerAPIMockRecorder) UpdateMlflowTrackingServerRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateMlflowTrackingServerRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).UpdateMlflowTrackingServerRequest), arg0)
}

// UpdateMlflowTrackingServerWithContext mocks base method.
func (m *MockSageMakerAPI) UpdateMlflowTrackingServerWithContext(arg0 aws.Context, arg1 *sagemaker.UpdateMlflowTrackingServerInput, arg2 ...request.Option) (*sagemaker.UpdateMlflowTrackingServerOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateMlflowTrackingServerWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.UpdateMlflowTrackingServerOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateMlflowTrackingServerWithContext indicates an expected call of UpdateMlflowTrackingServerWithContext.
func (mr *MockSageMakerAPIMockRecorder) UpdateMlflowTrackingServerWithContext(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, "UpdateMlflowTrackingServerWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).UpdateMlflowTrackingServerWithContext), varargs...)
}

// UpdateModelCard mocks base method.
func (m *MockSageMakerAPI) UpdateModelCard(arg0 *sagemaker.UpdateModelCardInput) (*sagemaker.UpdateModelCardOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateModelCard", arg0)
	ret0, _ := ret[0].(*sagemaker.UpdateModelCardOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateModelCard indicates an expected call of UpdateModelCard.
func (mr *MockSageMakerAPIMockRecorder) UpdateModelCard(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateModelCard", reflect.TypeOf((*MockSageMakerAPI)(nil).UpdateModelCard), arg0)
}

// UpdateModelCardRequest mocks base method.
func (m *MockSageMakerAPI) UpdateModelCardRequest(arg0 *sagemaker.UpdateModelCardInput) (*request.Request, *sagemaker.UpdateModelCardOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateModelCardRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.UpdateModelCardOutput)
	return ret0, ret1
}

// UpdateModelCardRequest indicates an expected call of UpdateModelCardRequest.
func (mr *MockSageMakerAPIMockRecorder) UpdateModelCardRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateModelCardRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).UpdateModelCardRequest), arg0)
}

// UpdateModelCardWithContext mocks base method.
func (m *MockSageMakerAPI) UpdateModelCardWithContext(arg0 aws.Context, arg1 *sagemaker.UpdateModelCardInput, arg2 ...request.Option) (*sagemaker.UpdateModelCardOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateModelCardWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.UpdateModelCardOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateModelCardWithContext indicates an expected call of UpdateModelCardWithContext.
func (mr *MockSageMakerAPIMockRecorder) UpdateModelCardWithContext(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, "UpdateModelCardWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).UpdateModelCardWithContext), varargs...)
}

// UpdateModelPackage mocks base method.
func (m *MockSageMakerAPI) UpdateModelPackage(arg0 *sagemaker.UpdateModelPackageInput) (*sagemaker.UpdateModelPackageOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateModelPackage", arg0)
	ret0, _ := ret[0].(*sagemaker.UpdateModelPackageOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateModelPackage indicates an expected call of UpdateModelPackage.
func (mr *MockSageMakerAPIMockRecorder) UpdateModelPackage(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateModelPackage", reflect.TypeOf((*MockSageMakerAPI)(nil).UpdateModelPackage), arg0)
}

// UpdateModelPackageRequest mocks base method.
func (m *MockSageMakerAPI) UpdateModelPackageRequest(arg0 *sagemaker.UpdateModelPackageInput) (*request.Request, *sagemaker.UpdateModelPackageOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateModelPackageRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.UpdateModelPackageOutput)
	return ret0, ret1
}

// UpdateModelPackageRequest indicates an expected call of UpdateModelPackageRequest.
func (mr *MockSageMakerAPIMockRecorder) UpdateModelPackageRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateModelPackageRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).UpdateModelPackageRequest), arg0)
}

// UpdateModelPackageWithContext mocks base method.
func (m *MockSageMakerAPI) UpdateModelPackageWithContext(arg0 aws.Context, arg1 *sagemaker.UpdateModelPackageInput, arg2 ...request.Option) (*sagemaker.UpdateModelPackageOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateModelPackageWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.UpdateModelPackageOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateModelPackageWithContext indicates an expected call of UpdateModelPackageWithContext.
func (mr *MockSageMakerAPIMockRecorder) UpdateModelPackageWithContext(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, "UpdateModelPackageWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).UpdateModelPackageWithContext), varargs...)
}

// UpdateMonitoringAlert mocks base method.
func (m *MockSageMakerAPI) UpdateMonitoringAlert(arg0 *sagemaker.UpdateMonitoringAlertInput) (*sagemaker.UpdateMonitoringAlertOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateMonitoringAlert", arg0)
	ret0, _ := ret[0].(*sagemaker.UpdateMonitoringAlertOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateMonitoringAlert indicates an expected call of UpdateMonitoringAlert.
func (mr *MockSageMakerAPIMockRecorder) UpdateMonitoringAlert(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateMonitoringAlert", reflect.TypeOf((*MockSageMakerAPI)(nil).UpdateMonitoringAlert), arg0)
}

// UpdateMonitoringAlertRequest mocks base method.
func (m *MockSageMakerAPI) UpdateMonitoringAlertRequest(arg0 *sagemaker.UpdateMonitoringAlertInput) (*request.Request, *sagemaker.UpdateMonitoringAlertOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateMonitoringAlertRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.UpdateMonitoringAlertOutput)
	return ret0, ret1
}

// UpdateMonitoringAlertRequest indicates an expected call of UpdateMonitoringAlertRequest.
func (mr *MockSageMakerAPIMockRecorder) UpdateMonitoringAlertRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateMonitoringAlertRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).UpdateMonitoringAlertRequest), arg0)
}

// UpdateMonitoringAlertWithContext mocks base method.
func (m *MockSageMakerAPI) UpdateMonitoringAlertWithContext(arg0 aws.Context, arg1 *sagemaker.UpdateMonitoringAlertInput, arg2 ...request.Option) (*sagemaker.UpdateMonitoringAlertOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateMonitoringAlertWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.UpdateMonitoringAlertOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateMonitoringAlertWithContext indicates an expected call of UpdateMonitoringAlertWithContext.
func (mr *MockSageMakerAPIMockRecorder) UpdateMonitoringAlertWithContext(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, "UpdateMonitoringAlertWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).UpdateMonitoringAlertWithContext), varargs...)
}

// UpdateMonitoringSchedule mocks base method.
func (m *MockSageMakerAPI) UpdateMonitoringSchedule(arg0 *sagemaker.UpdateMonitoringScheduleInput) (*sagemaker.UpdateMonitoringScheduleOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateMonitoringSchedule", arg0)
	ret0, _ := ret[0].(*sagemaker.UpdateMonitoringScheduleOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateMonitoringSchedule indicates an expected call of UpdateMonitoringSchedule.
func (mr *MockSageMakerAPIMockRecorder) UpdateMonitoringSchedule(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateMonitoringSchedule", reflect.TypeOf((*MockSageMakerAPI)(nil).UpdateMonitoringSchedule), arg0)
}

// UpdateMonitoringScheduleRequest mocks base method.
func (m *MockSageMakerAPI) UpdateMonitoringScheduleRequest(arg0 *sagemaker.UpdateMonitoringScheduleInput) (*request.Request, *sagemaker.UpdateMonitoringScheduleOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateMonitoringScheduleRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.UpdateMonitoringScheduleOutput)
	return ret0, ret1
}

// UpdateMonitoringScheduleRequest indicates an expected call of UpdateMonitoringScheduleRequest.
func (mr *MockSageMakerAPIMockRecorder) UpdateMonitoringScheduleRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateMonitoringScheduleRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).UpdateMonitoringScheduleRequest), arg0)
}

// UpdateMonitoringScheduleWithContext mocks base method.
func (m *MockSageMakerAPI) UpdateMonitoringScheduleWithContext(arg0 aws.Context, arg1 *sagemaker.UpdateMonitoringScheduleInput, arg2 ...request.Option) (*sagemaker.UpdateMonitoringScheduleOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateMonitoringScheduleWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.UpdateMonitoringScheduleOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateMonitoringScheduleWithContext indicates an expected call of UpdateMonitoringScheduleWithContext.
func (mr *MockSageMakerAPIMockRecorder) UpdateMonitoringScheduleWithContext(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, "UpdateMonitoringScheduleWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).UpdateMonitoringScheduleWithContext), varargs...)
}

// UpdateNotebookInstance mocks base method.
func (m *MockSageMakerAPI) UpdateNotebookInstance(arg0 *sagemaker.UpdateNotebookInstanceInput) (*sagemaker.UpdateNotebookInstanceOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateNotebookInstance", arg0)
	ret0, _ := ret[0].(*sagemaker.UpdateNotebookInstanceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateNotebookInstance indicates an expected call of UpdateNotebookInstance.
func (mr *MockSageMakerAPIMockRecorder) UpdateNotebookInstance(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateNotebookInstance", reflect.TypeOf((*MockSageMakerAPI)(nil).UpdateNotebookInstance), arg0)
}

// UpdateNotebookInstanceLifecycleConfig mocks base method.
func (m *MockSageMakerAPI) UpdateNotebookInstanceLifecycleConfig(arg0 *sagemaker.UpdateNotebookInstanceLifecycleConfigInput) (*sagemaker.UpdateNotebookInstanceLifecycleConfigOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateNotebookInstanceLifecycleConfig", arg0)
	ret0, _ := ret[0].(*sagemaker.UpdateNotebookInstanceLifecycleConfigOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateNotebookInstanceLifecycleConfig indicates an expected call of UpdateNotebookInstanceLifecycleConfig.
func (mr *MockSageMakerAPIMockRecorder) UpdateNotebookInstanceLifecycleConfig(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateNotebookInstanceLifecycleConfig", reflect.TypeOf((*MockSageMakerAPI)(nil).UpdateNotebookInstanceLifecycleConfig), arg0)
}

// UpdateNotebookInstanceLifecycleConfigRequest mocks base method.
func (m *MockSageMakerAPI) UpdateNotebookInstanceLifecycleConfigRequest(arg0 *sagemaker.UpdateNotebookInstanceLifecycleConfigInput) (*request.Request, *sagemaker.UpdateNotebookInstanceLifecycleConfigOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateNotebookInstanceLifecycleConfigRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.UpdateNotebookInstanceLifecycleConfigOutput)
	return ret0, ret1
}

// UpdateNotebookInstanceLifecycleConfigRequest indicates an expected call of UpdateNotebookInstanceLifecycleConfigRequest.
func (mr *MockSageMakerAPIMockRecorder) UpdateNotebookInstanceLifecycleConfigRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateNotebookInstanceLifecycleConfigRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).UpdateNotebookInstanceLifecycleConfigRequest), arg0)
}

// UpdateNotebookInstanceLifecycleConfigWithContext mocks base method.
func (m *MockSageMakerAPI) UpdateNotebookInstanceLifecycleConfigWithContext(arg0 aws.Context, arg1 *sagemaker.UpdateNotebookInstanceLifecycleConfigInput, arg2 ...request.Option) (*sagemaker.UpdateNotebookInstanceLifecycleConfigOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateNotebookInstanceLifecycleConfigWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.UpdateNotebookInstanceLifecycleConfigOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateNotebookInstanceLifecycleConfigWithContext indicates an expected call of UpdateNotebookInstanceLifecycleConfigWithContext.
func (mr *MockSageMakerAPIMockRecorder) UpdateNotebookInstanceLifecycleConfigWithContext(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, "UpdateNotebookInstanceLifecycleConfigWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).UpdateNotebookInstanceLifecycleConfigWithContext), varargs...)
}

// UpdateNotebookInstanceRequest mocks base method.
func (m *MockSageMakerAPI) UpdateNotebookInstanceRequest(arg0 *sagemaker.UpdateNotebookInstanceInput) (*request.Request, *sagemaker.UpdateNotebookInstanceOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateNotebookInstanceRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.UpdateNotebookInstanceOutput)
	return ret0, ret1
}

// UpdateNotebookInstanceRequest indicates an expected call of UpdateNotebookInstanceRequest.
func (mr *MockSageMakerAPIMockRecorder) UpdateNotebookInstanceRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateNotebookInstanceRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).UpdateNotebookInstanceRequest), arg0)
}

// UpdateNotebookInstanceWithContext mocks base method.
func (m *MockSageMakerAPI) UpdateNotebookInstanceWithContext(arg0 aws.Context, arg1 *sagemaker.UpdateNotebookInstanceInput, arg2 ...request.Option) (*sagemaker.UpdateNotebookInstanceOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateNotebookInstanceWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.UpdateNotebookInstanceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateNotebookInstanceWithContext indicates an expected call of UpdateNotebookInstanceWithContext.
func (mr *MockSageMakerAPIMockRecorder) UpdateNotebookInstanceWithContext(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, "UpdateNotebookInstanceWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).UpdateNotebookInstanceWithContext), varargs...)
}

// UpdatePipeline mocks base method.
func (m *MockSageMakerAPI) UpdatePipeline(arg0 *sagemaker.UpdatePipelineInput) (*sagemaker.UpdatePipelineOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdatePipeline", arg0)
	ret0, _ := ret[0].(*sagemaker.UpdatePipelineOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdatePipeline indicates an expected call of UpdatePipeline.
func (mr *MockSageMakerAPIMockRecorder) UpdatePipeline(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatePipeline", reflect.TypeOf((*MockSageMakerAPI)(nil).UpdatePipeline), arg0)
}

// UpdatePipelineExecution mocks base method.
func (m *MockSageMakerAPI) UpdatePipelineExecution(arg0 *sagemaker.UpdatePipelineExecutionInput) (*sagemaker.UpdatePipelineExecutionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdatePipelineExecution", arg0)
	ret0, _ := ret[0].(*sagemaker.UpdatePipelineExecutionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdatePipelineExecution indicates an expected call of UpdatePipelineExecution.
func (mr *MockSageMakerAPIMockRecorder) UpdatePipelineExecution(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatePipelineExecution", reflect.TypeOf((*MockSageMakerAPI)(nil).UpdatePipelineExecution), arg0)
}

// UpdatePipelineExecutionRequest mocks base method.
func (m *MockSageMakerAPI) UpdatePipelineExecutionRequest(arg0 *sagemaker.UpdatePipelineExecutionInput) (*request.Request, *sagemaker.UpdatePipelineExecutionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdatePipelineExecutionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.UpdatePipelineExecutionOutput)
	return ret0, ret1
}

// UpdatePipelineExecutionRequest indicates an expected call of UpdatePipelineExecutionRequest.
func (mr *MockSageMakerAPIMockRecorder) UpdatePipelineExecutionRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatePipelineExecutionRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).UpdatePipelineExecutionRequest), arg0)
}

// UpdatePipelineExecutionWithContext mocks base method.
func (m *MockSageMakerAPI) UpdatePipelineExecutionWithContext(arg0 aws.Context, arg1 *sagemaker.UpdatePipelineExecutionInput, arg2 ...request.Option) (*sagemaker.UpdatePipelineExecutionOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdatePipelineExecutionWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.UpdatePipelineExecutionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdatePipelineExecutionWithContext indicates an expected call of UpdatePipelineExecutionWithContext.
func (mr *MockSageMakerAPIMockRecorder) UpdatePipelineExecutionWithContext(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, "UpdatePipelineExecutionWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).UpdatePipelineExecutionWithContext), varargs...)
}

// UpdatePipelineRequest mocks base method.
func (m *MockSageMakerAPI) UpdatePipelineRequest(arg0 *sagemaker.UpdatePipelineInput) (*request.Request, *sagemaker.UpdatePipelineOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdatePipelineRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.UpdatePipelineOutput)
	return ret0, ret1
}

// UpdatePipelineRequest indicates an expected call of UpdatePipelineRequest.
func (mr *MockSageMakerAPIMockRecorder) UpdatePipelineRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatePipelineRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).UpdatePipelineRequest), arg0)
}

// UpdatePipelineWithContext mocks base method.
func (m *MockSageMakerAPI) UpdatePipelineWithContext(arg0 aws.Context, arg1 *sagemaker.UpdatePipelineInput, arg2 ...request.Option) (*sagemaker.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].(*sagemaker.UpdatePipelineOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdatePipelineWithContext indicates an expected call of UpdatePipelineWithContext.
func (mr *MockSageMakerAPIMockRecorder) 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((*MockSageMakerAPI)(nil).UpdatePipelineWithContext), varargs...)
}

// UpdateProject mocks base method.
func (m *MockSageMakerAPI) UpdateProject(arg0 *sagemaker.UpdateProjectInput) (*sagemaker.UpdateProjectOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateProject", arg0)
	ret0, _ := ret[0].(*sagemaker.UpdateProjectOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateProject indicates an expected call of UpdateProject.
func (mr *MockSageMakerAPIMockRecorder) UpdateProject(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateProject", reflect.TypeOf((*MockSageMakerAPI)(nil).UpdateProject), arg0)
}

// UpdateProjectRequest mocks base method.
func (m *MockSageMakerAPI) UpdateProjectRequest(arg0 *sagemaker.UpdateProjectInput) (*request.Request, *sagemaker.UpdateProjectOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateProjectRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.UpdateProjectOutput)
	return ret0, ret1
}

// UpdateProjectRequest indicates an expected call of UpdateProjectRequest.
func (mr *MockSageMakerAPIMockRecorder) UpdateProjectRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateProjectRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).UpdateProjectRequest), arg0)
}

// UpdateProjectWithContext mocks base method.
func (m *MockSageMakerAPI) UpdateProjectWithContext(arg0 aws.Context, arg1 *sagemaker.UpdateProjectInput, arg2 ...request.Option) (*sagemaker.UpdateProjectOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateProjectWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.UpdateProjectOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateProjectWithContext indicates an expected call of UpdateProjectWithContext.
func (mr *MockSageMakerAPIMockRecorder) UpdateProjectWithContext(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, "UpdateProjectWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).UpdateProjectWithContext), varargs...)
}

// UpdateSpace mocks base method.
func (m *MockSageMakerAPI) UpdateSpace(arg0 *sagemaker.UpdateSpaceInput) (*sagemaker.UpdateSpaceOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateSpace", arg0)
	ret0, _ := ret[0].(*sagemaker.UpdateSpaceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateSpace indicates an expected call of UpdateSpace.
func (mr *MockSageMakerAPIMockRecorder) UpdateSpace(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateSpace", reflect.TypeOf((*MockSageMakerAPI)(nil).UpdateSpace), arg0)
}

// UpdateSpaceRequest mocks base method.
func (m *MockSageMakerAPI) UpdateSpaceRequest(arg0 *sagemaker.UpdateSpaceInput) (*request.Request, *sagemaker.UpdateSpaceOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateSpaceRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.UpdateSpaceOutput)
	return ret0, ret1
}

// UpdateSpaceRequest indicates an expected call of UpdateSpaceRequest.
func (mr *MockSageMakerAPIMockRecorder) UpdateSpaceRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateSpaceRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).UpdateSpaceRequest), arg0)
}

// UpdateSpaceWithContext mocks base method.
func (m *MockSageMakerAPI) UpdateSpaceWithContext(arg0 aws.Context, arg1 *sagemaker.UpdateSpaceInput, arg2 ...request.Option) (*sagemaker.UpdateSpaceOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateSpaceWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.UpdateSpaceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateSpaceWithContext indicates an expected call of UpdateSpaceWithContext.
func (mr *MockSageMakerAPIMockRecorder) UpdateSpaceWithContext(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, "UpdateSpaceWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).UpdateSpaceWithContext), varargs...)
}

// UpdateTrainingJob mocks base method.
func (m *MockSageMakerAPI) UpdateTrainingJob(arg0 *sagemaker.UpdateTrainingJobInput) (*sagemaker.UpdateTrainingJobOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateTrainingJob", arg0)
	ret0, _ := ret[0].(*sagemaker.UpdateTrainingJobOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateTrainingJob indicates an expected call of UpdateTrainingJob.
func (mr *MockSageMakerAPIMockRecorder) UpdateTrainingJob(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTrainingJob", reflect.TypeOf((*MockSageMakerAPI)(nil).UpdateTrainingJob), arg0)
}

// UpdateTrainingJobRequest mocks base method.
func (m *MockSageMakerAPI) UpdateTrainingJobRequest(arg0 *sagemaker.UpdateTrainingJobInput) (*request.Request, *sagemaker.UpdateTrainingJobOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateTrainingJobRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.UpdateTrainingJobOutput)
	return ret0, ret1
}

// UpdateTrainingJobRequest indicates an expected call of UpdateTrainingJobRequest.
func (mr *MockSageMakerAPIMockRecorder) UpdateTrainingJobRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTrainingJobRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).UpdateTrainingJobRequest), arg0)
}

// UpdateTrainingJobWithContext mocks base method.
func (m *MockSageMakerAPI) UpdateTrainingJobWithContext(arg0 aws.Context, arg1 *sagemaker.UpdateTrainingJobInput, arg2 ...request.Option) (*sagemaker.UpdateTrainingJobOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateTrainingJobWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.UpdateTrainingJobOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateTrainingJobWithContext indicates an expected call of UpdateTrainingJobWithContext.
func (mr *MockSageMakerAPIMockRecorder) UpdateTrainingJobWithContext(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, "UpdateTrainingJobWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).UpdateTrainingJobWithContext), varargs...)
}

// UpdateTrial mocks base method.
func (m *MockSageMakerAPI) UpdateTrial(arg0 *sagemaker.UpdateTrialInput) (*sagemaker.UpdateTrialOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateTrial", arg0)
	ret0, _ := ret[0].(*sagemaker.UpdateTrialOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateTrial indicates an expected call of UpdateTrial.
func (mr *MockSageMakerAPIMockRecorder) UpdateTrial(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTrial", reflect.TypeOf((*MockSageMakerAPI)(nil).UpdateTrial), arg0)
}

// UpdateTrialComponent mocks base method.
func (m *MockSageMakerAPI) UpdateTrialComponent(arg0 *sagemaker.UpdateTrialComponentInput) (*sagemaker.UpdateTrialComponentOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateTrialComponent", arg0)
	ret0, _ := ret[0].(*sagemaker.UpdateTrialComponentOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateTrialComponent indicates an expected call of UpdateTrialComponent.
func (mr *MockSageMakerAPIMockRecorder) UpdateTrialComponent(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTrialComponent", reflect.TypeOf((*MockSageMakerAPI)(nil).UpdateTrialComponent), arg0)
}

// UpdateTrialComponentRequest mocks base method.
func (m *MockSageMakerAPI) UpdateTrialComponentRequest(arg0 *sagemaker.UpdateTrialComponentInput) (*request.Request, *sagemaker.UpdateTrialComponentOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateTrialComponentRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.UpdateTrialComponentOutput)
	return ret0, ret1
}

// UpdateTrialComponentRequest indicates an expected call of UpdateTrialComponentRequest.
func (mr *MockSageMakerAPIMockRecorder) UpdateTrialComponentRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTrialComponentRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).UpdateTrialComponentRequest), arg0)
}

// UpdateTrialComponentWithContext mocks base method.
func (m *MockSageMakerAPI) UpdateTrialComponentWithContext(arg0 aws.Context, arg1 *sagemaker.UpdateTrialComponentInput, arg2 ...request.Option) (*sagemaker.UpdateTrialComponentOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateTrialComponentWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.UpdateTrialComponentOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateTrialComponentWithContext indicates an expected call of UpdateTrialComponentWithContext.
func (mr *MockSageMakerAPIMockRecorder) UpdateTrialComponentWithContext(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, "UpdateTrialComponentWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).UpdateTrialComponentWithContext), varargs...)
}

// UpdateTrialRequest mocks base method.
func (m *MockSageMakerAPI) UpdateTrialRequest(arg0 *sagemaker.UpdateTrialInput) (*request.Request, *sagemaker.UpdateTrialOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateTrialRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.UpdateTrialOutput)
	return ret0, ret1
}

// UpdateTrialRequest indicates an expected call of UpdateTrialRequest.
func (mr *MockSageMakerAPIMockRecorder) UpdateTrialRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTrialRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).UpdateTrialRequest), arg0)
}

// UpdateTrialWithContext mocks base method.
func (m *MockSageMakerAPI) UpdateTrialWithContext(arg0 aws.Context, arg1 *sagemaker.UpdateTrialInput, arg2 ...request.Option) (*sagemaker.UpdateTrialOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateTrialWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.UpdateTrialOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateTrialWithContext indicates an expected call of UpdateTrialWithContext.
func (mr *MockSageMakerAPIMockRecorder) UpdateTrialWithContext(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, "UpdateTrialWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).UpdateTrialWithContext), varargs...)
}

// UpdateUserProfile mocks base method.
func (m *MockSageMakerAPI) UpdateUserProfile(arg0 *sagemaker.UpdateUserProfileInput) (*sagemaker.UpdateUserProfileOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateUserProfile", arg0)
	ret0, _ := ret[0].(*sagemaker.UpdateUserProfileOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateUserProfile indicates an expected call of UpdateUserProfile.
func (mr *MockSageMakerAPIMockRecorder) UpdateUserProfile(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateUserProfile", reflect.TypeOf((*MockSageMakerAPI)(nil).UpdateUserProfile), arg0)
}

// UpdateUserProfileRequest mocks base method.
func (m *MockSageMakerAPI) UpdateUserProfileRequest(arg0 *sagemaker.UpdateUserProfileInput) (*request.Request, *sagemaker.UpdateUserProfileOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateUserProfileRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.UpdateUserProfileOutput)
	return ret0, ret1
}

// UpdateUserProfileRequest indicates an expected call of UpdateUserProfileRequest.
func (mr *MockSageMakerAPIMockRecorder) UpdateUserProfileRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateUserProfileRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).UpdateUserProfileRequest), arg0)
}

// UpdateUserProfileWithContext mocks base method.
func (m *MockSageMakerAPI) UpdateUserProfileWithContext(arg0 aws.Context, arg1 *sagemaker.UpdateUserProfileInput, arg2 ...request.Option) (*sagemaker.UpdateUserProfileOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateUserProfileWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.UpdateUserProfileOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateUserProfileWithContext indicates an expected call of UpdateUserProfileWithContext.
func (mr *MockSageMakerAPIMockRecorder) UpdateUserProfileWithContext(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, "UpdateUserProfileWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).UpdateUserProfileWithContext), varargs...)
}

// UpdateWorkforce mocks base method.
func (m *MockSageMakerAPI) UpdateWorkforce(arg0 *sagemaker.UpdateWorkforceInput) (*sagemaker.UpdateWorkforceOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateWorkforce", arg0)
	ret0, _ := ret[0].(*sagemaker.UpdateWorkforceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateWorkforce indicates an expected call of UpdateWorkforce.
func (mr *MockSageMakerAPIMockRecorder) UpdateWorkforce(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateWorkforce", reflect.TypeOf((*MockSageMakerAPI)(nil).UpdateWorkforce), arg0)
}

// UpdateWorkforceRequest mocks base method.
func (m *MockSageMakerAPI) UpdateWorkforceRequest(arg0 *sagemaker.UpdateWorkforceInput) (*request.Request, *sagemaker.UpdateWorkforceOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateWorkforceRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.UpdateWorkforceOutput)
	return ret0, ret1
}

// UpdateWorkforceRequest indicates an expected call of UpdateWorkforceRequest.
func (mr *MockSageMakerAPIMockRecorder) UpdateWorkforceRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateWorkforceRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).UpdateWorkforceRequest), arg0)
}

// UpdateWorkforceWithContext mocks base method.
func (m *MockSageMakerAPI) UpdateWorkforceWithContext(arg0 aws.Context, arg1 *sagemaker.UpdateWorkforceInput, arg2 ...request.Option) (*sagemaker.UpdateWorkforceOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateWorkforceWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.UpdateWorkforceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateWorkforceWithContext indicates an expected call of UpdateWorkforceWithContext.
func (mr *MockSageMakerAPIMockRecorder) UpdateWorkforceWithContext(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, "UpdateWorkforceWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).UpdateWorkforceWithContext), varargs...)
}

// UpdateWorkteam mocks base method.
func (m *MockSageMakerAPI) UpdateWorkteam(arg0 *sagemaker.UpdateWorkteamInput) (*sagemaker.UpdateWorkteamOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateWorkteam", arg0)
	ret0, _ := ret[0].(*sagemaker.UpdateWorkteamOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateWorkteam indicates an expected call of UpdateWorkteam.
func (mr *MockSageMakerAPIMockRecorder) UpdateWorkteam(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateWorkteam", reflect.TypeOf((*MockSageMakerAPI)(nil).UpdateWorkteam), arg0)
}

// UpdateWorkteamRequest mocks base method.
func (m *MockSageMakerAPI) UpdateWorkteamRequest(arg0 *sagemaker.UpdateWorkteamInput) (*request.Request, *sagemaker.UpdateWorkteamOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateWorkteamRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sagemaker.UpdateWorkteamOutput)
	return ret0, ret1
}

// UpdateWorkteamRequest indicates an expected call of UpdateWorkteamRequest.
func (mr *MockSageMakerAPIMockRecorder) UpdateWorkteamRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateWorkteamRequest", reflect.TypeOf((*MockSageMakerAPI)(nil).UpdateWorkteamRequest), arg0)
}

// UpdateWorkteamWithContext mocks base method.
func (m *MockSageMakerAPI) UpdateWorkteamWithContext(arg0 aws.Context, arg1 *sagemaker.UpdateWorkteamInput, arg2 ...request.Option) (*sagemaker.UpdateWorkteamOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateWorkteamWithContext", varargs...)
	ret0, _ := ret[0].(*sagemaker.UpdateWorkteamOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateWorkteamWithContext indicates an expected call of UpdateWorkteamWithContext.
func (mr *MockSageMakerAPIMockRecorder) UpdateWorkteamWithContext(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, "UpdateWorkteamWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).UpdateWorkteamWithContext), varargs...)
}

// WaitUntilEndpointDeleted mocks base method.
func (m *MockSageMakerAPI) WaitUntilEndpointDeleted(arg0 *sagemaker.DescribeEndpointInput) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WaitUntilEndpointDeleted", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// WaitUntilEndpointDeleted indicates an expected call of WaitUntilEndpointDeleted.
func (mr *MockSageMakerAPIMockRecorder) WaitUntilEndpointDeleted(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilEndpointDeleted", reflect.TypeOf((*MockSageMakerAPI)(nil).WaitUntilEndpointDeleted), arg0)
}

// WaitUntilEndpointDeletedWithContext mocks base method.
func (m *MockSageMakerAPI) WaitUntilEndpointDeletedWithContext(arg0 aws.Context, arg1 *sagemaker.DescribeEndpointInput, arg2 ...request.WaiterOption) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "WaitUntilEndpointDeletedWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// WaitUntilEndpointDeletedWithContext indicates an expected call of WaitUntilEndpointDeletedWithContext.
func (mr *MockSageMakerAPIMockRecorder) WaitUntilEndpointDeletedWithContext(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, "WaitUntilEndpointDeletedWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).WaitUntilEndpointDeletedWithContext), varargs...)
}

// WaitUntilEndpointInService mocks base method.
func (m *MockSageMakerAPI) WaitUntilEndpointInService(arg0 *sagemaker.DescribeEndpointInput) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WaitUntilEndpointInService", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// WaitUntilEndpointInService indicates an expected call of WaitUntilEndpointInService.
func (mr *MockSageMakerAPIMockRecorder) WaitUntilEndpointInService(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilEndpointInService", reflect.TypeOf((*MockSageMakerAPI)(nil).WaitUntilEndpointInService), arg0)
}

// WaitUntilEndpointInServiceWithContext mocks base method.
func (m *MockSageMakerAPI) WaitUntilEndpointInServiceWithContext(arg0 aws.Context, arg1 *sagemaker.DescribeEndpointInput, arg2 ...request.WaiterOption) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "WaitUntilEndpointInServiceWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// WaitUntilEndpointInServiceWithContext indicates an expected call of WaitUntilEndpointInServiceWithContext.
func (mr *MockSageMakerAPIMockRecorder) WaitUntilEndpointInServiceWithContext(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, "WaitUntilEndpointInServiceWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).WaitUntilEndpointInServiceWithContext), varargs...)
}

// WaitUntilImageCreated mocks base method.
func (m *MockSageMakerAPI) WaitUntilImageCreated(arg0 *sagemaker.DescribeImageInput) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WaitUntilImageCreated", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// WaitUntilImageCreated indicates an expected call of WaitUntilImageCreated.
func (mr *MockSageMakerAPIMockRecorder) WaitUntilImageCreated(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilImageCreated", reflect.TypeOf((*MockSageMakerAPI)(nil).WaitUntilImageCreated), arg0)
}

// WaitUntilImageCreatedWithContext mocks base method.
func (m *MockSageMakerAPI) WaitUntilImageCreatedWithContext(arg0 aws.Context, arg1 *sagemaker.DescribeImageInput, arg2 ...request.WaiterOption) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "WaitUntilImageCreatedWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// WaitUntilImageCreatedWithContext indicates an expected call of WaitUntilImageCreatedWithContext.
func (mr *MockSageMakerAPIMockRecorder) WaitUntilImageCreatedWithContext(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, "WaitUntilImageCreatedWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).WaitUntilImageCreatedWithContext), varargs...)
}

// WaitUntilImageDeleted mocks base method.
func (m *MockSageMakerAPI) WaitUntilImageDeleted(arg0 *sagemaker.DescribeImageInput) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WaitUntilImageDeleted", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// WaitUntilImageDeleted indicates an expected call of WaitUntilImageDeleted.
func (mr *MockSageMakerAPIMockRecorder) WaitUntilImageDeleted(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilImageDeleted", reflect.TypeOf((*MockSageMakerAPI)(nil).WaitUntilImageDeleted), arg0)
}

// WaitUntilImageDeletedWithContext mocks base method.
func (m *MockSageMakerAPI) WaitUntilImageDeletedWithContext(arg0 aws.Context, arg1 *sagemaker.DescribeImageInput, arg2 ...request.WaiterOption) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "WaitUntilImageDeletedWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// WaitUntilImageDeletedWithContext indicates an expected call of WaitUntilImageDeletedWithContext.
func (mr *MockSageMakerAPIMockRecorder) WaitUntilImageDeletedWithContext(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, "WaitUntilImageDeletedWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).WaitUntilImageDeletedWithContext), varargs...)
}

// WaitUntilImageUpdated mocks base method.
func (m *MockSageMakerAPI) WaitUntilImageUpdated(arg0 *sagemaker.DescribeImageInput) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WaitUntilImageUpdated", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// WaitUntilImageUpdated indicates an expected call of WaitUntilImageUpdated.
func (mr *MockSageMakerAPIMockRecorder) WaitUntilImageUpdated(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilImageUpdated", reflect.TypeOf((*MockSageMakerAPI)(nil).WaitUntilImageUpdated), arg0)
}

// WaitUntilImageUpdatedWithContext mocks base method.
func (m *MockSageMakerAPI) WaitUntilImageUpdatedWithContext(arg0 aws.Context, arg1 *sagemaker.DescribeImageInput, arg2 ...request.WaiterOption) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "WaitUntilImageUpdatedWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// WaitUntilImageUpdatedWithContext indicates an expected call of WaitUntilImageUpdatedWithContext.
func (mr *MockSageMakerAPIMockRecorder) WaitUntilImageUpdatedWithContext(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, "WaitUntilImageUpdatedWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).WaitUntilImageUpdatedWithContext), varargs...)
}

// WaitUntilImageVersionCreated mocks base method.
func (m *MockSageMakerAPI) WaitUntilImageVersionCreated(arg0 *sagemaker.DescribeImageVersionInput) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WaitUntilImageVersionCreated", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// WaitUntilImageVersionCreated indicates an expected call of WaitUntilImageVersionCreated.
func (mr *MockSageMakerAPIMockRecorder) WaitUntilImageVersionCreated(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilImageVersionCreated", reflect.TypeOf((*MockSageMakerAPI)(nil).WaitUntilImageVersionCreated), arg0)
}

// WaitUntilImageVersionCreatedWithContext mocks base method.
func (m *MockSageMakerAPI) WaitUntilImageVersionCreatedWithContext(arg0 aws.Context, arg1 *sagemaker.DescribeImageVersionInput, arg2 ...request.WaiterOption) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "WaitUntilImageVersionCreatedWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// WaitUntilImageVersionCreatedWithContext indicates an expected call of WaitUntilImageVersionCreatedWithContext.
func (mr *MockSageMakerAPIMockRecorder) WaitUntilImageVersionCreatedWithContext(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, "WaitUntilImageVersionCreatedWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).WaitUntilImageVersionCreatedWithContext), varargs...)
}

// WaitUntilImageVersionDeleted mocks base method.
func (m *MockSageMakerAPI) WaitUntilImageVersionDeleted(arg0 *sagemaker.DescribeImageVersionInput) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WaitUntilImageVersionDeleted", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// WaitUntilImageVersionDeleted indicates an expected call of WaitUntilImageVersionDeleted.
func (mr *MockSageMakerAPIMockRecorder) WaitUntilImageVersionDeleted(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilImageVersionDeleted", reflect.TypeOf((*MockSageMakerAPI)(nil).WaitUntilImageVersionDeleted), arg0)
}

// WaitUntilImageVersionDeletedWithContext mocks base method.
func (m *MockSageMakerAPI) WaitUntilImageVersionDeletedWithContext(arg0 aws.Context, arg1 *sagemaker.DescribeImageVersionInput, arg2 ...request.WaiterOption) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "WaitUntilImageVersionDeletedWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// WaitUntilImageVersionDeletedWithContext indicates an expected call of WaitUntilImageVersionDeletedWithContext.
func (mr *MockSageMakerAPIMockRecorder) WaitUntilImageVersionDeletedWithContext(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, "WaitUntilImageVersionDeletedWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).WaitUntilImageVersionDeletedWithContext), varargs...)
}

// WaitUntilNotebookInstanceDeleted mocks base method.
func (m *MockSageMakerAPI) WaitUntilNotebookInstanceDeleted(arg0 *sagemaker.DescribeNotebookInstanceInput) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WaitUntilNotebookInstanceDeleted", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// WaitUntilNotebookInstanceDeleted indicates an expected call of WaitUntilNotebookInstanceDeleted.
func (mr *MockSageMakerAPIMockRecorder) WaitUntilNotebookInstanceDeleted(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilNotebookInstanceDeleted", reflect.TypeOf((*MockSageMakerAPI)(nil).WaitUntilNotebookInstanceDeleted), arg0)
}

// WaitUntilNotebookInstanceDeletedWithContext mocks base method.
func (m *MockSageMakerAPI) WaitUntilNotebookInstanceDeletedWithContext(arg0 aws.Context, arg1 *sagemaker.DescribeNotebookInstanceInput, arg2 ...request.WaiterOption) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "WaitUntilNotebookInstanceDeletedWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// WaitUntilNotebookInstanceDeletedWithContext indicates an expected call of WaitUntilNotebookInstanceDeletedWithContext.
func (mr *MockSageMakerAPIMockRecorder) WaitUntilNotebookInstanceDeletedWithContext(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, "WaitUntilNotebookInstanceDeletedWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).WaitUntilNotebookInstanceDeletedWithContext), varargs...)
}

// WaitUntilNotebookInstanceInService mocks base method.
func (m *MockSageMakerAPI) WaitUntilNotebookInstanceInService(arg0 *sagemaker.DescribeNotebookInstanceInput) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WaitUntilNotebookInstanceInService", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// WaitUntilNotebookInstanceInService indicates an expected call of WaitUntilNotebookInstanceInService.
func (mr *MockSageMakerAPIMockRecorder) WaitUntilNotebookInstanceInService(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilNotebookInstanceInService", reflect.TypeOf((*MockSageMakerAPI)(nil).WaitUntilNotebookInstanceInService), arg0)
}

// WaitUntilNotebookInstanceInServiceWithContext mocks base method.
func (m *MockSageMakerAPI) WaitUntilNotebookInstanceInServiceWithContext(arg0 aws.Context, arg1 *sagemaker.DescribeNotebookInstanceInput, arg2 ...request.WaiterOption) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "WaitUntilNotebookInstanceInServiceWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// WaitUntilNotebookInstanceInServiceWithContext indicates an expected call of WaitUntilNotebookInstanceInServiceWithContext.
func (mr *MockSageMakerAPIMockRecorder) WaitUntilNotebookInstanceInServiceWithContext(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, "WaitUntilNotebookInstanceInServiceWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).WaitUntilNotebookInstanceInServiceWithContext), varargs...)
}

// WaitUntilNotebookInstanceStopped mocks base method.
func (m *MockSageMakerAPI) WaitUntilNotebookInstanceStopped(arg0 *sagemaker.DescribeNotebookInstanceInput) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WaitUntilNotebookInstanceStopped", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// WaitUntilNotebookInstanceStopped indicates an expected call of WaitUntilNotebookInstanceStopped.
func (mr *MockSageMakerAPIMockRecorder) WaitUntilNotebookInstanceStopped(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilNotebookInstanceStopped", reflect.TypeOf((*MockSageMakerAPI)(nil).WaitUntilNotebookInstanceStopped), arg0)
}

// WaitUntilNotebookInstanceStoppedWithContext mocks base method.
func (m *MockSageMakerAPI) WaitUntilNotebookInstanceStoppedWithContext(arg0 aws.Context, arg1 *sagemaker.DescribeNotebookInstanceInput, arg2 ...request.WaiterOption) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "WaitUntilNotebookInstanceStoppedWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// WaitUntilNotebookInstanceStoppedWithContext indicates an expected call of WaitUntilNotebookInstanceStoppedWithContext.
func (mr *MockSageMakerAPIMockRecorder) WaitUntilNotebookInstanceStoppedWithContext(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, "WaitUntilNotebookInstanceStoppedWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).WaitUntilNotebookInstanceStoppedWithContext), varargs...)
}

// WaitUntilProcessingJobCompletedOrStopped mocks base method.
func (m *MockSageMakerAPI) WaitUntilProcessingJobCompletedOrStopped(arg0 *sagemaker.DescribeProcessingJobInput) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WaitUntilProcessingJobCompletedOrStopped", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// WaitUntilProcessingJobCompletedOrStopped indicates an expected call of WaitUntilProcessingJobCompletedOrStopped.
func (mr *MockSageMakerAPIMockRecorder) WaitUntilProcessingJobCompletedOrStopped(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilProcessingJobCompletedOrStopped", reflect.TypeOf((*MockSageMakerAPI)(nil).WaitUntilProcessingJobCompletedOrStopped), arg0)
}

// WaitUntilProcessingJobCompletedOrStoppedWithContext mocks base method.
func (m *MockSageMakerAPI) WaitUntilProcessingJobCompletedOrStoppedWithContext(arg0 aws.Context, arg1 *sagemaker.DescribeProcessingJobInput, arg2 ...request.WaiterOption) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "WaitUntilProcessingJobCompletedOrStoppedWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// WaitUntilProcessingJobCompletedOrStoppedWithContext indicates an expected call of WaitUntilProcessingJobCompletedOrStoppedWithContext.
func (mr *MockSageMakerAPIMockRecorder) WaitUntilProcessingJobCompletedOrStoppedWithContext(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, "WaitUntilProcessingJobCompletedOrStoppedWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).WaitUntilProcessingJobCompletedOrStoppedWithContext), varargs...)
}

// WaitUntilTrainingJobCompletedOrStopped mocks base method.
func (m *MockSageMakerAPI) WaitUntilTrainingJobCompletedOrStopped(arg0 *sagemaker.DescribeTrainingJobInput) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WaitUntilTrainingJobCompletedOrStopped", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// WaitUntilTrainingJobCompletedOrStopped indicates an expected call of WaitUntilTrainingJobCompletedOrStopped.
func (mr *MockSageMakerAPIMockRecorder) WaitUntilTrainingJobCompletedOrStopped(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilTrainingJobCompletedOrStopped", reflect.TypeOf((*MockSageMakerAPI)(nil).WaitUntilTrainingJobCompletedOrStopped), arg0)
}

// WaitUntilTrainingJobCompletedOrStoppedWithContext mocks base method.
func (m *MockSageMakerAPI) WaitUntilTrainingJobCompletedOrStoppedWithContext(arg0 aws.Context, arg1 *sagemaker.DescribeTrainingJobInput, arg2 ...request.WaiterOption) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "WaitUntilTrainingJobCompletedOrStoppedWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// WaitUntilTrainingJobCompletedOrStoppedWithContext indicates an expected call of WaitUntilTrainingJobCompletedOrStoppedWithContext.
func (mr *MockSageMakerAPIMockRecorder) WaitUntilTrainingJobCompletedOrStoppedWithContext(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, "WaitUntilTrainingJobCompletedOrStoppedWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).WaitUntilTrainingJobCompletedOrStoppedWithContext), varargs...)
}

// WaitUntilTransformJobCompletedOrStopped mocks base method.
func (m *MockSageMakerAPI) WaitUntilTransformJobCompletedOrStopped(arg0 *sagemaker.DescribeTransformJobInput) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WaitUntilTransformJobCompletedOrStopped", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// WaitUntilTransformJobCompletedOrStopped indicates an expected call of WaitUntilTransformJobCompletedOrStopped.
func (mr *MockSageMakerAPIMockRecorder) WaitUntilTransformJobCompletedOrStopped(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilTransformJobCompletedOrStopped", reflect.TypeOf((*MockSageMakerAPI)(nil).WaitUntilTransformJobCompletedOrStopped), arg0)
}

// WaitUntilTransformJobCompletedOrStoppedWithContext mocks base method.
func (m *MockSageMakerAPI) WaitUntilTransformJobCompletedOrStoppedWithContext(arg0 aws.Context, arg1 *sagemaker.DescribeTransformJobInput, arg2 ...request.WaiterOption) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "WaitUntilTransformJobCompletedOrStoppedWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// WaitUntilTransformJobCompletedOrStoppedWithContext indicates an expected call of WaitUntilTransformJobCompletedOrStoppedWithContext.
func (mr *MockSageMakerAPIMockRecorder) WaitUntilTransformJobCompletedOrStoppedWithContext(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, "WaitUntilTransformJobCompletedOrStoppedWithContext", reflect.TypeOf((*MockSageMakerAPI)(nil).WaitUntilTransformJobCompletedOrStoppedWithContext), varargs...)
}
