SageMakerAPI.go

// Code generated by mockery v2.2.2. DO NOT EDIT.

package mocks

import (
	context "context"

	request "github.com/aws/aws-sdk-go/aws/request"
	mock "github.com/stretchr/testify/mock"

	sagemaker "github.com/aws/aws-sdk-go/service/sagemaker"
)

// SageMakerAPI is an autogenerated mock type for the SageMakerAPI type
type SageMakerAPI struct {
	mock.Mock
}

// AddAssociation provides a mock function with given fields: _a0
func (_m *SageMakerAPI) AddAssociation(_a0 *sagemaker.AddAssociationInput) (*sagemaker.AddAssociationOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.AddAssociationOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.AddAssociationInput) *sagemaker.AddAssociationOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.AddAssociationOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.AddAssociationInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// AddAssociationRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) AddAssociationRequest(_a0 *sagemaker.AddAssociationInput) (*request.Request, *sagemaker.AddAssociationOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.AddAssociationInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.AddAssociationOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.AddAssociationInput) *sagemaker.AddAssociationOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.AddAssociationOutput)
		}
	}

	return r0, r1
}

// AddAssociationWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) AddAssociationWithContext(_a0 context.Context, _a1 *sagemaker.AddAssociationInput, _a2 ...request.Option) (*sagemaker.AddAssociationOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.AddAssociationOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.AddAssociationInput, ...request.Option) *sagemaker.AddAssociationOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.AddAssociationOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.AddAssociationInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// AddTags provides a mock function with given fields: _a0
func (_m *SageMakerAPI) AddTags(_a0 *sagemaker.AddTagsInput) (*sagemaker.AddTagsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.AddTagsOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.AddTagsInput) *sagemaker.AddTagsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.AddTagsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.AddTagsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// AddTagsRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) AddTagsRequest(_a0 *sagemaker.AddTagsInput) (*request.Request, *sagemaker.AddTagsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.AddTagsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.AddTagsOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.AddTagsInput) *sagemaker.AddTagsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.AddTagsOutput)
		}
	}

	return r0, r1
}

// AddTagsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) AddTagsWithContext(_a0 context.Context, _a1 *sagemaker.AddTagsInput, _a2 ...request.Option) (*sagemaker.AddTagsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.AddTagsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.AddTagsInput, ...request.Option) *sagemaker.AddTagsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.AddTagsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.AddTagsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// AssociateTrialComponent provides a mock function with given fields: _a0
func (_m *SageMakerAPI) AssociateTrialComponent(_a0 *sagemaker.AssociateTrialComponentInput) (*sagemaker.AssociateTrialComponentOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.AssociateTrialComponentOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.AssociateTrialComponentInput) *sagemaker.AssociateTrialComponentOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.AssociateTrialComponentOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.AssociateTrialComponentInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// AssociateTrialComponentRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) AssociateTrialComponentRequest(_a0 *sagemaker.AssociateTrialComponentInput) (*request.Request, *sagemaker.AssociateTrialComponentOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.AssociateTrialComponentInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.AssociateTrialComponentOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.AssociateTrialComponentInput) *sagemaker.AssociateTrialComponentOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.AssociateTrialComponentOutput)
		}
	}

	return r0, r1
}

// AssociateTrialComponentWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) AssociateTrialComponentWithContext(_a0 context.Context, _a1 *sagemaker.AssociateTrialComponentInput, _a2 ...request.Option) (*sagemaker.AssociateTrialComponentOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.AssociateTrialComponentOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.AssociateTrialComponentInput, ...request.Option) *sagemaker.AssociateTrialComponentOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.AssociateTrialComponentOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.AssociateTrialComponentInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateAction provides a mock function with given fields: _a0
func (_m *SageMakerAPI) CreateAction(_a0 *sagemaker.CreateActionInput) (*sagemaker.CreateActionOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.CreateActionOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.CreateActionInput) *sagemaker.CreateActionOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.CreateActionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.CreateActionInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateActionRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) CreateActionRequest(_a0 *sagemaker.CreateActionInput) (*request.Request, *sagemaker.CreateActionOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.CreateActionInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.CreateActionOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.CreateActionInput) *sagemaker.CreateActionOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.CreateActionOutput)
		}
	}

	return r0, r1
}

// CreateActionWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) CreateActionWithContext(_a0 context.Context, _a1 *sagemaker.CreateActionInput, _a2 ...request.Option) (*sagemaker.CreateActionOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.CreateActionOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.CreateActionInput, ...request.Option) *sagemaker.CreateActionOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.CreateActionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.CreateActionInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateAlgorithm provides a mock function with given fields: _a0
func (_m *SageMakerAPI) CreateAlgorithm(_a0 *sagemaker.CreateAlgorithmInput) (*sagemaker.CreateAlgorithmOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.CreateAlgorithmOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.CreateAlgorithmInput) *sagemaker.CreateAlgorithmOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.CreateAlgorithmOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.CreateAlgorithmInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateAlgorithmRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) CreateAlgorithmRequest(_a0 *sagemaker.CreateAlgorithmInput) (*request.Request, *sagemaker.CreateAlgorithmOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.CreateAlgorithmInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.CreateAlgorithmOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.CreateAlgorithmInput) *sagemaker.CreateAlgorithmOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.CreateAlgorithmOutput)
		}
	}

	return r0, r1
}

// CreateAlgorithmWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) CreateAlgorithmWithContext(_a0 context.Context, _a1 *sagemaker.CreateAlgorithmInput, _a2 ...request.Option) (*sagemaker.CreateAlgorithmOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.CreateAlgorithmOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.CreateAlgorithmInput, ...request.Option) *sagemaker.CreateAlgorithmOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.CreateAlgorithmOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.CreateAlgorithmInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateApp provides a mock function with given fields: _a0
func (_m *SageMakerAPI) CreateApp(_a0 *sagemaker.CreateAppInput) (*sagemaker.CreateAppOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.CreateAppOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.CreateAppInput) *sagemaker.CreateAppOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.CreateAppOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.CreateAppInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateAppImageConfig provides a mock function with given fields: _a0
func (_m *SageMakerAPI) CreateAppImageConfig(_a0 *sagemaker.CreateAppImageConfigInput) (*sagemaker.CreateAppImageConfigOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.CreateAppImageConfigOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.CreateAppImageConfigInput) *sagemaker.CreateAppImageConfigOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.CreateAppImageConfigOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.CreateAppImageConfigInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateAppImageConfigRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) CreateAppImageConfigRequest(_a0 *sagemaker.CreateAppImageConfigInput) (*request.Request, *sagemaker.CreateAppImageConfigOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.CreateAppImageConfigInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.CreateAppImageConfigOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.CreateAppImageConfigInput) *sagemaker.CreateAppImageConfigOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.CreateAppImageConfigOutput)
		}
	}

	return r0, r1
}

// CreateAppImageConfigWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) CreateAppImageConfigWithContext(_a0 context.Context, _a1 *sagemaker.CreateAppImageConfigInput, _a2 ...request.Option) (*sagemaker.CreateAppImageConfigOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.CreateAppImageConfigOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.CreateAppImageConfigInput, ...request.Option) *sagemaker.CreateAppImageConfigOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.CreateAppImageConfigOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.CreateAppImageConfigInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateAppRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) CreateAppRequest(_a0 *sagemaker.CreateAppInput) (*request.Request, *sagemaker.CreateAppOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.CreateAppInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.CreateAppOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.CreateAppInput) *sagemaker.CreateAppOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.CreateAppOutput)
		}
	}

	return r0, r1
}

// CreateAppWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) CreateAppWithContext(_a0 context.Context, _a1 *sagemaker.CreateAppInput, _a2 ...request.Option) (*sagemaker.CreateAppOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.CreateAppOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.CreateAppInput, ...request.Option) *sagemaker.CreateAppOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.CreateAppOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.CreateAppInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateArtifact provides a mock function with given fields: _a0
func (_m *SageMakerAPI) CreateArtifact(_a0 *sagemaker.CreateArtifactInput) (*sagemaker.CreateArtifactOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.CreateArtifactOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.CreateArtifactInput) *sagemaker.CreateArtifactOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.CreateArtifactOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.CreateArtifactInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateArtifactRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) CreateArtifactRequest(_a0 *sagemaker.CreateArtifactInput) (*request.Request, *sagemaker.CreateArtifactOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.CreateArtifactInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.CreateArtifactOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.CreateArtifactInput) *sagemaker.CreateArtifactOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.CreateArtifactOutput)
		}
	}

	return r0, r1
}

// CreateArtifactWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) CreateArtifactWithContext(_a0 context.Context, _a1 *sagemaker.CreateArtifactInput, _a2 ...request.Option) (*sagemaker.CreateArtifactOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.CreateArtifactOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.CreateArtifactInput, ...request.Option) *sagemaker.CreateArtifactOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.CreateArtifactOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.CreateArtifactInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateAutoMLJob provides a mock function with given fields: _a0
func (_m *SageMakerAPI) CreateAutoMLJob(_a0 *sagemaker.CreateAutoMLJobInput) (*sagemaker.CreateAutoMLJobOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.CreateAutoMLJobOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.CreateAutoMLJobInput) *sagemaker.CreateAutoMLJobOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.CreateAutoMLJobOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.CreateAutoMLJobInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateAutoMLJobRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) CreateAutoMLJobRequest(_a0 *sagemaker.CreateAutoMLJobInput) (*request.Request, *sagemaker.CreateAutoMLJobOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.CreateAutoMLJobInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.CreateAutoMLJobOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.CreateAutoMLJobInput) *sagemaker.CreateAutoMLJobOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.CreateAutoMLJobOutput)
		}
	}

	return r0, r1
}

// CreateAutoMLJobWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) CreateAutoMLJobWithContext(_a0 context.Context, _a1 *sagemaker.CreateAutoMLJobInput, _a2 ...request.Option) (*sagemaker.CreateAutoMLJobOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.CreateAutoMLJobOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.CreateAutoMLJobInput, ...request.Option) *sagemaker.CreateAutoMLJobOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.CreateAutoMLJobOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.CreateAutoMLJobInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateCodeRepository provides a mock function with given fields: _a0
func (_m *SageMakerAPI) CreateCodeRepository(_a0 *sagemaker.CreateCodeRepositoryInput) (*sagemaker.CreateCodeRepositoryOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.CreateCodeRepositoryOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.CreateCodeRepositoryInput) *sagemaker.CreateCodeRepositoryOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.CreateCodeRepositoryOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.CreateCodeRepositoryInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateCodeRepositoryRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) CreateCodeRepositoryRequest(_a0 *sagemaker.CreateCodeRepositoryInput) (*request.Request, *sagemaker.CreateCodeRepositoryOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.CreateCodeRepositoryInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.CreateCodeRepositoryOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.CreateCodeRepositoryInput) *sagemaker.CreateCodeRepositoryOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.CreateCodeRepositoryOutput)
		}
	}

	return r0, r1
}

// CreateCodeRepositoryWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) CreateCodeRepositoryWithContext(_a0 context.Context, _a1 *sagemaker.CreateCodeRepositoryInput, _a2 ...request.Option) (*sagemaker.CreateCodeRepositoryOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.CreateCodeRepositoryOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.CreateCodeRepositoryInput, ...request.Option) *sagemaker.CreateCodeRepositoryOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.CreateCodeRepositoryOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.CreateCodeRepositoryInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateCompilationJob provides a mock function with given fields: _a0
func (_m *SageMakerAPI) CreateCompilationJob(_a0 *sagemaker.CreateCompilationJobInput) (*sagemaker.CreateCompilationJobOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.CreateCompilationJobOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.CreateCompilationJobInput) *sagemaker.CreateCompilationJobOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.CreateCompilationJobOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.CreateCompilationJobInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateCompilationJobRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) CreateCompilationJobRequest(_a0 *sagemaker.CreateCompilationJobInput) (*request.Request, *sagemaker.CreateCompilationJobOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.CreateCompilationJobInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.CreateCompilationJobOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.CreateCompilationJobInput) *sagemaker.CreateCompilationJobOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.CreateCompilationJobOutput)
		}
	}

	return r0, r1
}

// CreateCompilationJobWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) CreateCompilationJobWithContext(_a0 context.Context, _a1 *sagemaker.CreateCompilationJobInput, _a2 ...request.Option) (*sagemaker.CreateCompilationJobOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.CreateCompilationJobOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.CreateCompilationJobInput, ...request.Option) *sagemaker.CreateCompilationJobOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.CreateCompilationJobOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.CreateCompilationJobInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateContext provides a mock function with given fields: _a0
func (_m *SageMakerAPI) CreateContext(_a0 *sagemaker.CreateContextInput) (*sagemaker.CreateContextOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.CreateContextOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.CreateContextInput) *sagemaker.CreateContextOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.CreateContextOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.CreateContextInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateContextRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) CreateContextRequest(_a0 *sagemaker.CreateContextInput) (*request.Request, *sagemaker.CreateContextOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.CreateContextInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.CreateContextOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.CreateContextInput) *sagemaker.CreateContextOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.CreateContextOutput)
		}
	}

	return r0, r1
}

// CreateContextWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) CreateContextWithContext(_a0 context.Context, _a1 *sagemaker.CreateContextInput, _a2 ...request.Option) (*sagemaker.CreateContextOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.CreateContextOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.CreateContextInput, ...request.Option) *sagemaker.CreateContextOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.CreateContextOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.CreateContextInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateDataQualityJobDefinition provides a mock function with given fields: _a0
func (_m *SageMakerAPI) CreateDataQualityJobDefinition(_a0 *sagemaker.CreateDataQualityJobDefinitionInput) (*sagemaker.CreateDataQualityJobDefinitionOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.CreateDataQualityJobDefinitionOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.CreateDataQualityJobDefinitionInput) *sagemaker.CreateDataQualityJobDefinitionOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.CreateDataQualityJobDefinitionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.CreateDataQualityJobDefinitionInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateDataQualityJobDefinitionRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) CreateDataQualityJobDefinitionRequest(_a0 *sagemaker.CreateDataQualityJobDefinitionInput) (*request.Request, *sagemaker.CreateDataQualityJobDefinitionOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.CreateDataQualityJobDefinitionInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.CreateDataQualityJobDefinitionOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.CreateDataQualityJobDefinitionInput) *sagemaker.CreateDataQualityJobDefinitionOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.CreateDataQualityJobDefinitionOutput)
		}
	}

	return r0, r1
}

// CreateDataQualityJobDefinitionWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) CreateDataQualityJobDefinitionWithContext(_a0 context.Context, _a1 *sagemaker.CreateDataQualityJobDefinitionInput, _a2 ...request.Option) (*sagemaker.CreateDataQualityJobDefinitionOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.CreateDataQualityJobDefinitionOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.CreateDataQualityJobDefinitionInput, ...request.Option) *sagemaker.CreateDataQualityJobDefinitionOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.CreateDataQualityJobDefinitionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.CreateDataQualityJobDefinitionInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateDeviceFleet provides a mock function with given fields: _a0
func (_m *SageMakerAPI) CreateDeviceFleet(_a0 *sagemaker.CreateDeviceFleetInput) (*sagemaker.CreateDeviceFleetOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.CreateDeviceFleetOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.CreateDeviceFleetInput) *sagemaker.CreateDeviceFleetOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.CreateDeviceFleetOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.CreateDeviceFleetInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateDeviceFleetRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) CreateDeviceFleetRequest(_a0 *sagemaker.CreateDeviceFleetInput) (*request.Request, *sagemaker.CreateDeviceFleetOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.CreateDeviceFleetInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.CreateDeviceFleetOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.CreateDeviceFleetInput) *sagemaker.CreateDeviceFleetOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.CreateDeviceFleetOutput)
		}
	}

	return r0, r1
}

// CreateDeviceFleetWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) CreateDeviceFleetWithContext(_a0 context.Context, _a1 *sagemaker.CreateDeviceFleetInput, _a2 ...request.Option) (*sagemaker.CreateDeviceFleetOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.CreateDeviceFleetOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.CreateDeviceFleetInput, ...request.Option) *sagemaker.CreateDeviceFleetOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.CreateDeviceFleetOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.CreateDeviceFleetInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateDomain provides a mock function with given fields: _a0
func (_m *SageMakerAPI) CreateDomain(_a0 *sagemaker.CreateDomainInput) (*sagemaker.CreateDomainOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.CreateDomainOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.CreateDomainInput) *sagemaker.CreateDomainOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.CreateDomainOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.CreateDomainInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateDomainRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) CreateDomainRequest(_a0 *sagemaker.CreateDomainInput) (*request.Request, *sagemaker.CreateDomainOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.CreateDomainInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.CreateDomainOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.CreateDomainInput) *sagemaker.CreateDomainOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.CreateDomainOutput)
		}
	}

	return r0, r1
}

// CreateDomainWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) CreateDomainWithContext(_a0 context.Context, _a1 *sagemaker.CreateDomainInput, _a2 ...request.Option) (*sagemaker.CreateDomainOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.CreateDomainOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.CreateDomainInput, ...request.Option) *sagemaker.CreateDomainOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.CreateDomainOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.CreateDomainInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateEdgePackagingJob provides a mock function with given fields: _a0
func (_m *SageMakerAPI) CreateEdgePackagingJob(_a0 *sagemaker.CreateEdgePackagingJobInput) (*sagemaker.CreateEdgePackagingJobOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.CreateEdgePackagingJobOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.CreateEdgePackagingJobInput) *sagemaker.CreateEdgePackagingJobOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.CreateEdgePackagingJobOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.CreateEdgePackagingJobInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateEdgePackagingJobRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) CreateEdgePackagingJobRequest(_a0 *sagemaker.CreateEdgePackagingJobInput) (*request.Request, *sagemaker.CreateEdgePackagingJobOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.CreateEdgePackagingJobInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.CreateEdgePackagingJobOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.CreateEdgePackagingJobInput) *sagemaker.CreateEdgePackagingJobOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.CreateEdgePackagingJobOutput)
		}
	}

	return r0, r1
}

// CreateEdgePackagingJobWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) CreateEdgePackagingJobWithContext(_a0 context.Context, _a1 *sagemaker.CreateEdgePackagingJobInput, _a2 ...request.Option) (*sagemaker.CreateEdgePackagingJobOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.CreateEdgePackagingJobOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.CreateEdgePackagingJobInput, ...request.Option) *sagemaker.CreateEdgePackagingJobOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.CreateEdgePackagingJobOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.CreateEdgePackagingJobInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateEndpoint provides a mock function with given fields: _a0
func (_m *SageMakerAPI) CreateEndpoint(_a0 *sagemaker.CreateEndpointInput) (*sagemaker.CreateEndpointOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.CreateEndpointOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.CreateEndpointInput) *sagemaker.CreateEndpointOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.CreateEndpointOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.CreateEndpointInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateEndpointConfig provides a mock function with given fields: _a0
func (_m *SageMakerAPI) CreateEndpointConfig(_a0 *sagemaker.CreateEndpointConfigInput) (*sagemaker.CreateEndpointConfigOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.CreateEndpointConfigOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.CreateEndpointConfigInput) *sagemaker.CreateEndpointConfigOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.CreateEndpointConfigOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.CreateEndpointConfigInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateEndpointConfigRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) CreateEndpointConfigRequest(_a0 *sagemaker.CreateEndpointConfigInput) (*request.Request, *sagemaker.CreateEndpointConfigOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.CreateEndpointConfigInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.CreateEndpointConfigOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.CreateEndpointConfigInput) *sagemaker.CreateEndpointConfigOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.CreateEndpointConfigOutput)
		}
	}

	return r0, r1
}

// CreateEndpointConfigWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) CreateEndpointConfigWithContext(_a0 context.Context, _a1 *sagemaker.CreateEndpointConfigInput, _a2 ...request.Option) (*sagemaker.CreateEndpointConfigOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.CreateEndpointConfigOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.CreateEndpointConfigInput, ...request.Option) *sagemaker.CreateEndpointConfigOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.CreateEndpointConfigOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.CreateEndpointConfigInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateEndpointRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) CreateEndpointRequest(_a0 *sagemaker.CreateEndpointInput) (*request.Request, *sagemaker.CreateEndpointOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.CreateEndpointInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.CreateEndpointOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.CreateEndpointInput) *sagemaker.CreateEndpointOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.CreateEndpointOutput)
		}
	}

	return r0, r1
}

// CreateEndpointWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) CreateEndpointWithContext(_a0 context.Context, _a1 *sagemaker.CreateEndpointInput, _a2 ...request.Option) (*sagemaker.CreateEndpointOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.CreateEndpointOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.CreateEndpointInput, ...request.Option) *sagemaker.CreateEndpointOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.CreateEndpointOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.CreateEndpointInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateExperiment provides a mock function with given fields: _a0
func (_m *SageMakerAPI) CreateExperiment(_a0 *sagemaker.CreateExperimentInput) (*sagemaker.CreateExperimentOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.CreateExperimentOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.CreateExperimentInput) *sagemaker.CreateExperimentOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.CreateExperimentOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.CreateExperimentInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateExperimentRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) CreateExperimentRequest(_a0 *sagemaker.CreateExperimentInput) (*request.Request, *sagemaker.CreateExperimentOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.CreateExperimentInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.CreateExperimentOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.CreateExperimentInput) *sagemaker.CreateExperimentOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.CreateExperimentOutput)
		}
	}

	return r0, r1
}

// CreateExperimentWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) CreateExperimentWithContext(_a0 context.Context, _a1 *sagemaker.CreateExperimentInput, _a2 ...request.Option) (*sagemaker.CreateExperimentOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.CreateExperimentOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.CreateExperimentInput, ...request.Option) *sagemaker.CreateExperimentOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.CreateExperimentOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.CreateExperimentInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateFeatureGroup provides a mock function with given fields: _a0
func (_m *SageMakerAPI) CreateFeatureGroup(_a0 *sagemaker.CreateFeatureGroupInput) (*sagemaker.CreateFeatureGroupOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.CreateFeatureGroupOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.CreateFeatureGroupInput) *sagemaker.CreateFeatureGroupOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.CreateFeatureGroupOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.CreateFeatureGroupInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateFeatureGroupRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) CreateFeatureGroupRequest(_a0 *sagemaker.CreateFeatureGroupInput) (*request.Request, *sagemaker.CreateFeatureGroupOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.CreateFeatureGroupInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.CreateFeatureGroupOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.CreateFeatureGroupInput) *sagemaker.CreateFeatureGroupOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.CreateFeatureGroupOutput)
		}
	}

	return r0, r1
}

// CreateFeatureGroupWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) CreateFeatureGroupWithContext(_a0 context.Context, _a1 *sagemaker.CreateFeatureGroupInput, _a2 ...request.Option) (*sagemaker.CreateFeatureGroupOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.CreateFeatureGroupOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.CreateFeatureGroupInput, ...request.Option) *sagemaker.CreateFeatureGroupOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.CreateFeatureGroupOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.CreateFeatureGroupInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateFlowDefinition provides a mock function with given fields: _a0
func (_m *SageMakerAPI) CreateFlowDefinition(_a0 *sagemaker.CreateFlowDefinitionInput) (*sagemaker.CreateFlowDefinitionOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.CreateFlowDefinitionOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.CreateFlowDefinitionInput) *sagemaker.CreateFlowDefinitionOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.CreateFlowDefinitionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.CreateFlowDefinitionInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateFlowDefinitionRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) CreateFlowDefinitionRequest(_a0 *sagemaker.CreateFlowDefinitionInput) (*request.Request, *sagemaker.CreateFlowDefinitionOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.CreateFlowDefinitionInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.CreateFlowDefinitionOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.CreateFlowDefinitionInput) *sagemaker.CreateFlowDefinitionOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.CreateFlowDefinitionOutput)
		}
	}

	return r0, r1
}

// CreateFlowDefinitionWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) CreateFlowDefinitionWithContext(_a0 context.Context, _a1 *sagemaker.CreateFlowDefinitionInput, _a2 ...request.Option) (*sagemaker.CreateFlowDefinitionOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.CreateFlowDefinitionOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.CreateFlowDefinitionInput, ...request.Option) *sagemaker.CreateFlowDefinitionOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.CreateFlowDefinitionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.CreateFlowDefinitionInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateHumanTaskUi provides a mock function with given fields: _a0
func (_m *SageMakerAPI) CreateHumanTaskUi(_a0 *sagemaker.CreateHumanTaskUiInput) (*sagemaker.CreateHumanTaskUiOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.CreateHumanTaskUiOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.CreateHumanTaskUiInput) *sagemaker.CreateHumanTaskUiOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.CreateHumanTaskUiOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.CreateHumanTaskUiInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateHumanTaskUiRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) CreateHumanTaskUiRequest(_a0 *sagemaker.CreateHumanTaskUiInput) (*request.Request, *sagemaker.CreateHumanTaskUiOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.CreateHumanTaskUiInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.CreateHumanTaskUiOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.CreateHumanTaskUiInput) *sagemaker.CreateHumanTaskUiOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.CreateHumanTaskUiOutput)
		}
	}

	return r0, r1
}

// CreateHumanTaskUiWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) CreateHumanTaskUiWithContext(_a0 context.Context, _a1 *sagemaker.CreateHumanTaskUiInput, _a2 ...request.Option) (*sagemaker.CreateHumanTaskUiOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.CreateHumanTaskUiOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.CreateHumanTaskUiInput, ...request.Option) *sagemaker.CreateHumanTaskUiOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.CreateHumanTaskUiOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.CreateHumanTaskUiInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateHyperParameterTuningJob provides a mock function with given fields: _a0
func (_m *SageMakerAPI) CreateHyperParameterTuningJob(_a0 *sagemaker.CreateHyperParameterTuningJobInput) (*sagemaker.CreateHyperParameterTuningJobOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.CreateHyperParameterTuningJobOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.CreateHyperParameterTuningJobInput) *sagemaker.CreateHyperParameterTuningJobOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.CreateHyperParameterTuningJobOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.CreateHyperParameterTuningJobInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateHyperParameterTuningJobRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) CreateHyperParameterTuningJobRequest(_a0 *sagemaker.CreateHyperParameterTuningJobInput) (*request.Request, *sagemaker.CreateHyperParameterTuningJobOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.CreateHyperParameterTuningJobInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.CreateHyperParameterTuningJobOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.CreateHyperParameterTuningJobInput) *sagemaker.CreateHyperParameterTuningJobOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.CreateHyperParameterTuningJobOutput)
		}
	}

	return r0, r1
}

// CreateHyperParameterTuningJobWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) CreateHyperParameterTuningJobWithContext(_a0 context.Context, _a1 *sagemaker.CreateHyperParameterTuningJobInput, _a2 ...request.Option) (*sagemaker.CreateHyperParameterTuningJobOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.CreateHyperParameterTuningJobOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.CreateHyperParameterTuningJobInput, ...request.Option) *sagemaker.CreateHyperParameterTuningJobOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.CreateHyperParameterTuningJobOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.CreateHyperParameterTuningJobInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateImage provides a mock function with given fields: _a0
func (_m *SageMakerAPI) CreateImage(_a0 *sagemaker.CreateImageInput) (*sagemaker.CreateImageOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.CreateImageOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.CreateImageInput) *sagemaker.CreateImageOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.CreateImageOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.CreateImageInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateImageRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) CreateImageRequest(_a0 *sagemaker.CreateImageInput) (*request.Request, *sagemaker.CreateImageOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.CreateImageInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.CreateImageOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.CreateImageInput) *sagemaker.CreateImageOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.CreateImageOutput)
		}
	}

	return r0, r1
}

// CreateImageVersion provides a mock function with given fields: _a0
func (_m *SageMakerAPI) CreateImageVersion(_a0 *sagemaker.CreateImageVersionInput) (*sagemaker.CreateImageVersionOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.CreateImageVersionOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.CreateImageVersionInput) *sagemaker.CreateImageVersionOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.CreateImageVersionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.CreateImageVersionInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateImageVersionRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) CreateImageVersionRequest(_a0 *sagemaker.CreateImageVersionInput) (*request.Request, *sagemaker.CreateImageVersionOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.CreateImageVersionInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.CreateImageVersionOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.CreateImageVersionInput) *sagemaker.CreateImageVersionOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.CreateImageVersionOutput)
		}
	}

	return r0, r1
}

// CreateImageVersionWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) CreateImageVersionWithContext(_a0 context.Context, _a1 *sagemaker.CreateImageVersionInput, _a2 ...request.Option) (*sagemaker.CreateImageVersionOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.CreateImageVersionOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.CreateImageVersionInput, ...request.Option) *sagemaker.CreateImageVersionOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.CreateImageVersionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.CreateImageVersionInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateImageWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) CreateImageWithContext(_a0 context.Context, _a1 *sagemaker.CreateImageInput, _a2 ...request.Option) (*sagemaker.CreateImageOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.CreateImageOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.CreateImageInput, ...request.Option) *sagemaker.CreateImageOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.CreateImageOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.CreateImageInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateLabelingJob provides a mock function with given fields: _a0
func (_m *SageMakerAPI) CreateLabelingJob(_a0 *sagemaker.CreateLabelingJobInput) (*sagemaker.CreateLabelingJobOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.CreateLabelingJobOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.CreateLabelingJobInput) *sagemaker.CreateLabelingJobOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.CreateLabelingJobOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.CreateLabelingJobInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateLabelingJobRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) CreateLabelingJobRequest(_a0 *sagemaker.CreateLabelingJobInput) (*request.Request, *sagemaker.CreateLabelingJobOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.CreateLabelingJobInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.CreateLabelingJobOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.CreateLabelingJobInput) *sagemaker.CreateLabelingJobOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.CreateLabelingJobOutput)
		}
	}

	return r0, r1
}

// CreateLabelingJobWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) CreateLabelingJobWithContext(_a0 context.Context, _a1 *sagemaker.CreateLabelingJobInput, _a2 ...request.Option) (*sagemaker.CreateLabelingJobOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.CreateLabelingJobOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.CreateLabelingJobInput, ...request.Option) *sagemaker.CreateLabelingJobOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.CreateLabelingJobOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.CreateLabelingJobInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateModel provides a mock function with given fields: _a0
func (_m *SageMakerAPI) CreateModel(_a0 *sagemaker.CreateModelInput) (*sagemaker.CreateModelOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.CreateModelOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.CreateModelInput) *sagemaker.CreateModelOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.CreateModelOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.CreateModelInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateModelBiasJobDefinition provides a mock function with given fields: _a0
func (_m *SageMakerAPI) CreateModelBiasJobDefinition(_a0 *sagemaker.CreateModelBiasJobDefinitionInput) (*sagemaker.CreateModelBiasJobDefinitionOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.CreateModelBiasJobDefinitionOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.CreateModelBiasJobDefinitionInput) *sagemaker.CreateModelBiasJobDefinitionOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.CreateModelBiasJobDefinitionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.CreateModelBiasJobDefinitionInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateModelBiasJobDefinitionRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) CreateModelBiasJobDefinitionRequest(_a0 *sagemaker.CreateModelBiasJobDefinitionInput) (*request.Request, *sagemaker.CreateModelBiasJobDefinitionOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.CreateModelBiasJobDefinitionInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.CreateModelBiasJobDefinitionOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.CreateModelBiasJobDefinitionInput) *sagemaker.CreateModelBiasJobDefinitionOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.CreateModelBiasJobDefinitionOutput)
		}
	}

	return r0, r1
}

// CreateModelBiasJobDefinitionWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) CreateModelBiasJobDefinitionWithContext(_a0 context.Context, _a1 *sagemaker.CreateModelBiasJobDefinitionInput, _a2 ...request.Option) (*sagemaker.CreateModelBiasJobDefinitionOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.CreateModelBiasJobDefinitionOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.CreateModelBiasJobDefinitionInput, ...request.Option) *sagemaker.CreateModelBiasJobDefinitionOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.CreateModelBiasJobDefinitionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.CreateModelBiasJobDefinitionInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateModelExplainabilityJobDefinition provides a mock function with given fields: _a0
func (_m *SageMakerAPI) CreateModelExplainabilityJobDefinition(_a0 *sagemaker.CreateModelExplainabilityJobDefinitionInput) (*sagemaker.CreateModelExplainabilityJobDefinitionOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.CreateModelExplainabilityJobDefinitionOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.CreateModelExplainabilityJobDefinitionInput) *sagemaker.CreateModelExplainabilityJobDefinitionOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.CreateModelExplainabilityJobDefinitionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.CreateModelExplainabilityJobDefinitionInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateModelExplainabilityJobDefinitionRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) CreateModelExplainabilityJobDefinitionRequest(_a0 *sagemaker.CreateModelExplainabilityJobDefinitionInput) (*request.Request, *sagemaker.CreateModelExplainabilityJobDefinitionOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.CreateModelExplainabilityJobDefinitionInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.CreateModelExplainabilityJobDefinitionOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.CreateModelExplainabilityJobDefinitionInput) *sagemaker.CreateModelExplainabilityJobDefinitionOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.CreateModelExplainabilityJobDefinitionOutput)
		}
	}

	return r0, r1
}

// CreateModelExplainabilityJobDefinitionWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) CreateModelExplainabilityJobDefinitionWithContext(_a0 context.Context, _a1 *sagemaker.CreateModelExplainabilityJobDefinitionInput, _a2 ...request.Option) (*sagemaker.CreateModelExplainabilityJobDefinitionOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.CreateModelExplainabilityJobDefinitionOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.CreateModelExplainabilityJobDefinitionInput, ...request.Option) *sagemaker.CreateModelExplainabilityJobDefinitionOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.CreateModelExplainabilityJobDefinitionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.CreateModelExplainabilityJobDefinitionInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateModelPackage provides a mock function with given fields: _a0
func (_m *SageMakerAPI) CreateModelPackage(_a0 *sagemaker.CreateModelPackageInput) (*sagemaker.CreateModelPackageOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.CreateModelPackageOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.CreateModelPackageInput) *sagemaker.CreateModelPackageOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.CreateModelPackageOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.CreateModelPackageInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateModelPackageGroup provides a mock function with given fields: _a0
func (_m *SageMakerAPI) CreateModelPackageGroup(_a0 *sagemaker.CreateModelPackageGroupInput) (*sagemaker.CreateModelPackageGroupOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.CreateModelPackageGroupOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.CreateModelPackageGroupInput) *sagemaker.CreateModelPackageGroupOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.CreateModelPackageGroupOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.CreateModelPackageGroupInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateModelPackageGroupRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) CreateModelPackageGroupRequest(_a0 *sagemaker.CreateModelPackageGroupInput) (*request.Request, *sagemaker.CreateModelPackageGroupOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.CreateModelPackageGroupInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.CreateModelPackageGroupOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.CreateModelPackageGroupInput) *sagemaker.CreateModelPackageGroupOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.CreateModelPackageGroupOutput)
		}
	}

	return r0, r1
}

// CreateModelPackageGroupWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) CreateModelPackageGroupWithContext(_a0 context.Context, _a1 *sagemaker.CreateModelPackageGroupInput, _a2 ...request.Option) (*sagemaker.CreateModelPackageGroupOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.CreateModelPackageGroupOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.CreateModelPackageGroupInput, ...request.Option) *sagemaker.CreateModelPackageGroupOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.CreateModelPackageGroupOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.CreateModelPackageGroupInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateModelPackageRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) CreateModelPackageRequest(_a0 *sagemaker.CreateModelPackageInput) (*request.Request, *sagemaker.CreateModelPackageOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.CreateModelPackageInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.CreateModelPackageOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.CreateModelPackageInput) *sagemaker.CreateModelPackageOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.CreateModelPackageOutput)
		}
	}

	return r0, r1
}

// CreateModelPackageWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) CreateModelPackageWithContext(_a0 context.Context, _a1 *sagemaker.CreateModelPackageInput, _a2 ...request.Option) (*sagemaker.CreateModelPackageOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.CreateModelPackageOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.CreateModelPackageInput, ...request.Option) *sagemaker.CreateModelPackageOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.CreateModelPackageOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.CreateModelPackageInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateModelQualityJobDefinition provides a mock function with given fields: _a0
func (_m *SageMakerAPI) CreateModelQualityJobDefinition(_a0 *sagemaker.CreateModelQualityJobDefinitionInput) (*sagemaker.CreateModelQualityJobDefinitionOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.CreateModelQualityJobDefinitionOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.CreateModelQualityJobDefinitionInput) *sagemaker.CreateModelQualityJobDefinitionOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.CreateModelQualityJobDefinitionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.CreateModelQualityJobDefinitionInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateModelQualityJobDefinitionRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) CreateModelQualityJobDefinitionRequest(_a0 *sagemaker.CreateModelQualityJobDefinitionInput) (*request.Request, *sagemaker.CreateModelQualityJobDefinitionOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.CreateModelQualityJobDefinitionInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.CreateModelQualityJobDefinitionOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.CreateModelQualityJobDefinitionInput) *sagemaker.CreateModelQualityJobDefinitionOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.CreateModelQualityJobDefinitionOutput)
		}
	}

	return r0, r1
}

// CreateModelQualityJobDefinitionWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) CreateModelQualityJobDefinitionWithContext(_a0 context.Context, _a1 *sagemaker.CreateModelQualityJobDefinitionInput, _a2 ...request.Option) (*sagemaker.CreateModelQualityJobDefinitionOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.CreateModelQualityJobDefinitionOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.CreateModelQualityJobDefinitionInput, ...request.Option) *sagemaker.CreateModelQualityJobDefinitionOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.CreateModelQualityJobDefinitionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.CreateModelQualityJobDefinitionInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateModelRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) CreateModelRequest(_a0 *sagemaker.CreateModelInput) (*request.Request, *sagemaker.CreateModelOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.CreateModelInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.CreateModelOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.CreateModelInput) *sagemaker.CreateModelOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.CreateModelOutput)
		}
	}

	return r0, r1
}

// CreateModelWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) CreateModelWithContext(_a0 context.Context, _a1 *sagemaker.CreateModelInput, _a2 ...request.Option) (*sagemaker.CreateModelOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.CreateModelOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.CreateModelInput, ...request.Option) *sagemaker.CreateModelOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.CreateModelOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.CreateModelInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateMonitoringSchedule provides a mock function with given fields: _a0
func (_m *SageMakerAPI) CreateMonitoringSchedule(_a0 *sagemaker.CreateMonitoringScheduleInput) (*sagemaker.CreateMonitoringScheduleOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.CreateMonitoringScheduleOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.CreateMonitoringScheduleInput) *sagemaker.CreateMonitoringScheduleOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.CreateMonitoringScheduleOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.CreateMonitoringScheduleInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateMonitoringScheduleRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) CreateMonitoringScheduleRequest(_a0 *sagemaker.CreateMonitoringScheduleInput) (*request.Request, *sagemaker.CreateMonitoringScheduleOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.CreateMonitoringScheduleInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.CreateMonitoringScheduleOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.CreateMonitoringScheduleInput) *sagemaker.CreateMonitoringScheduleOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.CreateMonitoringScheduleOutput)
		}
	}

	return r0, r1
}

// CreateMonitoringScheduleWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) CreateMonitoringScheduleWithContext(_a0 context.Context, _a1 *sagemaker.CreateMonitoringScheduleInput, _a2 ...request.Option) (*sagemaker.CreateMonitoringScheduleOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.CreateMonitoringScheduleOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.CreateMonitoringScheduleInput, ...request.Option) *sagemaker.CreateMonitoringScheduleOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.CreateMonitoringScheduleOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.CreateMonitoringScheduleInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateNotebookInstance provides a mock function with given fields: _a0
func (_m *SageMakerAPI) CreateNotebookInstance(_a0 *sagemaker.CreateNotebookInstanceInput) (*sagemaker.CreateNotebookInstanceOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.CreateNotebookInstanceOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.CreateNotebookInstanceInput) *sagemaker.CreateNotebookInstanceOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.CreateNotebookInstanceOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.CreateNotebookInstanceInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateNotebookInstanceLifecycleConfig provides a mock function with given fields: _a0
func (_m *SageMakerAPI) CreateNotebookInstanceLifecycleConfig(_a0 *sagemaker.CreateNotebookInstanceLifecycleConfigInput) (*sagemaker.CreateNotebookInstanceLifecycleConfigOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.CreateNotebookInstanceLifecycleConfigOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.CreateNotebookInstanceLifecycleConfigInput) *sagemaker.CreateNotebookInstanceLifecycleConfigOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.CreateNotebookInstanceLifecycleConfigOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.CreateNotebookInstanceLifecycleConfigInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateNotebookInstanceLifecycleConfigRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) CreateNotebookInstanceLifecycleConfigRequest(_a0 *sagemaker.CreateNotebookInstanceLifecycleConfigInput) (*request.Request, *sagemaker.CreateNotebookInstanceLifecycleConfigOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.CreateNotebookInstanceLifecycleConfigInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.CreateNotebookInstanceLifecycleConfigOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.CreateNotebookInstanceLifecycleConfigInput) *sagemaker.CreateNotebookInstanceLifecycleConfigOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.CreateNotebookInstanceLifecycleConfigOutput)
		}
	}

	return r0, r1
}

// CreateNotebookInstanceLifecycleConfigWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) CreateNotebookInstanceLifecycleConfigWithContext(_a0 context.Context, _a1 *sagemaker.CreateNotebookInstanceLifecycleConfigInput, _a2 ...request.Option) (*sagemaker.CreateNotebookInstanceLifecycleConfigOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.CreateNotebookInstanceLifecycleConfigOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.CreateNotebookInstanceLifecycleConfigInput, ...request.Option) *sagemaker.CreateNotebookInstanceLifecycleConfigOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.CreateNotebookInstanceLifecycleConfigOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.CreateNotebookInstanceLifecycleConfigInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateNotebookInstanceRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) CreateNotebookInstanceRequest(_a0 *sagemaker.CreateNotebookInstanceInput) (*request.Request, *sagemaker.CreateNotebookInstanceOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.CreateNotebookInstanceInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.CreateNotebookInstanceOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.CreateNotebookInstanceInput) *sagemaker.CreateNotebookInstanceOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.CreateNotebookInstanceOutput)
		}
	}

	return r0, r1
}

// CreateNotebookInstanceWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) CreateNotebookInstanceWithContext(_a0 context.Context, _a1 *sagemaker.CreateNotebookInstanceInput, _a2 ...request.Option) (*sagemaker.CreateNotebookInstanceOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.CreateNotebookInstanceOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.CreateNotebookInstanceInput, ...request.Option) *sagemaker.CreateNotebookInstanceOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.CreateNotebookInstanceOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.CreateNotebookInstanceInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreatePipeline provides a mock function with given fields: _a0
func (_m *SageMakerAPI) CreatePipeline(_a0 *sagemaker.CreatePipelineInput) (*sagemaker.CreatePipelineOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.CreatePipelineOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.CreatePipelineInput) *sagemaker.CreatePipelineOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.CreatePipelineOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.CreatePipelineInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreatePipelineRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) CreatePipelineRequest(_a0 *sagemaker.CreatePipelineInput) (*request.Request, *sagemaker.CreatePipelineOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.CreatePipelineInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.CreatePipelineOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.CreatePipelineInput) *sagemaker.CreatePipelineOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.CreatePipelineOutput)
		}
	}

	return r0, r1
}

// CreatePipelineWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) CreatePipelineWithContext(_a0 context.Context, _a1 *sagemaker.CreatePipelineInput, _a2 ...request.Option) (*sagemaker.CreatePipelineOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.CreatePipelineOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.CreatePipelineInput, ...request.Option) *sagemaker.CreatePipelineOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.CreatePipelineOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.CreatePipelineInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreatePresignedDomainUrl provides a mock function with given fields: _a0
func (_m *SageMakerAPI) CreatePresignedDomainUrl(_a0 *sagemaker.CreatePresignedDomainUrlInput) (*sagemaker.CreatePresignedDomainUrlOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.CreatePresignedDomainUrlOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.CreatePresignedDomainUrlInput) *sagemaker.CreatePresignedDomainUrlOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.CreatePresignedDomainUrlOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.CreatePresignedDomainUrlInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreatePresignedDomainUrlRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) CreatePresignedDomainUrlRequest(_a0 *sagemaker.CreatePresignedDomainUrlInput) (*request.Request, *sagemaker.CreatePresignedDomainUrlOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.CreatePresignedDomainUrlInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.CreatePresignedDomainUrlOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.CreatePresignedDomainUrlInput) *sagemaker.CreatePresignedDomainUrlOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.CreatePresignedDomainUrlOutput)
		}
	}

	return r0, r1
}

// CreatePresignedDomainUrlWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) CreatePresignedDomainUrlWithContext(_a0 context.Context, _a1 *sagemaker.CreatePresignedDomainUrlInput, _a2 ...request.Option) (*sagemaker.CreatePresignedDomainUrlOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.CreatePresignedDomainUrlOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.CreatePresignedDomainUrlInput, ...request.Option) *sagemaker.CreatePresignedDomainUrlOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.CreatePresignedDomainUrlOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.CreatePresignedDomainUrlInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreatePresignedNotebookInstanceUrl provides a mock function with given fields: _a0
func (_m *SageMakerAPI) CreatePresignedNotebookInstanceUrl(_a0 *sagemaker.CreatePresignedNotebookInstanceUrlInput) (*sagemaker.CreatePresignedNotebookInstanceUrlOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.CreatePresignedNotebookInstanceUrlOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.CreatePresignedNotebookInstanceUrlInput) *sagemaker.CreatePresignedNotebookInstanceUrlOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.CreatePresignedNotebookInstanceUrlOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.CreatePresignedNotebookInstanceUrlInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreatePresignedNotebookInstanceUrlRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) CreatePresignedNotebookInstanceUrlRequest(_a0 *sagemaker.CreatePresignedNotebookInstanceUrlInput) (*request.Request, *sagemaker.CreatePresignedNotebookInstanceUrlOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.CreatePresignedNotebookInstanceUrlInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.CreatePresignedNotebookInstanceUrlOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.CreatePresignedNotebookInstanceUrlInput) *sagemaker.CreatePresignedNotebookInstanceUrlOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.CreatePresignedNotebookInstanceUrlOutput)
		}
	}

	return r0, r1
}

// CreatePresignedNotebookInstanceUrlWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) CreatePresignedNotebookInstanceUrlWithContext(_a0 context.Context, _a1 *sagemaker.CreatePresignedNotebookInstanceUrlInput, _a2 ...request.Option) (*sagemaker.CreatePresignedNotebookInstanceUrlOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.CreatePresignedNotebookInstanceUrlOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.CreatePresignedNotebookInstanceUrlInput, ...request.Option) *sagemaker.CreatePresignedNotebookInstanceUrlOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.CreatePresignedNotebookInstanceUrlOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.CreatePresignedNotebookInstanceUrlInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateProcessingJob provides a mock function with given fields: _a0
func (_m *SageMakerAPI) CreateProcessingJob(_a0 *sagemaker.CreateProcessingJobInput) (*sagemaker.CreateProcessingJobOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.CreateProcessingJobOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.CreateProcessingJobInput) *sagemaker.CreateProcessingJobOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.CreateProcessingJobOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.CreateProcessingJobInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateProcessingJobRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) CreateProcessingJobRequest(_a0 *sagemaker.CreateProcessingJobInput) (*request.Request, *sagemaker.CreateProcessingJobOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.CreateProcessingJobInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.CreateProcessingJobOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.CreateProcessingJobInput) *sagemaker.CreateProcessingJobOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.CreateProcessingJobOutput)
		}
	}

	return r0, r1
}

// CreateProcessingJobWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) CreateProcessingJobWithContext(_a0 context.Context, _a1 *sagemaker.CreateProcessingJobInput, _a2 ...request.Option) (*sagemaker.CreateProcessingJobOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.CreateProcessingJobOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.CreateProcessingJobInput, ...request.Option) *sagemaker.CreateProcessingJobOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.CreateProcessingJobOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.CreateProcessingJobInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateProject provides a mock function with given fields: _a0
func (_m *SageMakerAPI) CreateProject(_a0 *sagemaker.CreateProjectInput) (*sagemaker.CreateProjectOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.CreateProjectOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.CreateProjectInput) *sagemaker.CreateProjectOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.CreateProjectOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.CreateProjectInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateProjectRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) CreateProjectRequest(_a0 *sagemaker.CreateProjectInput) (*request.Request, *sagemaker.CreateProjectOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.CreateProjectInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.CreateProjectOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.CreateProjectInput) *sagemaker.CreateProjectOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.CreateProjectOutput)
		}
	}

	return r0, r1
}

// CreateProjectWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) CreateProjectWithContext(_a0 context.Context, _a1 *sagemaker.CreateProjectInput, _a2 ...request.Option) (*sagemaker.CreateProjectOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.CreateProjectOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.CreateProjectInput, ...request.Option) *sagemaker.CreateProjectOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.CreateProjectOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.CreateProjectInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateTrainingJob provides a mock function with given fields: _a0
func (_m *SageMakerAPI) CreateTrainingJob(_a0 *sagemaker.CreateTrainingJobInput) (*sagemaker.CreateTrainingJobOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.CreateTrainingJobOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.CreateTrainingJobInput) *sagemaker.CreateTrainingJobOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.CreateTrainingJobOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.CreateTrainingJobInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateTrainingJobRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) CreateTrainingJobRequest(_a0 *sagemaker.CreateTrainingJobInput) (*request.Request, *sagemaker.CreateTrainingJobOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.CreateTrainingJobInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.CreateTrainingJobOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.CreateTrainingJobInput) *sagemaker.CreateTrainingJobOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.CreateTrainingJobOutput)
		}
	}

	return r0, r1
}

// CreateTrainingJobWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) CreateTrainingJobWithContext(_a0 context.Context, _a1 *sagemaker.CreateTrainingJobInput, _a2 ...request.Option) (*sagemaker.CreateTrainingJobOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.CreateTrainingJobOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.CreateTrainingJobInput, ...request.Option) *sagemaker.CreateTrainingJobOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.CreateTrainingJobOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.CreateTrainingJobInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateTransformJob provides a mock function with given fields: _a0
func (_m *SageMakerAPI) CreateTransformJob(_a0 *sagemaker.CreateTransformJobInput) (*sagemaker.CreateTransformJobOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.CreateTransformJobOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.CreateTransformJobInput) *sagemaker.CreateTransformJobOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.CreateTransformJobOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.CreateTransformJobInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateTransformJobRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) CreateTransformJobRequest(_a0 *sagemaker.CreateTransformJobInput) (*request.Request, *sagemaker.CreateTransformJobOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.CreateTransformJobInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.CreateTransformJobOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.CreateTransformJobInput) *sagemaker.CreateTransformJobOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.CreateTransformJobOutput)
		}
	}

	return r0, r1
}

// CreateTransformJobWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) CreateTransformJobWithContext(_a0 context.Context, _a1 *sagemaker.CreateTransformJobInput, _a2 ...request.Option) (*sagemaker.CreateTransformJobOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.CreateTransformJobOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.CreateTransformJobInput, ...request.Option) *sagemaker.CreateTransformJobOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.CreateTransformJobOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.CreateTransformJobInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateTrial provides a mock function with given fields: _a0
func (_m *SageMakerAPI) CreateTrial(_a0 *sagemaker.CreateTrialInput) (*sagemaker.CreateTrialOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.CreateTrialOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.CreateTrialInput) *sagemaker.CreateTrialOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.CreateTrialOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.CreateTrialInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateTrialComponent provides a mock function with given fields: _a0
func (_m *SageMakerAPI) CreateTrialComponent(_a0 *sagemaker.CreateTrialComponentInput) (*sagemaker.CreateTrialComponentOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.CreateTrialComponentOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.CreateTrialComponentInput) *sagemaker.CreateTrialComponentOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.CreateTrialComponentOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.CreateTrialComponentInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateTrialComponentRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) CreateTrialComponentRequest(_a0 *sagemaker.CreateTrialComponentInput) (*request.Request, *sagemaker.CreateTrialComponentOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.CreateTrialComponentInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.CreateTrialComponentOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.CreateTrialComponentInput) *sagemaker.CreateTrialComponentOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.CreateTrialComponentOutput)
		}
	}

	return r0, r1
}

// CreateTrialComponentWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) CreateTrialComponentWithContext(_a0 context.Context, _a1 *sagemaker.CreateTrialComponentInput, _a2 ...request.Option) (*sagemaker.CreateTrialComponentOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.CreateTrialComponentOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.CreateTrialComponentInput, ...request.Option) *sagemaker.CreateTrialComponentOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.CreateTrialComponentOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.CreateTrialComponentInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateTrialRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) CreateTrialRequest(_a0 *sagemaker.CreateTrialInput) (*request.Request, *sagemaker.CreateTrialOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.CreateTrialInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.CreateTrialOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.CreateTrialInput) *sagemaker.CreateTrialOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.CreateTrialOutput)
		}
	}

	return r0, r1
}

// CreateTrialWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) CreateTrialWithContext(_a0 context.Context, _a1 *sagemaker.CreateTrialInput, _a2 ...request.Option) (*sagemaker.CreateTrialOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.CreateTrialOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.CreateTrialInput, ...request.Option) *sagemaker.CreateTrialOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.CreateTrialOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.CreateTrialInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateUserProfile provides a mock function with given fields: _a0
func (_m *SageMakerAPI) CreateUserProfile(_a0 *sagemaker.CreateUserProfileInput) (*sagemaker.CreateUserProfileOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.CreateUserProfileOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.CreateUserProfileInput) *sagemaker.CreateUserProfileOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.CreateUserProfileOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.CreateUserProfileInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateUserProfileRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) CreateUserProfileRequest(_a0 *sagemaker.CreateUserProfileInput) (*request.Request, *sagemaker.CreateUserProfileOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.CreateUserProfileInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.CreateUserProfileOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.CreateUserProfileInput) *sagemaker.CreateUserProfileOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.CreateUserProfileOutput)
		}
	}

	return r0, r1
}

// CreateUserProfileWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) CreateUserProfileWithContext(_a0 context.Context, _a1 *sagemaker.CreateUserProfileInput, _a2 ...request.Option) (*sagemaker.CreateUserProfileOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.CreateUserProfileOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.CreateUserProfileInput, ...request.Option) *sagemaker.CreateUserProfileOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.CreateUserProfileOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.CreateUserProfileInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateWorkforce provides a mock function with given fields: _a0
func (_m *SageMakerAPI) CreateWorkforce(_a0 *sagemaker.CreateWorkforceInput) (*sagemaker.CreateWorkforceOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.CreateWorkforceOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.CreateWorkforceInput) *sagemaker.CreateWorkforceOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.CreateWorkforceOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.CreateWorkforceInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateWorkforceRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) CreateWorkforceRequest(_a0 *sagemaker.CreateWorkforceInput) (*request.Request, *sagemaker.CreateWorkforceOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.CreateWorkforceInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.CreateWorkforceOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.CreateWorkforceInput) *sagemaker.CreateWorkforceOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.CreateWorkforceOutput)
		}
	}

	return r0, r1
}

// CreateWorkforceWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) CreateWorkforceWithContext(_a0 context.Context, _a1 *sagemaker.CreateWorkforceInput, _a2 ...request.Option) (*sagemaker.CreateWorkforceOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.CreateWorkforceOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.CreateWorkforceInput, ...request.Option) *sagemaker.CreateWorkforceOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.CreateWorkforceOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.CreateWorkforceInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateWorkteam provides a mock function with given fields: _a0
func (_m *SageMakerAPI) CreateWorkteam(_a0 *sagemaker.CreateWorkteamInput) (*sagemaker.CreateWorkteamOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.CreateWorkteamOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.CreateWorkteamInput) *sagemaker.CreateWorkteamOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.CreateWorkteamOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.CreateWorkteamInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateWorkteamRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) CreateWorkteamRequest(_a0 *sagemaker.CreateWorkteamInput) (*request.Request, *sagemaker.CreateWorkteamOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.CreateWorkteamInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.CreateWorkteamOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.CreateWorkteamInput) *sagemaker.CreateWorkteamOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.CreateWorkteamOutput)
		}
	}

	return r0, r1
}

// CreateWorkteamWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) CreateWorkteamWithContext(_a0 context.Context, _a1 *sagemaker.CreateWorkteamInput, _a2 ...request.Option) (*sagemaker.CreateWorkteamOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.CreateWorkteamOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.CreateWorkteamInput, ...request.Option) *sagemaker.CreateWorkteamOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.CreateWorkteamOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.CreateWorkteamInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteAction provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DeleteAction(_a0 *sagemaker.DeleteActionInput) (*sagemaker.DeleteActionOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.DeleteActionOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.DeleteActionInput) *sagemaker.DeleteActionOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DeleteActionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.DeleteActionInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteActionRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DeleteActionRequest(_a0 *sagemaker.DeleteActionInput) (*request.Request, *sagemaker.DeleteActionOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.DeleteActionInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.DeleteActionOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.DeleteActionInput) *sagemaker.DeleteActionOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.DeleteActionOutput)
		}
	}

	return r0, r1
}

// DeleteActionWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) DeleteActionWithContext(_a0 context.Context, _a1 *sagemaker.DeleteActionInput, _a2 ...request.Option) (*sagemaker.DeleteActionOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.DeleteActionOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.DeleteActionInput, ...request.Option) *sagemaker.DeleteActionOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DeleteActionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.DeleteActionInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteAlgorithm provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DeleteAlgorithm(_a0 *sagemaker.DeleteAlgorithmInput) (*sagemaker.DeleteAlgorithmOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.DeleteAlgorithmOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.DeleteAlgorithmInput) *sagemaker.DeleteAlgorithmOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DeleteAlgorithmOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.DeleteAlgorithmInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteAlgorithmRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DeleteAlgorithmRequest(_a0 *sagemaker.DeleteAlgorithmInput) (*request.Request, *sagemaker.DeleteAlgorithmOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.DeleteAlgorithmInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.DeleteAlgorithmOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.DeleteAlgorithmInput) *sagemaker.DeleteAlgorithmOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.DeleteAlgorithmOutput)
		}
	}

	return r0, r1
}

// DeleteAlgorithmWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) DeleteAlgorithmWithContext(_a0 context.Context, _a1 *sagemaker.DeleteAlgorithmInput, _a2 ...request.Option) (*sagemaker.DeleteAlgorithmOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.DeleteAlgorithmOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.DeleteAlgorithmInput, ...request.Option) *sagemaker.DeleteAlgorithmOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DeleteAlgorithmOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.DeleteAlgorithmInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteApp provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DeleteApp(_a0 *sagemaker.DeleteAppInput) (*sagemaker.DeleteAppOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.DeleteAppOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.DeleteAppInput) *sagemaker.DeleteAppOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DeleteAppOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.DeleteAppInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteAppImageConfig provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DeleteAppImageConfig(_a0 *sagemaker.DeleteAppImageConfigInput) (*sagemaker.DeleteAppImageConfigOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.DeleteAppImageConfigOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.DeleteAppImageConfigInput) *sagemaker.DeleteAppImageConfigOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DeleteAppImageConfigOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.DeleteAppImageConfigInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteAppImageConfigRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DeleteAppImageConfigRequest(_a0 *sagemaker.DeleteAppImageConfigInput) (*request.Request, *sagemaker.DeleteAppImageConfigOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.DeleteAppImageConfigInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.DeleteAppImageConfigOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.DeleteAppImageConfigInput) *sagemaker.DeleteAppImageConfigOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.DeleteAppImageConfigOutput)
		}
	}

	return r0, r1
}

// DeleteAppImageConfigWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) DeleteAppImageConfigWithContext(_a0 context.Context, _a1 *sagemaker.DeleteAppImageConfigInput, _a2 ...request.Option) (*sagemaker.DeleteAppImageConfigOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.DeleteAppImageConfigOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.DeleteAppImageConfigInput, ...request.Option) *sagemaker.DeleteAppImageConfigOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DeleteAppImageConfigOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.DeleteAppImageConfigInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteAppRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DeleteAppRequest(_a0 *sagemaker.DeleteAppInput) (*request.Request, *sagemaker.DeleteAppOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.DeleteAppInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.DeleteAppOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.DeleteAppInput) *sagemaker.DeleteAppOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.DeleteAppOutput)
		}
	}

	return r0, r1
}

// DeleteAppWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) DeleteAppWithContext(_a0 context.Context, _a1 *sagemaker.DeleteAppInput, _a2 ...request.Option) (*sagemaker.DeleteAppOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.DeleteAppOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.DeleteAppInput, ...request.Option) *sagemaker.DeleteAppOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DeleteAppOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.DeleteAppInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteArtifact provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DeleteArtifact(_a0 *sagemaker.DeleteArtifactInput) (*sagemaker.DeleteArtifactOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.DeleteArtifactOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.DeleteArtifactInput) *sagemaker.DeleteArtifactOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DeleteArtifactOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.DeleteArtifactInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteArtifactRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DeleteArtifactRequest(_a0 *sagemaker.DeleteArtifactInput) (*request.Request, *sagemaker.DeleteArtifactOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.DeleteArtifactInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.DeleteArtifactOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.DeleteArtifactInput) *sagemaker.DeleteArtifactOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.DeleteArtifactOutput)
		}
	}

	return r0, r1
}

// DeleteArtifactWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) DeleteArtifactWithContext(_a0 context.Context, _a1 *sagemaker.DeleteArtifactInput, _a2 ...request.Option) (*sagemaker.DeleteArtifactOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.DeleteArtifactOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.DeleteArtifactInput, ...request.Option) *sagemaker.DeleteArtifactOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DeleteArtifactOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.DeleteArtifactInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteAssociation provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DeleteAssociation(_a0 *sagemaker.DeleteAssociationInput) (*sagemaker.DeleteAssociationOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.DeleteAssociationOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.DeleteAssociationInput) *sagemaker.DeleteAssociationOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DeleteAssociationOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.DeleteAssociationInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteAssociationRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DeleteAssociationRequest(_a0 *sagemaker.DeleteAssociationInput) (*request.Request, *sagemaker.DeleteAssociationOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.DeleteAssociationInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.DeleteAssociationOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.DeleteAssociationInput) *sagemaker.DeleteAssociationOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.DeleteAssociationOutput)
		}
	}

	return r0, r1
}

// DeleteAssociationWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) DeleteAssociationWithContext(_a0 context.Context, _a1 *sagemaker.DeleteAssociationInput, _a2 ...request.Option) (*sagemaker.DeleteAssociationOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.DeleteAssociationOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.DeleteAssociationInput, ...request.Option) *sagemaker.DeleteAssociationOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DeleteAssociationOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.DeleteAssociationInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteCodeRepository provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DeleteCodeRepository(_a0 *sagemaker.DeleteCodeRepositoryInput) (*sagemaker.DeleteCodeRepositoryOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.DeleteCodeRepositoryOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.DeleteCodeRepositoryInput) *sagemaker.DeleteCodeRepositoryOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DeleteCodeRepositoryOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.DeleteCodeRepositoryInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteCodeRepositoryRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DeleteCodeRepositoryRequest(_a0 *sagemaker.DeleteCodeRepositoryInput) (*request.Request, *sagemaker.DeleteCodeRepositoryOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.DeleteCodeRepositoryInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.DeleteCodeRepositoryOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.DeleteCodeRepositoryInput) *sagemaker.DeleteCodeRepositoryOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.DeleteCodeRepositoryOutput)
		}
	}

	return r0, r1
}

// DeleteCodeRepositoryWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) DeleteCodeRepositoryWithContext(_a0 context.Context, _a1 *sagemaker.DeleteCodeRepositoryInput, _a2 ...request.Option) (*sagemaker.DeleteCodeRepositoryOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.DeleteCodeRepositoryOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.DeleteCodeRepositoryInput, ...request.Option) *sagemaker.DeleteCodeRepositoryOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DeleteCodeRepositoryOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.DeleteCodeRepositoryInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteContext provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DeleteContext(_a0 *sagemaker.DeleteContextInput) (*sagemaker.DeleteContextOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.DeleteContextOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.DeleteContextInput) *sagemaker.DeleteContextOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DeleteContextOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.DeleteContextInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteContextRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DeleteContextRequest(_a0 *sagemaker.DeleteContextInput) (*request.Request, *sagemaker.DeleteContextOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.DeleteContextInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.DeleteContextOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.DeleteContextInput) *sagemaker.DeleteContextOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.DeleteContextOutput)
		}
	}

	return r0, r1
}

// DeleteContextWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) DeleteContextWithContext(_a0 context.Context, _a1 *sagemaker.DeleteContextInput, _a2 ...request.Option) (*sagemaker.DeleteContextOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.DeleteContextOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.DeleteContextInput, ...request.Option) *sagemaker.DeleteContextOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DeleteContextOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.DeleteContextInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteDataQualityJobDefinition provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DeleteDataQualityJobDefinition(_a0 *sagemaker.DeleteDataQualityJobDefinitionInput) (*sagemaker.DeleteDataQualityJobDefinitionOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.DeleteDataQualityJobDefinitionOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.DeleteDataQualityJobDefinitionInput) *sagemaker.DeleteDataQualityJobDefinitionOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DeleteDataQualityJobDefinitionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.DeleteDataQualityJobDefinitionInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteDataQualityJobDefinitionRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DeleteDataQualityJobDefinitionRequest(_a0 *sagemaker.DeleteDataQualityJobDefinitionInput) (*request.Request, *sagemaker.DeleteDataQualityJobDefinitionOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.DeleteDataQualityJobDefinitionInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.DeleteDataQualityJobDefinitionOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.DeleteDataQualityJobDefinitionInput) *sagemaker.DeleteDataQualityJobDefinitionOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.DeleteDataQualityJobDefinitionOutput)
		}
	}

	return r0, r1
}

// DeleteDataQualityJobDefinitionWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) DeleteDataQualityJobDefinitionWithContext(_a0 context.Context, _a1 *sagemaker.DeleteDataQualityJobDefinitionInput, _a2 ...request.Option) (*sagemaker.DeleteDataQualityJobDefinitionOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.DeleteDataQualityJobDefinitionOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.DeleteDataQualityJobDefinitionInput, ...request.Option) *sagemaker.DeleteDataQualityJobDefinitionOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DeleteDataQualityJobDefinitionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.DeleteDataQualityJobDefinitionInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteDeviceFleet provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DeleteDeviceFleet(_a0 *sagemaker.DeleteDeviceFleetInput) (*sagemaker.DeleteDeviceFleetOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.DeleteDeviceFleetOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.DeleteDeviceFleetInput) *sagemaker.DeleteDeviceFleetOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DeleteDeviceFleetOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.DeleteDeviceFleetInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteDeviceFleetRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DeleteDeviceFleetRequest(_a0 *sagemaker.DeleteDeviceFleetInput) (*request.Request, *sagemaker.DeleteDeviceFleetOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.DeleteDeviceFleetInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.DeleteDeviceFleetOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.DeleteDeviceFleetInput) *sagemaker.DeleteDeviceFleetOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.DeleteDeviceFleetOutput)
		}
	}

	return r0, r1
}

// DeleteDeviceFleetWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) DeleteDeviceFleetWithContext(_a0 context.Context, _a1 *sagemaker.DeleteDeviceFleetInput, _a2 ...request.Option) (*sagemaker.DeleteDeviceFleetOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.DeleteDeviceFleetOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.DeleteDeviceFleetInput, ...request.Option) *sagemaker.DeleteDeviceFleetOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DeleteDeviceFleetOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.DeleteDeviceFleetInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteDomain provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DeleteDomain(_a0 *sagemaker.DeleteDomainInput) (*sagemaker.DeleteDomainOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.DeleteDomainOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.DeleteDomainInput) *sagemaker.DeleteDomainOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DeleteDomainOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.DeleteDomainInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteDomainRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DeleteDomainRequest(_a0 *sagemaker.DeleteDomainInput) (*request.Request, *sagemaker.DeleteDomainOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.DeleteDomainInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.DeleteDomainOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.DeleteDomainInput) *sagemaker.DeleteDomainOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.DeleteDomainOutput)
		}
	}

	return r0, r1
}

// DeleteDomainWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) DeleteDomainWithContext(_a0 context.Context, _a1 *sagemaker.DeleteDomainInput, _a2 ...request.Option) (*sagemaker.DeleteDomainOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.DeleteDomainOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.DeleteDomainInput, ...request.Option) *sagemaker.DeleteDomainOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DeleteDomainOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.DeleteDomainInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteEndpoint provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DeleteEndpoint(_a0 *sagemaker.DeleteEndpointInput) (*sagemaker.DeleteEndpointOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.DeleteEndpointOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.DeleteEndpointInput) *sagemaker.DeleteEndpointOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DeleteEndpointOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.DeleteEndpointInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteEndpointConfig provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DeleteEndpointConfig(_a0 *sagemaker.DeleteEndpointConfigInput) (*sagemaker.DeleteEndpointConfigOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.DeleteEndpointConfigOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.DeleteEndpointConfigInput) *sagemaker.DeleteEndpointConfigOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DeleteEndpointConfigOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.DeleteEndpointConfigInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteEndpointConfigRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DeleteEndpointConfigRequest(_a0 *sagemaker.DeleteEndpointConfigInput) (*request.Request, *sagemaker.DeleteEndpointConfigOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.DeleteEndpointConfigInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.DeleteEndpointConfigOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.DeleteEndpointConfigInput) *sagemaker.DeleteEndpointConfigOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.DeleteEndpointConfigOutput)
		}
	}

	return r0, r1
}

// DeleteEndpointConfigWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) DeleteEndpointConfigWithContext(_a0 context.Context, _a1 *sagemaker.DeleteEndpointConfigInput, _a2 ...request.Option) (*sagemaker.DeleteEndpointConfigOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.DeleteEndpointConfigOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.DeleteEndpointConfigInput, ...request.Option) *sagemaker.DeleteEndpointConfigOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DeleteEndpointConfigOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.DeleteEndpointConfigInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteEndpointRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DeleteEndpointRequest(_a0 *sagemaker.DeleteEndpointInput) (*request.Request, *sagemaker.DeleteEndpointOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.DeleteEndpointInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.DeleteEndpointOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.DeleteEndpointInput) *sagemaker.DeleteEndpointOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.DeleteEndpointOutput)
		}
	}

	return r0, r1
}

// DeleteEndpointWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) DeleteEndpointWithContext(_a0 context.Context, _a1 *sagemaker.DeleteEndpointInput, _a2 ...request.Option) (*sagemaker.DeleteEndpointOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.DeleteEndpointOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.DeleteEndpointInput, ...request.Option) *sagemaker.DeleteEndpointOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DeleteEndpointOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.DeleteEndpointInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteExperiment provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DeleteExperiment(_a0 *sagemaker.DeleteExperimentInput) (*sagemaker.DeleteExperimentOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.DeleteExperimentOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.DeleteExperimentInput) *sagemaker.DeleteExperimentOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DeleteExperimentOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.DeleteExperimentInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteExperimentRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DeleteExperimentRequest(_a0 *sagemaker.DeleteExperimentInput) (*request.Request, *sagemaker.DeleteExperimentOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.DeleteExperimentInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.DeleteExperimentOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.DeleteExperimentInput) *sagemaker.DeleteExperimentOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.DeleteExperimentOutput)
		}
	}

	return r0, r1
}

// DeleteExperimentWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) DeleteExperimentWithContext(_a0 context.Context, _a1 *sagemaker.DeleteExperimentInput, _a2 ...request.Option) (*sagemaker.DeleteExperimentOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.DeleteExperimentOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.DeleteExperimentInput, ...request.Option) *sagemaker.DeleteExperimentOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DeleteExperimentOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.DeleteExperimentInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteFeatureGroup provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DeleteFeatureGroup(_a0 *sagemaker.DeleteFeatureGroupInput) (*sagemaker.DeleteFeatureGroupOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.DeleteFeatureGroupOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.DeleteFeatureGroupInput) *sagemaker.DeleteFeatureGroupOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DeleteFeatureGroupOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.DeleteFeatureGroupInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteFeatureGroupRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DeleteFeatureGroupRequest(_a0 *sagemaker.DeleteFeatureGroupInput) (*request.Request, *sagemaker.DeleteFeatureGroupOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.DeleteFeatureGroupInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.DeleteFeatureGroupOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.DeleteFeatureGroupInput) *sagemaker.DeleteFeatureGroupOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.DeleteFeatureGroupOutput)
		}
	}

	return r0, r1
}

// DeleteFeatureGroupWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) DeleteFeatureGroupWithContext(_a0 context.Context, _a1 *sagemaker.DeleteFeatureGroupInput, _a2 ...request.Option) (*sagemaker.DeleteFeatureGroupOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.DeleteFeatureGroupOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.DeleteFeatureGroupInput, ...request.Option) *sagemaker.DeleteFeatureGroupOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DeleteFeatureGroupOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.DeleteFeatureGroupInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteFlowDefinition provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DeleteFlowDefinition(_a0 *sagemaker.DeleteFlowDefinitionInput) (*sagemaker.DeleteFlowDefinitionOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.DeleteFlowDefinitionOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.DeleteFlowDefinitionInput) *sagemaker.DeleteFlowDefinitionOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DeleteFlowDefinitionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.DeleteFlowDefinitionInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteFlowDefinitionRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DeleteFlowDefinitionRequest(_a0 *sagemaker.DeleteFlowDefinitionInput) (*request.Request, *sagemaker.DeleteFlowDefinitionOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.DeleteFlowDefinitionInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.DeleteFlowDefinitionOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.DeleteFlowDefinitionInput) *sagemaker.DeleteFlowDefinitionOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.DeleteFlowDefinitionOutput)
		}
	}

	return r0, r1
}

// DeleteFlowDefinitionWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) DeleteFlowDefinitionWithContext(_a0 context.Context, _a1 *sagemaker.DeleteFlowDefinitionInput, _a2 ...request.Option) (*sagemaker.DeleteFlowDefinitionOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.DeleteFlowDefinitionOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.DeleteFlowDefinitionInput, ...request.Option) *sagemaker.DeleteFlowDefinitionOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DeleteFlowDefinitionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.DeleteFlowDefinitionInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteHumanTaskUi provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DeleteHumanTaskUi(_a0 *sagemaker.DeleteHumanTaskUiInput) (*sagemaker.DeleteHumanTaskUiOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.DeleteHumanTaskUiOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.DeleteHumanTaskUiInput) *sagemaker.DeleteHumanTaskUiOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DeleteHumanTaskUiOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.DeleteHumanTaskUiInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteHumanTaskUiRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DeleteHumanTaskUiRequest(_a0 *sagemaker.DeleteHumanTaskUiInput) (*request.Request, *sagemaker.DeleteHumanTaskUiOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.DeleteHumanTaskUiInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.DeleteHumanTaskUiOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.DeleteHumanTaskUiInput) *sagemaker.DeleteHumanTaskUiOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.DeleteHumanTaskUiOutput)
		}
	}

	return r0, r1
}

// DeleteHumanTaskUiWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) DeleteHumanTaskUiWithContext(_a0 context.Context, _a1 *sagemaker.DeleteHumanTaskUiInput, _a2 ...request.Option) (*sagemaker.DeleteHumanTaskUiOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.DeleteHumanTaskUiOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.DeleteHumanTaskUiInput, ...request.Option) *sagemaker.DeleteHumanTaskUiOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DeleteHumanTaskUiOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.DeleteHumanTaskUiInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteImage provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DeleteImage(_a0 *sagemaker.DeleteImageInput) (*sagemaker.DeleteImageOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.DeleteImageOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.DeleteImageInput) *sagemaker.DeleteImageOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DeleteImageOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.DeleteImageInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteImageRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DeleteImageRequest(_a0 *sagemaker.DeleteImageInput) (*request.Request, *sagemaker.DeleteImageOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.DeleteImageInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.DeleteImageOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.DeleteImageInput) *sagemaker.DeleteImageOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.DeleteImageOutput)
		}
	}

	return r0, r1
}

// DeleteImageVersion provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DeleteImageVersion(_a0 *sagemaker.DeleteImageVersionInput) (*sagemaker.DeleteImageVersionOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.DeleteImageVersionOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.DeleteImageVersionInput) *sagemaker.DeleteImageVersionOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DeleteImageVersionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.DeleteImageVersionInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteImageVersionRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DeleteImageVersionRequest(_a0 *sagemaker.DeleteImageVersionInput) (*request.Request, *sagemaker.DeleteImageVersionOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.DeleteImageVersionInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.DeleteImageVersionOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.DeleteImageVersionInput) *sagemaker.DeleteImageVersionOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.DeleteImageVersionOutput)
		}
	}

	return r0, r1
}

// DeleteImageVersionWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) DeleteImageVersionWithContext(_a0 context.Context, _a1 *sagemaker.DeleteImageVersionInput, _a2 ...request.Option) (*sagemaker.DeleteImageVersionOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.DeleteImageVersionOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.DeleteImageVersionInput, ...request.Option) *sagemaker.DeleteImageVersionOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DeleteImageVersionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.DeleteImageVersionInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteImageWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) DeleteImageWithContext(_a0 context.Context, _a1 *sagemaker.DeleteImageInput, _a2 ...request.Option) (*sagemaker.DeleteImageOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.DeleteImageOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.DeleteImageInput, ...request.Option) *sagemaker.DeleteImageOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DeleteImageOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.DeleteImageInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteModel provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DeleteModel(_a0 *sagemaker.DeleteModelInput) (*sagemaker.DeleteModelOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.DeleteModelOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.DeleteModelInput) *sagemaker.DeleteModelOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DeleteModelOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.DeleteModelInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteModelBiasJobDefinition provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DeleteModelBiasJobDefinition(_a0 *sagemaker.DeleteModelBiasJobDefinitionInput) (*sagemaker.DeleteModelBiasJobDefinitionOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.DeleteModelBiasJobDefinitionOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.DeleteModelBiasJobDefinitionInput) *sagemaker.DeleteModelBiasJobDefinitionOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DeleteModelBiasJobDefinitionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.DeleteModelBiasJobDefinitionInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteModelBiasJobDefinitionRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DeleteModelBiasJobDefinitionRequest(_a0 *sagemaker.DeleteModelBiasJobDefinitionInput) (*request.Request, *sagemaker.DeleteModelBiasJobDefinitionOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.DeleteModelBiasJobDefinitionInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.DeleteModelBiasJobDefinitionOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.DeleteModelBiasJobDefinitionInput) *sagemaker.DeleteModelBiasJobDefinitionOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.DeleteModelBiasJobDefinitionOutput)
		}
	}

	return r0, r1
}

// DeleteModelBiasJobDefinitionWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) DeleteModelBiasJobDefinitionWithContext(_a0 context.Context, _a1 *sagemaker.DeleteModelBiasJobDefinitionInput, _a2 ...request.Option) (*sagemaker.DeleteModelBiasJobDefinitionOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.DeleteModelBiasJobDefinitionOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.DeleteModelBiasJobDefinitionInput, ...request.Option) *sagemaker.DeleteModelBiasJobDefinitionOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DeleteModelBiasJobDefinitionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.DeleteModelBiasJobDefinitionInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteModelExplainabilityJobDefinition provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DeleteModelExplainabilityJobDefinition(_a0 *sagemaker.DeleteModelExplainabilityJobDefinitionInput) (*sagemaker.DeleteModelExplainabilityJobDefinitionOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.DeleteModelExplainabilityJobDefinitionOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.DeleteModelExplainabilityJobDefinitionInput) *sagemaker.DeleteModelExplainabilityJobDefinitionOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DeleteModelExplainabilityJobDefinitionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.DeleteModelExplainabilityJobDefinitionInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteModelExplainabilityJobDefinitionRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DeleteModelExplainabilityJobDefinitionRequest(_a0 *sagemaker.DeleteModelExplainabilityJobDefinitionInput) (*request.Request, *sagemaker.DeleteModelExplainabilityJobDefinitionOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.DeleteModelExplainabilityJobDefinitionInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.DeleteModelExplainabilityJobDefinitionOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.DeleteModelExplainabilityJobDefinitionInput) *sagemaker.DeleteModelExplainabilityJobDefinitionOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.DeleteModelExplainabilityJobDefinitionOutput)
		}
	}

	return r0, r1
}

// DeleteModelExplainabilityJobDefinitionWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) DeleteModelExplainabilityJobDefinitionWithContext(_a0 context.Context, _a1 *sagemaker.DeleteModelExplainabilityJobDefinitionInput, _a2 ...request.Option) (*sagemaker.DeleteModelExplainabilityJobDefinitionOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.DeleteModelExplainabilityJobDefinitionOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.DeleteModelExplainabilityJobDefinitionInput, ...request.Option) *sagemaker.DeleteModelExplainabilityJobDefinitionOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DeleteModelExplainabilityJobDefinitionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.DeleteModelExplainabilityJobDefinitionInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteModelPackage provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DeleteModelPackage(_a0 *sagemaker.DeleteModelPackageInput) (*sagemaker.DeleteModelPackageOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.DeleteModelPackageOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.DeleteModelPackageInput) *sagemaker.DeleteModelPackageOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DeleteModelPackageOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.DeleteModelPackageInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteModelPackageGroup provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DeleteModelPackageGroup(_a0 *sagemaker.DeleteModelPackageGroupInput) (*sagemaker.DeleteModelPackageGroupOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.DeleteModelPackageGroupOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.DeleteModelPackageGroupInput) *sagemaker.DeleteModelPackageGroupOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DeleteModelPackageGroupOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.DeleteModelPackageGroupInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteModelPackageGroupPolicy provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DeleteModelPackageGroupPolicy(_a0 *sagemaker.DeleteModelPackageGroupPolicyInput) (*sagemaker.DeleteModelPackageGroupPolicyOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.DeleteModelPackageGroupPolicyOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.DeleteModelPackageGroupPolicyInput) *sagemaker.DeleteModelPackageGroupPolicyOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DeleteModelPackageGroupPolicyOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.DeleteModelPackageGroupPolicyInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteModelPackageGroupPolicyRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DeleteModelPackageGroupPolicyRequest(_a0 *sagemaker.DeleteModelPackageGroupPolicyInput) (*request.Request, *sagemaker.DeleteModelPackageGroupPolicyOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.DeleteModelPackageGroupPolicyInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.DeleteModelPackageGroupPolicyOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.DeleteModelPackageGroupPolicyInput) *sagemaker.DeleteModelPackageGroupPolicyOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.DeleteModelPackageGroupPolicyOutput)
		}
	}

	return r0, r1
}

// DeleteModelPackageGroupPolicyWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) DeleteModelPackageGroupPolicyWithContext(_a0 context.Context, _a1 *sagemaker.DeleteModelPackageGroupPolicyInput, _a2 ...request.Option) (*sagemaker.DeleteModelPackageGroupPolicyOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.DeleteModelPackageGroupPolicyOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.DeleteModelPackageGroupPolicyInput, ...request.Option) *sagemaker.DeleteModelPackageGroupPolicyOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DeleteModelPackageGroupPolicyOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.DeleteModelPackageGroupPolicyInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteModelPackageGroupRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DeleteModelPackageGroupRequest(_a0 *sagemaker.DeleteModelPackageGroupInput) (*request.Request, *sagemaker.DeleteModelPackageGroupOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.DeleteModelPackageGroupInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.DeleteModelPackageGroupOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.DeleteModelPackageGroupInput) *sagemaker.DeleteModelPackageGroupOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.DeleteModelPackageGroupOutput)
		}
	}

	return r0, r1
}

// DeleteModelPackageGroupWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) DeleteModelPackageGroupWithContext(_a0 context.Context, _a1 *sagemaker.DeleteModelPackageGroupInput, _a2 ...request.Option) (*sagemaker.DeleteModelPackageGroupOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.DeleteModelPackageGroupOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.DeleteModelPackageGroupInput, ...request.Option) *sagemaker.DeleteModelPackageGroupOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DeleteModelPackageGroupOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.DeleteModelPackageGroupInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteModelPackageRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DeleteModelPackageRequest(_a0 *sagemaker.DeleteModelPackageInput) (*request.Request, *sagemaker.DeleteModelPackageOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.DeleteModelPackageInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.DeleteModelPackageOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.DeleteModelPackageInput) *sagemaker.DeleteModelPackageOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.DeleteModelPackageOutput)
		}
	}

	return r0, r1
}

// DeleteModelPackageWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) DeleteModelPackageWithContext(_a0 context.Context, _a1 *sagemaker.DeleteModelPackageInput, _a2 ...request.Option) (*sagemaker.DeleteModelPackageOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.DeleteModelPackageOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.DeleteModelPackageInput, ...request.Option) *sagemaker.DeleteModelPackageOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DeleteModelPackageOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.DeleteModelPackageInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteModelQualityJobDefinition provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DeleteModelQualityJobDefinition(_a0 *sagemaker.DeleteModelQualityJobDefinitionInput) (*sagemaker.DeleteModelQualityJobDefinitionOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.DeleteModelQualityJobDefinitionOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.DeleteModelQualityJobDefinitionInput) *sagemaker.DeleteModelQualityJobDefinitionOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DeleteModelQualityJobDefinitionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.DeleteModelQualityJobDefinitionInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteModelQualityJobDefinitionRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DeleteModelQualityJobDefinitionRequest(_a0 *sagemaker.DeleteModelQualityJobDefinitionInput) (*request.Request, *sagemaker.DeleteModelQualityJobDefinitionOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.DeleteModelQualityJobDefinitionInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.DeleteModelQualityJobDefinitionOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.DeleteModelQualityJobDefinitionInput) *sagemaker.DeleteModelQualityJobDefinitionOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.DeleteModelQualityJobDefinitionOutput)
		}
	}

	return r0, r1
}

// DeleteModelQualityJobDefinitionWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) DeleteModelQualityJobDefinitionWithContext(_a0 context.Context, _a1 *sagemaker.DeleteModelQualityJobDefinitionInput, _a2 ...request.Option) (*sagemaker.DeleteModelQualityJobDefinitionOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.DeleteModelQualityJobDefinitionOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.DeleteModelQualityJobDefinitionInput, ...request.Option) *sagemaker.DeleteModelQualityJobDefinitionOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DeleteModelQualityJobDefinitionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.DeleteModelQualityJobDefinitionInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteModelRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DeleteModelRequest(_a0 *sagemaker.DeleteModelInput) (*request.Request, *sagemaker.DeleteModelOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.DeleteModelInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.DeleteModelOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.DeleteModelInput) *sagemaker.DeleteModelOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.DeleteModelOutput)
		}
	}

	return r0, r1
}

// DeleteModelWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) DeleteModelWithContext(_a0 context.Context, _a1 *sagemaker.DeleteModelInput, _a2 ...request.Option) (*sagemaker.DeleteModelOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.DeleteModelOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.DeleteModelInput, ...request.Option) *sagemaker.DeleteModelOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DeleteModelOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.DeleteModelInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteMonitoringSchedule provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DeleteMonitoringSchedule(_a0 *sagemaker.DeleteMonitoringScheduleInput) (*sagemaker.DeleteMonitoringScheduleOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.DeleteMonitoringScheduleOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.DeleteMonitoringScheduleInput) *sagemaker.DeleteMonitoringScheduleOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DeleteMonitoringScheduleOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.DeleteMonitoringScheduleInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteMonitoringScheduleRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DeleteMonitoringScheduleRequest(_a0 *sagemaker.DeleteMonitoringScheduleInput) (*request.Request, *sagemaker.DeleteMonitoringScheduleOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.DeleteMonitoringScheduleInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.DeleteMonitoringScheduleOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.DeleteMonitoringScheduleInput) *sagemaker.DeleteMonitoringScheduleOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.DeleteMonitoringScheduleOutput)
		}
	}

	return r0, r1
}

// DeleteMonitoringScheduleWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) DeleteMonitoringScheduleWithContext(_a0 context.Context, _a1 *sagemaker.DeleteMonitoringScheduleInput, _a2 ...request.Option) (*sagemaker.DeleteMonitoringScheduleOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.DeleteMonitoringScheduleOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.DeleteMonitoringScheduleInput, ...request.Option) *sagemaker.DeleteMonitoringScheduleOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DeleteMonitoringScheduleOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.DeleteMonitoringScheduleInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteNotebookInstance provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DeleteNotebookInstance(_a0 *sagemaker.DeleteNotebookInstanceInput) (*sagemaker.DeleteNotebookInstanceOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.DeleteNotebookInstanceOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.DeleteNotebookInstanceInput) *sagemaker.DeleteNotebookInstanceOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DeleteNotebookInstanceOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.DeleteNotebookInstanceInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteNotebookInstanceLifecycleConfig provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DeleteNotebookInstanceLifecycleConfig(_a0 *sagemaker.DeleteNotebookInstanceLifecycleConfigInput) (*sagemaker.DeleteNotebookInstanceLifecycleConfigOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.DeleteNotebookInstanceLifecycleConfigOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.DeleteNotebookInstanceLifecycleConfigInput) *sagemaker.DeleteNotebookInstanceLifecycleConfigOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DeleteNotebookInstanceLifecycleConfigOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.DeleteNotebookInstanceLifecycleConfigInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteNotebookInstanceLifecycleConfigRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DeleteNotebookInstanceLifecycleConfigRequest(_a0 *sagemaker.DeleteNotebookInstanceLifecycleConfigInput) (*request.Request, *sagemaker.DeleteNotebookInstanceLifecycleConfigOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.DeleteNotebookInstanceLifecycleConfigInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.DeleteNotebookInstanceLifecycleConfigOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.DeleteNotebookInstanceLifecycleConfigInput) *sagemaker.DeleteNotebookInstanceLifecycleConfigOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.DeleteNotebookInstanceLifecycleConfigOutput)
		}
	}

	return r0, r1
}

// DeleteNotebookInstanceLifecycleConfigWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) DeleteNotebookInstanceLifecycleConfigWithContext(_a0 context.Context, _a1 *sagemaker.DeleteNotebookInstanceLifecycleConfigInput, _a2 ...request.Option) (*sagemaker.DeleteNotebookInstanceLifecycleConfigOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.DeleteNotebookInstanceLifecycleConfigOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.DeleteNotebookInstanceLifecycleConfigInput, ...request.Option) *sagemaker.DeleteNotebookInstanceLifecycleConfigOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DeleteNotebookInstanceLifecycleConfigOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.DeleteNotebookInstanceLifecycleConfigInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteNotebookInstanceRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DeleteNotebookInstanceRequest(_a0 *sagemaker.DeleteNotebookInstanceInput) (*request.Request, *sagemaker.DeleteNotebookInstanceOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.DeleteNotebookInstanceInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.DeleteNotebookInstanceOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.DeleteNotebookInstanceInput) *sagemaker.DeleteNotebookInstanceOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.DeleteNotebookInstanceOutput)
		}
	}

	return r0, r1
}

// DeleteNotebookInstanceWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) DeleteNotebookInstanceWithContext(_a0 context.Context, _a1 *sagemaker.DeleteNotebookInstanceInput, _a2 ...request.Option) (*sagemaker.DeleteNotebookInstanceOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.DeleteNotebookInstanceOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.DeleteNotebookInstanceInput, ...request.Option) *sagemaker.DeleteNotebookInstanceOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DeleteNotebookInstanceOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.DeleteNotebookInstanceInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeletePipeline provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DeletePipeline(_a0 *sagemaker.DeletePipelineInput) (*sagemaker.DeletePipelineOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.DeletePipelineOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.DeletePipelineInput) *sagemaker.DeletePipelineOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DeletePipelineOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.DeletePipelineInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeletePipelineRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DeletePipelineRequest(_a0 *sagemaker.DeletePipelineInput) (*request.Request, *sagemaker.DeletePipelineOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.DeletePipelineInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.DeletePipelineOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.DeletePipelineInput) *sagemaker.DeletePipelineOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.DeletePipelineOutput)
		}
	}

	return r0, r1
}

// DeletePipelineWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) DeletePipelineWithContext(_a0 context.Context, _a1 *sagemaker.DeletePipelineInput, _a2 ...request.Option) (*sagemaker.DeletePipelineOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.DeletePipelineOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.DeletePipelineInput, ...request.Option) *sagemaker.DeletePipelineOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DeletePipelineOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.DeletePipelineInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteProject provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DeleteProject(_a0 *sagemaker.DeleteProjectInput) (*sagemaker.DeleteProjectOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.DeleteProjectOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.DeleteProjectInput) *sagemaker.DeleteProjectOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DeleteProjectOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.DeleteProjectInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteProjectRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DeleteProjectRequest(_a0 *sagemaker.DeleteProjectInput) (*request.Request, *sagemaker.DeleteProjectOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.DeleteProjectInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.DeleteProjectOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.DeleteProjectInput) *sagemaker.DeleteProjectOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.DeleteProjectOutput)
		}
	}

	return r0, r1
}

// DeleteProjectWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) DeleteProjectWithContext(_a0 context.Context, _a1 *sagemaker.DeleteProjectInput, _a2 ...request.Option) (*sagemaker.DeleteProjectOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.DeleteProjectOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.DeleteProjectInput, ...request.Option) *sagemaker.DeleteProjectOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DeleteProjectOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.DeleteProjectInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteTags provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DeleteTags(_a0 *sagemaker.DeleteTagsInput) (*sagemaker.DeleteTagsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.DeleteTagsOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.DeleteTagsInput) *sagemaker.DeleteTagsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DeleteTagsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.DeleteTagsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteTagsRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DeleteTagsRequest(_a0 *sagemaker.DeleteTagsInput) (*request.Request, *sagemaker.DeleteTagsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.DeleteTagsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.DeleteTagsOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.DeleteTagsInput) *sagemaker.DeleteTagsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.DeleteTagsOutput)
		}
	}

	return r0, r1
}

// DeleteTagsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) DeleteTagsWithContext(_a0 context.Context, _a1 *sagemaker.DeleteTagsInput, _a2 ...request.Option) (*sagemaker.DeleteTagsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.DeleteTagsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.DeleteTagsInput, ...request.Option) *sagemaker.DeleteTagsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DeleteTagsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.DeleteTagsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteTrial provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DeleteTrial(_a0 *sagemaker.DeleteTrialInput) (*sagemaker.DeleteTrialOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.DeleteTrialOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.DeleteTrialInput) *sagemaker.DeleteTrialOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DeleteTrialOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.DeleteTrialInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteTrialComponent provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DeleteTrialComponent(_a0 *sagemaker.DeleteTrialComponentInput) (*sagemaker.DeleteTrialComponentOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.DeleteTrialComponentOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.DeleteTrialComponentInput) *sagemaker.DeleteTrialComponentOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DeleteTrialComponentOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.DeleteTrialComponentInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteTrialComponentRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DeleteTrialComponentRequest(_a0 *sagemaker.DeleteTrialComponentInput) (*request.Request, *sagemaker.DeleteTrialComponentOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.DeleteTrialComponentInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.DeleteTrialComponentOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.DeleteTrialComponentInput) *sagemaker.DeleteTrialComponentOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.DeleteTrialComponentOutput)
		}
	}

	return r0, r1
}

// DeleteTrialComponentWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) DeleteTrialComponentWithContext(_a0 context.Context, _a1 *sagemaker.DeleteTrialComponentInput, _a2 ...request.Option) (*sagemaker.DeleteTrialComponentOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.DeleteTrialComponentOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.DeleteTrialComponentInput, ...request.Option) *sagemaker.DeleteTrialComponentOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DeleteTrialComponentOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.DeleteTrialComponentInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteTrialRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DeleteTrialRequest(_a0 *sagemaker.DeleteTrialInput) (*request.Request, *sagemaker.DeleteTrialOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.DeleteTrialInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.DeleteTrialOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.DeleteTrialInput) *sagemaker.DeleteTrialOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.DeleteTrialOutput)
		}
	}

	return r0, r1
}

// DeleteTrialWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) DeleteTrialWithContext(_a0 context.Context, _a1 *sagemaker.DeleteTrialInput, _a2 ...request.Option) (*sagemaker.DeleteTrialOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.DeleteTrialOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.DeleteTrialInput, ...request.Option) *sagemaker.DeleteTrialOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DeleteTrialOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.DeleteTrialInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteUserProfile provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DeleteUserProfile(_a0 *sagemaker.DeleteUserProfileInput) (*sagemaker.DeleteUserProfileOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.DeleteUserProfileOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.DeleteUserProfileInput) *sagemaker.DeleteUserProfileOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DeleteUserProfileOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.DeleteUserProfileInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteUserProfileRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DeleteUserProfileRequest(_a0 *sagemaker.DeleteUserProfileInput) (*request.Request, *sagemaker.DeleteUserProfileOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.DeleteUserProfileInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.DeleteUserProfileOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.DeleteUserProfileInput) *sagemaker.DeleteUserProfileOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.DeleteUserProfileOutput)
		}
	}

	return r0, r1
}

// DeleteUserProfileWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) DeleteUserProfileWithContext(_a0 context.Context, _a1 *sagemaker.DeleteUserProfileInput, _a2 ...request.Option) (*sagemaker.DeleteUserProfileOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.DeleteUserProfileOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.DeleteUserProfileInput, ...request.Option) *sagemaker.DeleteUserProfileOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DeleteUserProfileOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.DeleteUserProfileInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteWorkforce provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DeleteWorkforce(_a0 *sagemaker.DeleteWorkforceInput) (*sagemaker.DeleteWorkforceOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.DeleteWorkforceOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.DeleteWorkforceInput) *sagemaker.DeleteWorkforceOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DeleteWorkforceOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.DeleteWorkforceInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteWorkforceRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DeleteWorkforceRequest(_a0 *sagemaker.DeleteWorkforceInput) (*request.Request, *sagemaker.DeleteWorkforceOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.DeleteWorkforceInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.DeleteWorkforceOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.DeleteWorkforceInput) *sagemaker.DeleteWorkforceOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.DeleteWorkforceOutput)
		}
	}

	return r0, r1
}

// DeleteWorkforceWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) DeleteWorkforceWithContext(_a0 context.Context, _a1 *sagemaker.DeleteWorkforceInput, _a2 ...request.Option) (*sagemaker.DeleteWorkforceOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.DeleteWorkforceOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.DeleteWorkforceInput, ...request.Option) *sagemaker.DeleteWorkforceOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DeleteWorkforceOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.DeleteWorkforceInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteWorkteam provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DeleteWorkteam(_a0 *sagemaker.DeleteWorkteamInput) (*sagemaker.DeleteWorkteamOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.DeleteWorkteamOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.DeleteWorkteamInput) *sagemaker.DeleteWorkteamOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DeleteWorkteamOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.DeleteWorkteamInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteWorkteamRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DeleteWorkteamRequest(_a0 *sagemaker.DeleteWorkteamInput) (*request.Request, *sagemaker.DeleteWorkteamOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.DeleteWorkteamInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.DeleteWorkteamOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.DeleteWorkteamInput) *sagemaker.DeleteWorkteamOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.DeleteWorkteamOutput)
		}
	}

	return r0, r1
}

// DeleteWorkteamWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) DeleteWorkteamWithContext(_a0 context.Context, _a1 *sagemaker.DeleteWorkteamInput, _a2 ...request.Option) (*sagemaker.DeleteWorkteamOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.DeleteWorkteamOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.DeleteWorkteamInput, ...request.Option) *sagemaker.DeleteWorkteamOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DeleteWorkteamOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.DeleteWorkteamInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeregisterDevices provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DeregisterDevices(_a0 *sagemaker.DeregisterDevicesInput) (*sagemaker.DeregisterDevicesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.DeregisterDevicesOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.DeregisterDevicesInput) *sagemaker.DeregisterDevicesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DeregisterDevicesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.DeregisterDevicesInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeregisterDevicesRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DeregisterDevicesRequest(_a0 *sagemaker.DeregisterDevicesInput) (*request.Request, *sagemaker.DeregisterDevicesOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.DeregisterDevicesInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.DeregisterDevicesOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.DeregisterDevicesInput) *sagemaker.DeregisterDevicesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.DeregisterDevicesOutput)
		}
	}

	return r0, r1
}

// DeregisterDevicesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) DeregisterDevicesWithContext(_a0 context.Context, _a1 *sagemaker.DeregisterDevicesInput, _a2 ...request.Option) (*sagemaker.DeregisterDevicesOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.DeregisterDevicesOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.DeregisterDevicesInput, ...request.Option) *sagemaker.DeregisterDevicesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DeregisterDevicesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.DeregisterDevicesInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeAction provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DescribeAction(_a0 *sagemaker.DescribeActionInput) (*sagemaker.DescribeActionOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.DescribeActionOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.DescribeActionInput) *sagemaker.DescribeActionOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DescribeActionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.DescribeActionInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeActionRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DescribeActionRequest(_a0 *sagemaker.DescribeActionInput) (*request.Request, *sagemaker.DescribeActionOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.DescribeActionInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.DescribeActionOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.DescribeActionInput) *sagemaker.DescribeActionOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.DescribeActionOutput)
		}
	}

	return r0, r1
}

// DescribeActionWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) DescribeActionWithContext(_a0 context.Context, _a1 *sagemaker.DescribeActionInput, _a2 ...request.Option) (*sagemaker.DescribeActionOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.DescribeActionOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.DescribeActionInput, ...request.Option) *sagemaker.DescribeActionOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DescribeActionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.DescribeActionInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeAlgorithm provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DescribeAlgorithm(_a0 *sagemaker.DescribeAlgorithmInput) (*sagemaker.DescribeAlgorithmOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.DescribeAlgorithmOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.DescribeAlgorithmInput) *sagemaker.DescribeAlgorithmOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DescribeAlgorithmOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.DescribeAlgorithmInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeAlgorithmRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DescribeAlgorithmRequest(_a0 *sagemaker.DescribeAlgorithmInput) (*request.Request, *sagemaker.DescribeAlgorithmOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.DescribeAlgorithmInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.DescribeAlgorithmOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.DescribeAlgorithmInput) *sagemaker.DescribeAlgorithmOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.DescribeAlgorithmOutput)
		}
	}

	return r0, r1
}

// DescribeAlgorithmWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) DescribeAlgorithmWithContext(_a0 context.Context, _a1 *sagemaker.DescribeAlgorithmInput, _a2 ...request.Option) (*sagemaker.DescribeAlgorithmOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.DescribeAlgorithmOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.DescribeAlgorithmInput, ...request.Option) *sagemaker.DescribeAlgorithmOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DescribeAlgorithmOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.DescribeAlgorithmInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeApp provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DescribeApp(_a0 *sagemaker.DescribeAppInput) (*sagemaker.DescribeAppOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.DescribeAppOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.DescribeAppInput) *sagemaker.DescribeAppOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DescribeAppOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.DescribeAppInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeAppImageConfig provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DescribeAppImageConfig(_a0 *sagemaker.DescribeAppImageConfigInput) (*sagemaker.DescribeAppImageConfigOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.DescribeAppImageConfigOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.DescribeAppImageConfigInput) *sagemaker.DescribeAppImageConfigOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DescribeAppImageConfigOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.DescribeAppImageConfigInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeAppImageConfigRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DescribeAppImageConfigRequest(_a0 *sagemaker.DescribeAppImageConfigInput) (*request.Request, *sagemaker.DescribeAppImageConfigOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.DescribeAppImageConfigInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.DescribeAppImageConfigOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.DescribeAppImageConfigInput) *sagemaker.DescribeAppImageConfigOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.DescribeAppImageConfigOutput)
		}
	}

	return r0, r1
}

// DescribeAppImageConfigWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) DescribeAppImageConfigWithContext(_a0 context.Context, _a1 *sagemaker.DescribeAppImageConfigInput, _a2 ...request.Option) (*sagemaker.DescribeAppImageConfigOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.DescribeAppImageConfigOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.DescribeAppImageConfigInput, ...request.Option) *sagemaker.DescribeAppImageConfigOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DescribeAppImageConfigOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.DescribeAppImageConfigInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeAppRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DescribeAppRequest(_a0 *sagemaker.DescribeAppInput) (*request.Request, *sagemaker.DescribeAppOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.DescribeAppInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.DescribeAppOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.DescribeAppInput) *sagemaker.DescribeAppOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.DescribeAppOutput)
		}
	}

	return r0, r1
}

// DescribeAppWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) DescribeAppWithContext(_a0 context.Context, _a1 *sagemaker.DescribeAppInput, _a2 ...request.Option) (*sagemaker.DescribeAppOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.DescribeAppOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.DescribeAppInput, ...request.Option) *sagemaker.DescribeAppOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DescribeAppOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.DescribeAppInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeArtifact provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DescribeArtifact(_a0 *sagemaker.DescribeArtifactInput) (*sagemaker.DescribeArtifactOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.DescribeArtifactOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.DescribeArtifactInput) *sagemaker.DescribeArtifactOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DescribeArtifactOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.DescribeArtifactInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeArtifactRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DescribeArtifactRequest(_a0 *sagemaker.DescribeArtifactInput) (*request.Request, *sagemaker.DescribeArtifactOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.DescribeArtifactInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.DescribeArtifactOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.DescribeArtifactInput) *sagemaker.DescribeArtifactOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.DescribeArtifactOutput)
		}
	}

	return r0, r1
}

// DescribeArtifactWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) DescribeArtifactWithContext(_a0 context.Context, _a1 *sagemaker.DescribeArtifactInput, _a2 ...request.Option) (*sagemaker.DescribeArtifactOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.DescribeArtifactOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.DescribeArtifactInput, ...request.Option) *sagemaker.DescribeArtifactOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DescribeArtifactOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.DescribeArtifactInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeAutoMLJob provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DescribeAutoMLJob(_a0 *sagemaker.DescribeAutoMLJobInput) (*sagemaker.DescribeAutoMLJobOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.DescribeAutoMLJobOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.DescribeAutoMLJobInput) *sagemaker.DescribeAutoMLJobOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DescribeAutoMLJobOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.DescribeAutoMLJobInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeAutoMLJobRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DescribeAutoMLJobRequest(_a0 *sagemaker.DescribeAutoMLJobInput) (*request.Request, *sagemaker.DescribeAutoMLJobOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.DescribeAutoMLJobInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.DescribeAutoMLJobOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.DescribeAutoMLJobInput) *sagemaker.DescribeAutoMLJobOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.DescribeAutoMLJobOutput)
		}
	}

	return r0, r1
}

// DescribeAutoMLJobWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) DescribeAutoMLJobWithContext(_a0 context.Context, _a1 *sagemaker.DescribeAutoMLJobInput, _a2 ...request.Option) (*sagemaker.DescribeAutoMLJobOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.DescribeAutoMLJobOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.DescribeAutoMLJobInput, ...request.Option) *sagemaker.DescribeAutoMLJobOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DescribeAutoMLJobOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.DescribeAutoMLJobInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeCodeRepository provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DescribeCodeRepository(_a0 *sagemaker.DescribeCodeRepositoryInput) (*sagemaker.DescribeCodeRepositoryOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.DescribeCodeRepositoryOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.DescribeCodeRepositoryInput) *sagemaker.DescribeCodeRepositoryOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DescribeCodeRepositoryOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.DescribeCodeRepositoryInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeCodeRepositoryRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DescribeCodeRepositoryRequest(_a0 *sagemaker.DescribeCodeRepositoryInput) (*request.Request, *sagemaker.DescribeCodeRepositoryOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.DescribeCodeRepositoryInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.DescribeCodeRepositoryOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.DescribeCodeRepositoryInput) *sagemaker.DescribeCodeRepositoryOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.DescribeCodeRepositoryOutput)
		}
	}

	return r0, r1
}

// DescribeCodeRepositoryWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) DescribeCodeRepositoryWithContext(_a0 context.Context, _a1 *sagemaker.DescribeCodeRepositoryInput, _a2 ...request.Option) (*sagemaker.DescribeCodeRepositoryOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.DescribeCodeRepositoryOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.DescribeCodeRepositoryInput, ...request.Option) *sagemaker.DescribeCodeRepositoryOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DescribeCodeRepositoryOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.DescribeCodeRepositoryInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeCompilationJob provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DescribeCompilationJob(_a0 *sagemaker.DescribeCompilationJobInput) (*sagemaker.DescribeCompilationJobOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.DescribeCompilationJobOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.DescribeCompilationJobInput) *sagemaker.DescribeCompilationJobOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DescribeCompilationJobOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.DescribeCompilationJobInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeCompilationJobRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DescribeCompilationJobRequest(_a0 *sagemaker.DescribeCompilationJobInput) (*request.Request, *sagemaker.DescribeCompilationJobOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.DescribeCompilationJobInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.DescribeCompilationJobOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.DescribeCompilationJobInput) *sagemaker.DescribeCompilationJobOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.DescribeCompilationJobOutput)
		}
	}

	return r0, r1
}

// DescribeCompilationJobWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) DescribeCompilationJobWithContext(_a0 context.Context, _a1 *sagemaker.DescribeCompilationJobInput, _a2 ...request.Option) (*sagemaker.DescribeCompilationJobOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.DescribeCompilationJobOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.DescribeCompilationJobInput, ...request.Option) *sagemaker.DescribeCompilationJobOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DescribeCompilationJobOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.DescribeCompilationJobInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeContext provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DescribeContext(_a0 *sagemaker.DescribeContextInput) (*sagemaker.DescribeContextOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.DescribeContextOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.DescribeContextInput) *sagemaker.DescribeContextOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DescribeContextOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.DescribeContextInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeContextRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DescribeContextRequest(_a0 *sagemaker.DescribeContextInput) (*request.Request, *sagemaker.DescribeContextOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.DescribeContextInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.DescribeContextOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.DescribeContextInput) *sagemaker.DescribeContextOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.DescribeContextOutput)
		}
	}

	return r0, r1
}

// DescribeContextWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) DescribeContextWithContext(_a0 context.Context, _a1 *sagemaker.DescribeContextInput, _a2 ...request.Option) (*sagemaker.DescribeContextOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.DescribeContextOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.DescribeContextInput, ...request.Option) *sagemaker.DescribeContextOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DescribeContextOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.DescribeContextInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeDataQualityJobDefinition provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DescribeDataQualityJobDefinition(_a0 *sagemaker.DescribeDataQualityJobDefinitionInput) (*sagemaker.DescribeDataQualityJobDefinitionOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.DescribeDataQualityJobDefinitionOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.DescribeDataQualityJobDefinitionInput) *sagemaker.DescribeDataQualityJobDefinitionOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DescribeDataQualityJobDefinitionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.DescribeDataQualityJobDefinitionInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeDataQualityJobDefinitionRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DescribeDataQualityJobDefinitionRequest(_a0 *sagemaker.DescribeDataQualityJobDefinitionInput) (*request.Request, *sagemaker.DescribeDataQualityJobDefinitionOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.DescribeDataQualityJobDefinitionInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.DescribeDataQualityJobDefinitionOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.DescribeDataQualityJobDefinitionInput) *sagemaker.DescribeDataQualityJobDefinitionOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.DescribeDataQualityJobDefinitionOutput)
		}
	}

	return r0, r1
}

// DescribeDataQualityJobDefinitionWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) DescribeDataQualityJobDefinitionWithContext(_a0 context.Context, _a1 *sagemaker.DescribeDataQualityJobDefinitionInput, _a2 ...request.Option) (*sagemaker.DescribeDataQualityJobDefinitionOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.DescribeDataQualityJobDefinitionOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.DescribeDataQualityJobDefinitionInput, ...request.Option) *sagemaker.DescribeDataQualityJobDefinitionOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DescribeDataQualityJobDefinitionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.DescribeDataQualityJobDefinitionInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeDevice provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DescribeDevice(_a0 *sagemaker.DescribeDeviceInput) (*sagemaker.DescribeDeviceOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.DescribeDeviceOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.DescribeDeviceInput) *sagemaker.DescribeDeviceOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DescribeDeviceOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.DescribeDeviceInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeDeviceFleet provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DescribeDeviceFleet(_a0 *sagemaker.DescribeDeviceFleetInput) (*sagemaker.DescribeDeviceFleetOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.DescribeDeviceFleetOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.DescribeDeviceFleetInput) *sagemaker.DescribeDeviceFleetOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DescribeDeviceFleetOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.DescribeDeviceFleetInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeDeviceFleetRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DescribeDeviceFleetRequest(_a0 *sagemaker.DescribeDeviceFleetInput) (*request.Request, *sagemaker.DescribeDeviceFleetOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.DescribeDeviceFleetInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.DescribeDeviceFleetOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.DescribeDeviceFleetInput) *sagemaker.DescribeDeviceFleetOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.DescribeDeviceFleetOutput)
		}
	}

	return r0, r1
}

// DescribeDeviceFleetWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) DescribeDeviceFleetWithContext(_a0 context.Context, _a1 *sagemaker.DescribeDeviceFleetInput, _a2 ...request.Option) (*sagemaker.DescribeDeviceFleetOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.DescribeDeviceFleetOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.DescribeDeviceFleetInput, ...request.Option) *sagemaker.DescribeDeviceFleetOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DescribeDeviceFleetOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.DescribeDeviceFleetInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeDeviceRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DescribeDeviceRequest(_a0 *sagemaker.DescribeDeviceInput) (*request.Request, *sagemaker.DescribeDeviceOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.DescribeDeviceInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.DescribeDeviceOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.DescribeDeviceInput) *sagemaker.DescribeDeviceOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.DescribeDeviceOutput)
		}
	}

	return r0, r1
}

// DescribeDeviceWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) DescribeDeviceWithContext(_a0 context.Context, _a1 *sagemaker.DescribeDeviceInput, _a2 ...request.Option) (*sagemaker.DescribeDeviceOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.DescribeDeviceOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.DescribeDeviceInput, ...request.Option) *sagemaker.DescribeDeviceOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DescribeDeviceOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.DescribeDeviceInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeDomain provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DescribeDomain(_a0 *sagemaker.DescribeDomainInput) (*sagemaker.DescribeDomainOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.DescribeDomainOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.DescribeDomainInput) *sagemaker.DescribeDomainOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DescribeDomainOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.DescribeDomainInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeDomainRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DescribeDomainRequest(_a0 *sagemaker.DescribeDomainInput) (*request.Request, *sagemaker.DescribeDomainOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.DescribeDomainInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.DescribeDomainOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.DescribeDomainInput) *sagemaker.DescribeDomainOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.DescribeDomainOutput)
		}
	}

	return r0, r1
}

// DescribeDomainWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) DescribeDomainWithContext(_a0 context.Context, _a1 *sagemaker.DescribeDomainInput, _a2 ...request.Option) (*sagemaker.DescribeDomainOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.DescribeDomainOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.DescribeDomainInput, ...request.Option) *sagemaker.DescribeDomainOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DescribeDomainOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.DescribeDomainInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeEdgePackagingJob provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DescribeEdgePackagingJob(_a0 *sagemaker.DescribeEdgePackagingJobInput) (*sagemaker.DescribeEdgePackagingJobOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.DescribeEdgePackagingJobOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.DescribeEdgePackagingJobInput) *sagemaker.DescribeEdgePackagingJobOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DescribeEdgePackagingJobOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.DescribeEdgePackagingJobInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeEdgePackagingJobRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DescribeEdgePackagingJobRequest(_a0 *sagemaker.DescribeEdgePackagingJobInput) (*request.Request, *sagemaker.DescribeEdgePackagingJobOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.DescribeEdgePackagingJobInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.DescribeEdgePackagingJobOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.DescribeEdgePackagingJobInput) *sagemaker.DescribeEdgePackagingJobOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.DescribeEdgePackagingJobOutput)
		}
	}

	return r0, r1
}

// DescribeEdgePackagingJobWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) DescribeEdgePackagingJobWithContext(_a0 context.Context, _a1 *sagemaker.DescribeEdgePackagingJobInput, _a2 ...request.Option) (*sagemaker.DescribeEdgePackagingJobOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.DescribeEdgePackagingJobOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.DescribeEdgePackagingJobInput, ...request.Option) *sagemaker.DescribeEdgePackagingJobOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DescribeEdgePackagingJobOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.DescribeEdgePackagingJobInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeEndpoint provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DescribeEndpoint(_a0 *sagemaker.DescribeEndpointInput) (*sagemaker.DescribeEndpointOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.DescribeEndpointOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.DescribeEndpointInput) *sagemaker.DescribeEndpointOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DescribeEndpointOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.DescribeEndpointInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeEndpointConfig provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DescribeEndpointConfig(_a0 *sagemaker.DescribeEndpointConfigInput) (*sagemaker.DescribeEndpointConfigOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.DescribeEndpointConfigOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.DescribeEndpointConfigInput) *sagemaker.DescribeEndpointConfigOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DescribeEndpointConfigOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.DescribeEndpointConfigInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeEndpointConfigRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DescribeEndpointConfigRequest(_a0 *sagemaker.DescribeEndpointConfigInput) (*request.Request, *sagemaker.DescribeEndpointConfigOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.DescribeEndpointConfigInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.DescribeEndpointConfigOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.DescribeEndpointConfigInput) *sagemaker.DescribeEndpointConfigOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.DescribeEndpointConfigOutput)
		}
	}

	return r0, r1
}

// DescribeEndpointConfigWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) DescribeEndpointConfigWithContext(_a0 context.Context, _a1 *sagemaker.DescribeEndpointConfigInput, _a2 ...request.Option) (*sagemaker.DescribeEndpointConfigOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.DescribeEndpointConfigOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.DescribeEndpointConfigInput, ...request.Option) *sagemaker.DescribeEndpointConfigOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DescribeEndpointConfigOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.DescribeEndpointConfigInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeEndpointRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DescribeEndpointRequest(_a0 *sagemaker.DescribeEndpointInput) (*request.Request, *sagemaker.DescribeEndpointOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.DescribeEndpointInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.DescribeEndpointOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.DescribeEndpointInput) *sagemaker.DescribeEndpointOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.DescribeEndpointOutput)
		}
	}

	return r0, r1
}

// DescribeEndpointWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) DescribeEndpointWithContext(_a0 context.Context, _a1 *sagemaker.DescribeEndpointInput, _a2 ...request.Option) (*sagemaker.DescribeEndpointOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.DescribeEndpointOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.DescribeEndpointInput, ...request.Option) *sagemaker.DescribeEndpointOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DescribeEndpointOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.DescribeEndpointInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeExperiment provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DescribeExperiment(_a0 *sagemaker.DescribeExperimentInput) (*sagemaker.DescribeExperimentOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.DescribeExperimentOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.DescribeExperimentInput) *sagemaker.DescribeExperimentOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DescribeExperimentOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.DescribeExperimentInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeExperimentRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DescribeExperimentRequest(_a0 *sagemaker.DescribeExperimentInput) (*request.Request, *sagemaker.DescribeExperimentOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.DescribeExperimentInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.DescribeExperimentOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.DescribeExperimentInput) *sagemaker.DescribeExperimentOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.DescribeExperimentOutput)
		}
	}

	return r0, r1
}

// DescribeExperimentWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) DescribeExperimentWithContext(_a0 context.Context, _a1 *sagemaker.DescribeExperimentInput, _a2 ...request.Option) (*sagemaker.DescribeExperimentOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.DescribeExperimentOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.DescribeExperimentInput, ...request.Option) *sagemaker.DescribeExperimentOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DescribeExperimentOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.DescribeExperimentInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeFeatureGroup provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DescribeFeatureGroup(_a0 *sagemaker.DescribeFeatureGroupInput) (*sagemaker.DescribeFeatureGroupOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.DescribeFeatureGroupOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.DescribeFeatureGroupInput) *sagemaker.DescribeFeatureGroupOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DescribeFeatureGroupOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.DescribeFeatureGroupInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeFeatureGroupRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DescribeFeatureGroupRequest(_a0 *sagemaker.DescribeFeatureGroupInput) (*request.Request, *sagemaker.DescribeFeatureGroupOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.DescribeFeatureGroupInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.DescribeFeatureGroupOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.DescribeFeatureGroupInput) *sagemaker.DescribeFeatureGroupOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.DescribeFeatureGroupOutput)
		}
	}

	return r0, r1
}

// DescribeFeatureGroupWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) DescribeFeatureGroupWithContext(_a0 context.Context, _a1 *sagemaker.DescribeFeatureGroupInput, _a2 ...request.Option) (*sagemaker.DescribeFeatureGroupOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.DescribeFeatureGroupOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.DescribeFeatureGroupInput, ...request.Option) *sagemaker.DescribeFeatureGroupOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DescribeFeatureGroupOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.DescribeFeatureGroupInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeFlowDefinition provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DescribeFlowDefinition(_a0 *sagemaker.DescribeFlowDefinitionInput) (*sagemaker.DescribeFlowDefinitionOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.DescribeFlowDefinitionOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.DescribeFlowDefinitionInput) *sagemaker.DescribeFlowDefinitionOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DescribeFlowDefinitionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.DescribeFlowDefinitionInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeFlowDefinitionRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DescribeFlowDefinitionRequest(_a0 *sagemaker.DescribeFlowDefinitionInput) (*request.Request, *sagemaker.DescribeFlowDefinitionOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.DescribeFlowDefinitionInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.DescribeFlowDefinitionOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.DescribeFlowDefinitionInput) *sagemaker.DescribeFlowDefinitionOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.DescribeFlowDefinitionOutput)
		}
	}

	return r0, r1
}

// DescribeFlowDefinitionWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) DescribeFlowDefinitionWithContext(_a0 context.Context, _a1 *sagemaker.DescribeFlowDefinitionInput, _a2 ...request.Option) (*sagemaker.DescribeFlowDefinitionOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.DescribeFlowDefinitionOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.DescribeFlowDefinitionInput, ...request.Option) *sagemaker.DescribeFlowDefinitionOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DescribeFlowDefinitionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.DescribeFlowDefinitionInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeHumanTaskUi provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DescribeHumanTaskUi(_a0 *sagemaker.DescribeHumanTaskUiInput) (*sagemaker.DescribeHumanTaskUiOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.DescribeHumanTaskUiOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.DescribeHumanTaskUiInput) *sagemaker.DescribeHumanTaskUiOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DescribeHumanTaskUiOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.DescribeHumanTaskUiInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeHumanTaskUiRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DescribeHumanTaskUiRequest(_a0 *sagemaker.DescribeHumanTaskUiInput) (*request.Request, *sagemaker.DescribeHumanTaskUiOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.DescribeHumanTaskUiInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.DescribeHumanTaskUiOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.DescribeHumanTaskUiInput) *sagemaker.DescribeHumanTaskUiOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.DescribeHumanTaskUiOutput)
		}
	}

	return r0, r1
}

// DescribeHumanTaskUiWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) DescribeHumanTaskUiWithContext(_a0 context.Context, _a1 *sagemaker.DescribeHumanTaskUiInput, _a2 ...request.Option) (*sagemaker.DescribeHumanTaskUiOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.DescribeHumanTaskUiOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.DescribeHumanTaskUiInput, ...request.Option) *sagemaker.DescribeHumanTaskUiOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DescribeHumanTaskUiOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.DescribeHumanTaskUiInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeHyperParameterTuningJob provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DescribeHyperParameterTuningJob(_a0 *sagemaker.DescribeHyperParameterTuningJobInput) (*sagemaker.DescribeHyperParameterTuningJobOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.DescribeHyperParameterTuningJobOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.DescribeHyperParameterTuningJobInput) *sagemaker.DescribeHyperParameterTuningJobOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DescribeHyperParameterTuningJobOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.DescribeHyperParameterTuningJobInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeHyperParameterTuningJobRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DescribeHyperParameterTuningJobRequest(_a0 *sagemaker.DescribeHyperParameterTuningJobInput) (*request.Request, *sagemaker.DescribeHyperParameterTuningJobOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.DescribeHyperParameterTuningJobInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.DescribeHyperParameterTuningJobOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.DescribeHyperParameterTuningJobInput) *sagemaker.DescribeHyperParameterTuningJobOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.DescribeHyperParameterTuningJobOutput)
		}
	}

	return r0, r1
}

// DescribeHyperParameterTuningJobWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) DescribeHyperParameterTuningJobWithContext(_a0 context.Context, _a1 *sagemaker.DescribeHyperParameterTuningJobInput, _a2 ...request.Option) (*sagemaker.DescribeHyperParameterTuningJobOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.DescribeHyperParameterTuningJobOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.DescribeHyperParameterTuningJobInput, ...request.Option) *sagemaker.DescribeHyperParameterTuningJobOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DescribeHyperParameterTuningJobOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.DescribeHyperParameterTuningJobInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeImage provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DescribeImage(_a0 *sagemaker.DescribeImageInput) (*sagemaker.DescribeImageOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.DescribeImageOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.DescribeImageInput) *sagemaker.DescribeImageOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DescribeImageOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.DescribeImageInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeImageRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DescribeImageRequest(_a0 *sagemaker.DescribeImageInput) (*request.Request, *sagemaker.DescribeImageOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.DescribeImageInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.DescribeImageOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.DescribeImageInput) *sagemaker.DescribeImageOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.DescribeImageOutput)
		}
	}

	return r0, r1
}

// DescribeImageVersion provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DescribeImageVersion(_a0 *sagemaker.DescribeImageVersionInput) (*sagemaker.DescribeImageVersionOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.DescribeImageVersionOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.DescribeImageVersionInput) *sagemaker.DescribeImageVersionOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DescribeImageVersionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.DescribeImageVersionInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeImageVersionRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DescribeImageVersionRequest(_a0 *sagemaker.DescribeImageVersionInput) (*request.Request, *sagemaker.DescribeImageVersionOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.DescribeImageVersionInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.DescribeImageVersionOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.DescribeImageVersionInput) *sagemaker.DescribeImageVersionOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.DescribeImageVersionOutput)
		}
	}

	return r0, r1
}

// DescribeImageVersionWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) DescribeImageVersionWithContext(_a0 context.Context, _a1 *sagemaker.DescribeImageVersionInput, _a2 ...request.Option) (*sagemaker.DescribeImageVersionOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.DescribeImageVersionOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.DescribeImageVersionInput, ...request.Option) *sagemaker.DescribeImageVersionOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DescribeImageVersionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.DescribeImageVersionInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeImageWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) DescribeImageWithContext(_a0 context.Context, _a1 *sagemaker.DescribeImageInput, _a2 ...request.Option) (*sagemaker.DescribeImageOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.DescribeImageOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.DescribeImageInput, ...request.Option) *sagemaker.DescribeImageOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DescribeImageOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.DescribeImageInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeLabelingJob provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DescribeLabelingJob(_a0 *sagemaker.DescribeLabelingJobInput) (*sagemaker.DescribeLabelingJobOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.DescribeLabelingJobOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.DescribeLabelingJobInput) *sagemaker.DescribeLabelingJobOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DescribeLabelingJobOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.DescribeLabelingJobInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeLabelingJobRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DescribeLabelingJobRequest(_a0 *sagemaker.DescribeLabelingJobInput) (*request.Request, *sagemaker.DescribeLabelingJobOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.DescribeLabelingJobInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.DescribeLabelingJobOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.DescribeLabelingJobInput) *sagemaker.DescribeLabelingJobOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.DescribeLabelingJobOutput)
		}
	}

	return r0, r1
}

// DescribeLabelingJobWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) DescribeLabelingJobWithContext(_a0 context.Context, _a1 *sagemaker.DescribeLabelingJobInput, _a2 ...request.Option) (*sagemaker.DescribeLabelingJobOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.DescribeLabelingJobOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.DescribeLabelingJobInput, ...request.Option) *sagemaker.DescribeLabelingJobOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DescribeLabelingJobOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.DescribeLabelingJobInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeModel provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DescribeModel(_a0 *sagemaker.DescribeModelInput) (*sagemaker.DescribeModelOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.DescribeModelOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.DescribeModelInput) *sagemaker.DescribeModelOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DescribeModelOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.DescribeModelInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeModelBiasJobDefinition provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DescribeModelBiasJobDefinition(_a0 *sagemaker.DescribeModelBiasJobDefinitionInput) (*sagemaker.DescribeModelBiasJobDefinitionOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.DescribeModelBiasJobDefinitionOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.DescribeModelBiasJobDefinitionInput) *sagemaker.DescribeModelBiasJobDefinitionOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DescribeModelBiasJobDefinitionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.DescribeModelBiasJobDefinitionInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeModelBiasJobDefinitionRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DescribeModelBiasJobDefinitionRequest(_a0 *sagemaker.DescribeModelBiasJobDefinitionInput) (*request.Request, *sagemaker.DescribeModelBiasJobDefinitionOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.DescribeModelBiasJobDefinitionInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.DescribeModelBiasJobDefinitionOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.DescribeModelBiasJobDefinitionInput) *sagemaker.DescribeModelBiasJobDefinitionOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.DescribeModelBiasJobDefinitionOutput)
		}
	}

	return r0, r1
}

// DescribeModelBiasJobDefinitionWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) DescribeModelBiasJobDefinitionWithContext(_a0 context.Context, _a1 *sagemaker.DescribeModelBiasJobDefinitionInput, _a2 ...request.Option) (*sagemaker.DescribeModelBiasJobDefinitionOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.DescribeModelBiasJobDefinitionOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.DescribeModelBiasJobDefinitionInput, ...request.Option) *sagemaker.DescribeModelBiasJobDefinitionOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DescribeModelBiasJobDefinitionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.DescribeModelBiasJobDefinitionInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeModelExplainabilityJobDefinition provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DescribeModelExplainabilityJobDefinition(_a0 *sagemaker.DescribeModelExplainabilityJobDefinitionInput) (*sagemaker.DescribeModelExplainabilityJobDefinitionOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.DescribeModelExplainabilityJobDefinitionOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.DescribeModelExplainabilityJobDefinitionInput) *sagemaker.DescribeModelExplainabilityJobDefinitionOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DescribeModelExplainabilityJobDefinitionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.DescribeModelExplainabilityJobDefinitionInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeModelExplainabilityJobDefinitionRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DescribeModelExplainabilityJobDefinitionRequest(_a0 *sagemaker.DescribeModelExplainabilityJobDefinitionInput) (*request.Request, *sagemaker.DescribeModelExplainabilityJobDefinitionOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.DescribeModelExplainabilityJobDefinitionInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.DescribeModelExplainabilityJobDefinitionOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.DescribeModelExplainabilityJobDefinitionInput) *sagemaker.DescribeModelExplainabilityJobDefinitionOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.DescribeModelExplainabilityJobDefinitionOutput)
		}
	}

	return r0, r1
}

// DescribeModelExplainabilityJobDefinitionWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) DescribeModelExplainabilityJobDefinitionWithContext(_a0 context.Context, _a1 *sagemaker.DescribeModelExplainabilityJobDefinitionInput, _a2 ...request.Option) (*sagemaker.DescribeModelExplainabilityJobDefinitionOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.DescribeModelExplainabilityJobDefinitionOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.DescribeModelExplainabilityJobDefinitionInput, ...request.Option) *sagemaker.DescribeModelExplainabilityJobDefinitionOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DescribeModelExplainabilityJobDefinitionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.DescribeModelExplainabilityJobDefinitionInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeModelPackage provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DescribeModelPackage(_a0 *sagemaker.DescribeModelPackageInput) (*sagemaker.DescribeModelPackageOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.DescribeModelPackageOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.DescribeModelPackageInput) *sagemaker.DescribeModelPackageOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DescribeModelPackageOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.DescribeModelPackageInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeModelPackageGroup provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DescribeModelPackageGroup(_a0 *sagemaker.DescribeModelPackageGroupInput) (*sagemaker.DescribeModelPackageGroupOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.DescribeModelPackageGroupOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.DescribeModelPackageGroupInput) *sagemaker.DescribeModelPackageGroupOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DescribeModelPackageGroupOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.DescribeModelPackageGroupInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeModelPackageGroupRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DescribeModelPackageGroupRequest(_a0 *sagemaker.DescribeModelPackageGroupInput) (*request.Request, *sagemaker.DescribeModelPackageGroupOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.DescribeModelPackageGroupInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.DescribeModelPackageGroupOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.DescribeModelPackageGroupInput) *sagemaker.DescribeModelPackageGroupOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.DescribeModelPackageGroupOutput)
		}
	}

	return r0, r1
}

// DescribeModelPackageGroupWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) DescribeModelPackageGroupWithContext(_a0 context.Context, _a1 *sagemaker.DescribeModelPackageGroupInput, _a2 ...request.Option) (*sagemaker.DescribeModelPackageGroupOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.DescribeModelPackageGroupOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.DescribeModelPackageGroupInput, ...request.Option) *sagemaker.DescribeModelPackageGroupOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DescribeModelPackageGroupOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.DescribeModelPackageGroupInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeModelPackageRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DescribeModelPackageRequest(_a0 *sagemaker.DescribeModelPackageInput) (*request.Request, *sagemaker.DescribeModelPackageOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.DescribeModelPackageInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.DescribeModelPackageOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.DescribeModelPackageInput) *sagemaker.DescribeModelPackageOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.DescribeModelPackageOutput)
		}
	}

	return r0, r1
}

// DescribeModelPackageWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) DescribeModelPackageWithContext(_a0 context.Context, _a1 *sagemaker.DescribeModelPackageInput, _a2 ...request.Option) (*sagemaker.DescribeModelPackageOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.DescribeModelPackageOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.DescribeModelPackageInput, ...request.Option) *sagemaker.DescribeModelPackageOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DescribeModelPackageOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.DescribeModelPackageInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeModelQualityJobDefinition provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DescribeModelQualityJobDefinition(_a0 *sagemaker.DescribeModelQualityJobDefinitionInput) (*sagemaker.DescribeModelQualityJobDefinitionOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.DescribeModelQualityJobDefinitionOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.DescribeModelQualityJobDefinitionInput) *sagemaker.DescribeModelQualityJobDefinitionOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DescribeModelQualityJobDefinitionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.DescribeModelQualityJobDefinitionInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeModelQualityJobDefinitionRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DescribeModelQualityJobDefinitionRequest(_a0 *sagemaker.DescribeModelQualityJobDefinitionInput) (*request.Request, *sagemaker.DescribeModelQualityJobDefinitionOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.DescribeModelQualityJobDefinitionInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.DescribeModelQualityJobDefinitionOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.DescribeModelQualityJobDefinitionInput) *sagemaker.DescribeModelQualityJobDefinitionOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.DescribeModelQualityJobDefinitionOutput)
		}
	}

	return r0, r1
}

// DescribeModelQualityJobDefinitionWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) DescribeModelQualityJobDefinitionWithContext(_a0 context.Context, _a1 *sagemaker.DescribeModelQualityJobDefinitionInput, _a2 ...request.Option) (*sagemaker.DescribeModelQualityJobDefinitionOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.DescribeModelQualityJobDefinitionOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.DescribeModelQualityJobDefinitionInput, ...request.Option) *sagemaker.DescribeModelQualityJobDefinitionOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DescribeModelQualityJobDefinitionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.DescribeModelQualityJobDefinitionInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeModelRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DescribeModelRequest(_a0 *sagemaker.DescribeModelInput) (*request.Request, *sagemaker.DescribeModelOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.DescribeModelInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.DescribeModelOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.DescribeModelInput) *sagemaker.DescribeModelOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.DescribeModelOutput)
		}
	}

	return r0, r1
}

// DescribeModelWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) DescribeModelWithContext(_a0 context.Context, _a1 *sagemaker.DescribeModelInput, _a2 ...request.Option) (*sagemaker.DescribeModelOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.DescribeModelOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.DescribeModelInput, ...request.Option) *sagemaker.DescribeModelOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DescribeModelOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.DescribeModelInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeMonitoringSchedule provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DescribeMonitoringSchedule(_a0 *sagemaker.DescribeMonitoringScheduleInput) (*sagemaker.DescribeMonitoringScheduleOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.DescribeMonitoringScheduleOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.DescribeMonitoringScheduleInput) *sagemaker.DescribeMonitoringScheduleOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DescribeMonitoringScheduleOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.DescribeMonitoringScheduleInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeMonitoringScheduleRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DescribeMonitoringScheduleRequest(_a0 *sagemaker.DescribeMonitoringScheduleInput) (*request.Request, *sagemaker.DescribeMonitoringScheduleOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.DescribeMonitoringScheduleInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.DescribeMonitoringScheduleOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.DescribeMonitoringScheduleInput) *sagemaker.DescribeMonitoringScheduleOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.DescribeMonitoringScheduleOutput)
		}
	}

	return r0, r1
}

// DescribeMonitoringScheduleWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) DescribeMonitoringScheduleWithContext(_a0 context.Context, _a1 *sagemaker.DescribeMonitoringScheduleInput, _a2 ...request.Option) (*sagemaker.DescribeMonitoringScheduleOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.DescribeMonitoringScheduleOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.DescribeMonitoringScheduleInput, ...request.Option) *sagemaker.DescribeMonitoringScheduleOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DescribeMonitoringScheduleOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.DescribeMonitoringScheduleInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeNotebookInstance provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DescribeNotebookInstance(_a0 *sagemaker.DescribeNotebookInstanceInput) (*sagemaker.DescribeNotebookInstanceOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.DescribeNotebookInstanceOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.DescribeNotebookInstanceInput) *sagemaker.DescribeNotebookInstanceOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DescribeNotebookInstanceOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.DescribeNotebookInstanceInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeNotebookInstanceLifecycleConfig provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DescribeNotebookInstanceLifecycleConfig(_a0 *sagemaker.DescribeNotebookInstanceLifecycleConfigInput) (*sagemaker.DescribeNotebookInstanceLifecycleConfigOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.DescribeNotebookInstanceLifecycleConfigOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.DescribeNotebookInstanceLifecycleConfigInput) *sagemaker.DescribeNotebookInstanceLifecycleConfigOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DescribeNotebookInstanceLifecycleConfigOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.DescribeNotebookInstanceLifecycleConfigInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeNotebookInstanceLifecycleConfigRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DescribeNotebookInstanceLifecycleConfigRequest(_a0 *sagemaker.DescribeNotebookInstanceLifecycleConfigInput) (*request.Request, *sagemaker.DescribeNotebookInstanceLifecycleConfigOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.DescribeNotebookInstanceLifecycleConfigInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.DescribeNotebookInstanceLifecycleConfigOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.DescribeNotebookInstanceLifecycleConfigInput) *sagemaker.DescribeNotebookInstanceLifecycleConfigOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.DescribeNotebookInstanceLifecycleConfigOutput)
		}
	}

	return r0, r1
}

// DescribeNotebookInstanceLifecycleConfigWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) DescribeNotebookInstanceLifecycleConfigWithContext(_a0 context.Context, _a1 *sagemaker.DescribeNotebookInstanceLifecycleConfigInput, _a2 ...request.Option) (*sagemaker.DescribeNotebookInstanceLifecycleConfigOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.DescribeNotebookInstanceLifecycleConfigOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.DescribeNotebookInstanceLifecycleConfigInput, ...request.Option) *sagemaker.DescribeNotebookInstanceLifecycleConfigOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DescribeNotebookInstanceLifecycleConfigOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.DescribeNotebookInstanceLifecycleConfigInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeNotebookInstanceRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DescribeNotebookInstanceRequest(_a0 *sagemaker.DescribeNotebookInstanceInput) (*request.Request, *sagemaker.DescribeNotebookInstanceOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.DescribeNotebookInstanceInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.DescribeNotebookInstanceOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.DescribeNotebookInstanceInput) *sagemaker.DescribeNotebookInstanceOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.DescribeNotebookInstanceOutput)
		}
	}

	return r0, r1
}

// DescribeNotebookInstanceWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) DescribeNotebookInstanceWithContext(_a0 context.Context, _a1 *sagemaker.DescribeNotebookInstanceInput, _a2 ...request.Option) (*sagemaker.DescribeNotebookInstanceOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.DescribeNotebookInstanceOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.DescribeNotebookInstanceInput, ...request.Option) *sagemaker.DescribeNotebookInstanceOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DescribeNotebookInstanceOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.DescribeNotebookInstanceInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribePipeline provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DescribePipeline(_a0 *sagemaker.DescribePipelineInput) (*sagemaker.DescribePipelineOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.DescribePipelineOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.DescribePipelineInput) *sagemaker.DescribePipelineOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DescribePipelineOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.DescribePipelineInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribePipelineDefinitionForExecution provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DescribePipelineDefinitionForExecution(_a0 *sagemaker.DescribePipelineDefinitionForExecutionInput) (*sagemaker.DescribePipelineDefinitionForExecutionOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.DescribePipelineDefinitionForExecutionOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.DescribePipelineDefinitionForExecutionInput) *sagemaker.DescribePipelineDefinitionForExecutionOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DescribePipelineDefinitionForExecutionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.DescribePipelineDefinitionForExecutionInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribePipelineDefinitionForExecutionRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DescribePipelineDefinitionForExecutionRequest(_a0 *sagemaker.DescribePipelineDefinitionForExecutionInput) (*request.Request, *sagemaker.DescribePipelineDefinitionForExecutionOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.DescribePipelineDefinitionForExecutionInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.DescribePipelineDefinitionForExecutionOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.DescribePipelineDefinitionForExecutionInput) *sagemaker.DescribePipelineDefinitionForExecutionOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.DescribePipelineDefinitionForExecutionOutput)
		}
	}

	return r0, r1
}

// DescribePipelineDefinitionForExecutionWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) DescribePipelineDefinitionForExecutionWithContext(_a0 context.Context, _a1 *sagemaker.DescribePipelineDefinitionForExecutionInput, _a2 ...request.Option) (*sagemaker.DescribePipelineDefinitionForExecutionOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.DescribePipelineDefinitionForExecutionOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.DescribePipelineDefinitionForExecutionInput, ...request.Option) *sagemaker.DescribePipelineDefinitionForExecutionOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DescribePipelineDefinitionForExecutionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.DescribePipelineDefinitionForExecutionInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribePipelineExecution provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DescribePipelineExecution(_a0 *sagemaker.DescribePipelineExecutionInput) (*sagemaker.DescribePipelineExecutionOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.DescribePipelineExecutionOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.DescribePipelineExecutionInput) *sagemaker.DescribePipelineExecutionOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DescribePipelineExecutionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.DescribePipelineExecutionInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribePipelineExecutionRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DescribePipelineExecutionRequest(_a0 *sagemaker.DescribePipelineExecutionInput) (*request.Request, *sagemaker.DescribePipelineExecutionOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.DescribePipelineExecutionInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.DescribePipelineExecutionOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.DescribePipelineExecutionInput) *sagemaker.DescribePipelineExecutionOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.DescribePipelineExecutionOutput)
		}
	}

	return r0, r1
}

// DescribePipelineExecutionWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) DescribePipelineExecutionWithContext(_a0 context.Context, _a1 *sagemaker.DescribePipelineExecutionInput, _a2 ...request.Option) (*sagemaker.DescribePipelineExecutionOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.DescribePipelineExecutionOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.DescribePipelineExecutionInput, ...request.Option) *sagemaker.DescribePipelineExecutionOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DescribePipelineExecutionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.DescribePipelineExecutionInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribePipelineRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DescribePipelineRequest(_a0 *sagemaker.DescribePipelineInput) (*request.Request, *sagemaker.DescribePipelineOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.DescribePipelineInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.DescribePipelineOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.DescribePipelineInput) *sagemaker.DescribePipelineOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.DescribePipelineOutput)
		}
	}

	return r0, r1
}

// DescribePipelineWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) DescribePipelineWithContext(_a0 context.Context, _a1 *sagemaker.DescribePipelineInput, _a2 ...request.Option) (*sagemaker.DescribePipelineOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.DescribePipelineOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.DescribePipelineInput, ...request.Option) *sagemaker.DescribePipelineOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DescribePipelineOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.DescribePipelineInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeProcessingJob provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DescribeProcessingJob(_a0 *sagemaker.DescribeProcessingJobInput) (*sagemaker.DescribeProcessingJobOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.DescribeProcessingJobOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.DescribeProcessingJobInput) *sagemaker.DescribeProcessingJobOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DescribeProcessingJobOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.DescribeProcessingJobInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeProcessingJobRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DescribeProcessingJobRequest(_a0 *sagemaker.DescribeProcessingJobInput) (*request.Request, *sagemaker.DescribeProcessingJobOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.DescribeProcessingJobInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.DescribeProcessingJobOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.DescribeProcessingJobInput) *sagemaker.DescribeProcessingJobOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.DescribeProcessingJobOutput)
		}
	}

	return r0, r1
}

// DescribeProcessingJobWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) DescribeProcessingJobWithContext(_a0 context.Context, _a1 *sagemaker.DescribeProcessingJobInput, _a2 ...request.Option) (*sagemaker.DescribeProcessingJobOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.DescribeProcessingJobOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.DescribeProcessingJobInput, ...request.Option) *sagemaker.DescribeProcessingJobOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DescribeProcessingJobOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.DescribeProcessingJobInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeProject provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DescribeProject(_a0 *sagemaker.DescribeProjectInput) (*sagemaker.DescribeProjectOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.DescribeProjectOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.DescribeProjectInput) *sagemaker.DescribeProjectOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DescribeProjectOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.DescribeProjectInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeProjectRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DescribeProjectRequest(_a0 *sagemaker.DescribeProjectInput) (*request.Request, *sagemaker.DescribeProjectOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.DescribeProjectInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.DescribeProjectOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.DescribeProjectInput) *sagemaker.DescribeProjectOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.DescribeProjectOutput)
		}
	}

	return r0, r1
}

// DescribeProjectWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) DescribeProjectWithContext(_a0 context.Context, _a1 *sagemaker.DescribeProjectInput, _a2 ...request.Option) (*sagemaker.DescribeProjectOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.DescribeProjectOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.DescribeProjectInput, ...request.Option) *sagemaker.DescribeProjectOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DescribeProjectOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.DescribeProjectInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeSubscribedWorkteam provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DescribeSubscribedWorkteam(_a0 *sagemaker.DescribeSubscribedWorkteamInput) (*sagemaker.DescribeSubscribedWorkteamOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.DescribeSubscribedWorkteamOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.DescribeSubscribedWorkteamInput) *sagemaker.DescribeSubscribedWorkteamOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DescribeSubscribedWorkteamOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.DescribeSubscribedWorkteamInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeSubscribedWorkteamRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DescribeSubscribedWorkteamRequest(_a0 *sagemaker.DescribeSubscribedWorkteamInput) (*request.Request, *sagemaker.DescribeSubscribedWorkteamOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.DescribeSubscribedWorkteamInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.DescribeSubscribedWorkteamOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.DescribeSubscribedWorkteamInput) *sagemaker.DescribeSubscribedWorkteamOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.DescribeSubscribedWorkteamOutput)
		}
	}

	return r0, r1
}

// DescribeSubscribedWorkteamWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) DescribeSubscribedWorkteamWithContext(_a0 context.Context, _a1 *sagemaker.DescribeSubscribedWorkteamInput, _a2 ...request.Option) (*sagemaker.DescribeSubscribedWorkteamOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.DescribeSubscribedWorkteamOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.DescribeSubscribedWorkteamInput, ...request.Option) *sagemaker.DescribeSubscribedWorkteamOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DescribeSubscribedWorkteamOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.DescribeSubscribedWorkteamInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeTrainingJob provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DescribeTrainingJob(_a0 *sagemaker.DescribeTrainingJobInput) (*sagemaker.DescribeTrainingJobOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.DescribeTrainingJobOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.DescribeTrainingJobInput) *sagemaker.DescribeTrainingJobOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DescribeTrainingJobOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.DescribeTrainingJobInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeTrainingJobRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DescribeTrainingJobRequest(_a0 *sagemaker.DescribeTrainingJobInput) (*request.Request, *sagemaker.DescribeTrainingJobOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.DescribeTrainingJobInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.DescribeTrainingJobOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.DescribeTrainingJobInput) *sagemaker.DescribeTrainingJobOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.DescribeTrainingJobOutput)
		}
	}

	return r0, r1
}

// DescribeTrainingJobWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) DescribeTrainingJobWithContext(_a0 context.Context, _a1 *sagemaker.DescribeTrainingJobInput, _a2 ...request.Option) (*sagemaker.DescribeTrainingJobOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.DescribeTrainingJobOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.DescribeTrainingJobInput, ...request.Option) *sagemaker.DescribeTrainingJobOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DescribeTrainingJobOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.DescribeTrainingJobInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeTransformJob provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DescribeTransformJob(_a0 *sagemaker.DescribeTransformJobInput) (*sagemaker.DescribeTransformJobOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.DescribeTransformJobOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.DescribeTransformJobInput) *sagemaker.DescribeTransformJobOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DescribeTransformJobOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.DescribeTransformJobInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeTransformJobRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DescribeTransformJobRequest(_a0 *sagemaker.DescribeTransformJobInput) (*request.Request, *sagemaker.DescribeTransformJobOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.DescribeTransformJobInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.DescribeTransformJobOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.DescribeTransformJobInput) *sagemaker.DescribeTransformJobOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.DescribeTransformJobOutput)
		}
	}

	return r0, r1
}

// DescribeTransformJobWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) DescribeTransformJobWithContext(_a0 context.Context, _a1 *sagemaker.DescribeTransformJobInput, _a2 ...request.Option) (*sagemaker.DescribeTransformJobOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.DescribeTransformJobOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.DescribeTransformJobInput, ...request.Option) *sagemaker.DescribeTransformJobOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DescribeTransformJobOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.DescribeTransformJobInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeTrial provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DescribeTrial(_a0 *sagemaker.DescribeTrialInput) (*sagemaker.DescribeTrialOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.DescribeTrialOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.DescribeTrialInput) *sagemaker.DescribeTrialOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DescribeTrialOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.DescribeTrialInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeTrialComponent provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DescribeTrialComponent(_a0 *sagemaker.DescribeTrialComponentInput) (*sagemaker.DescribeTrialComponentOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.DescribeTrialComponentOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.DescribeTrialComponentInput) *sagemaker.DescribeTrialComponentOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DescribeTrialComponentOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.DescribeTrialComponentInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeTrialComponentRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DescribeTrialComponentRequest(_a0 *sagemaker.DescribeTrialComponentInput) (*request.Request, *sagemaker.DescribeTrialComponentOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.DescribeTrialComponentInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.DescribeTrialComponentOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.DescribeTrialComponentInput) *sagemaker.DescribeTrialComponentOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.DescribeTrialComponentOutput)
		}
	}

	return r0, r1
}

// DescribeTrialComponentWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) DescribeTrialComponentWithContext(_a0 context.Context, _a1 *sagemaker.DescribeTrialComponentInput, _a2 ...request.Option) (*sagemaker.DescribeTrialComponentOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.DescribeTrialComponentOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.DescribeTrialComponentInput, ...request.Option) *sagemaker.DescribeTrialComponentOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DescribeTrialComponentOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.DescribeTrialComponentInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeTrialRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DescribeTrialRequest(_a0 *sagemaker.DescribeTrialInput) (*request.Request, *sagemaker.DescribeTrialOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.DescribeTrialInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.DescribeTrialOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.DescribeTrialInput) *sagemaker.DescribeTrialOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.DescribeTrialOutput)
		}
	}

	return r0, r1
}

// DescribeTrialWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) DescribeTrialWithContext(_a0 context.Context, _a1 *sagemaker.DescribeTrialInput, _a2 ...request.Option) (*sagemaker.DescribeTrialOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.DescribeTrialOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.DescribeTrialInput, ...request.Option) *sagemaker.DescribeTrialOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DescribeTrialOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.DescribeTrialInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeUserProfile provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DescribeUserProfile(_a0 *sagemaker.DescribeUserProfileInput) (*sagemaker.DescribeUserProfileOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.DescribeUserProfileOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.DescribeUserProfileInput) *sagemaker.DescribeUserProfileOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DescribeUserProfileOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.DescribeUserProfileInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeUserProfileRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DescribeUserProfileRequest(_a0 *sagemaker.DescribeUserProfileInput) (*request.Request, *sagemaker.DescribeUserProfileOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.DescribeUserProfileInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.DescribeUserProfileOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.DescribeUserProfileInput) *sagemaker.DescribeUserProfileOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.DescribeUserProfileOutput)
		}
	}

	return r0, r1
}

// DescribeUserProfileWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) DescribeUserProfileWithContext(_a0 context.Context, _a1 *sagemaker.DescribeUserProfileInput, _a2 ...request.Option) (*sagemaker.DescribeUserProfileOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.DescribeUserProfileOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.DescribeUserProfileInput, ...request.Option) *sagemaker.DescribeUserProfileOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DescribeUserProfileOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.DescribeUserProfileInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeWorkforce provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DescribeWorkforce(_a0 *sagemaker.DescribeWorkforceInput) (*sagemaker.DescribeWorkforceOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.DescribeWorkforceOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.DescribeWorkforceInput) *sagemaker.DescribeWorkforceOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DescribeWorkforceOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.DescribeWorkforceInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeWorkforceRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DescribeWorkforceRequest(_a0 *sagemaker.DescribeWorkforceInput) (*request.Request, *sagemaker.DescribeWorkforceOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.DescribeWorkforceInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.DescribeWorkforceOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.DescribeWorkforceInput) *sagemaker.DescribeWorkforceOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.DescribeWorkforceOutput)
		}
	}

	return r0, r1
}

// DescribeWorkforceWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) DescribeWorkforceWithContext(_a0 context.Context, _a1 *sagemaker.DescribeWorkforceInput, _a2 ...request.Option) (*sagemaker.DescribeWorkforceOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.DescribeWorkforceOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.DescribeWorkforceInput, ...request.Option) *sagemaker.DescribeWorkforceOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DescribeWorkforceOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.DescribeWorkforceInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeWorkteam provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DescribeWorkteam(_a0 *sagemaker.DescribeWorkteamInput) (*sagemaker.DescribeWorkteamOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.DescribeWorkteamOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.DescribeWorkteamInput) *sagemaker.DescribeWorkteamOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DescribeWorkteamOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.DescribeWorkteamInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeWorkteamRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DescribeWorkteamRequest(_a0 *sagemaker.DescribeWorkteamInput) (*request.Request, *sagemaker.DescribeWorkteamOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.DescribeWorkteamInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.DescribeWorkteamOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.DescribeWorkteamInput) *sagemaker.DescribeWorkteamOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.DescribeWorkteamOutput)
		}
	}

	return r0, r1
}

// DescribeWorkteamWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) DescribeWorkteamWithContext(_a0 context.Context, _a1 *sagemaker.DescribeWorkteamInput, _a2 ...request.Option) (*sagemaker.DescribeWorkteamOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.DescribeWorkteamOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.DescribeWorkteamInput, ...request.Option) *sagemaker.DescribeWorkteamOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DescribeWorkteamOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.DescribeWorkteamInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DisableSagemakerServicecatalogPortfolio provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DisableSagemakerServicecatalogPortfolio(_a0 *sagemaker.DisableSagemakerServicecatalogPortfolioInput) (*sagemaker.DisableSagemakerServicecatalogPortfolioOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.DisableSagemakerServicecatalogPortfolioOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.DisableSagemakerServicecatalogPortfolioInput) *sagemaker.DisableSagemakerServicecatalogPortfolioOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DisableSagemakerServicecatalogPortfolioOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.DisableSagemakerServicecatalogPortfolioInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DisableSagemakerServicecatalogPortfolioRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DisableSagemakerServicecatalogPortfolioRequest(_a0 *sagemaker.DisableSagemakerServicecatalogPortfolioInput) (*request.Request, *sagemaker.DisableSagemakerServicecatalogPortfolioOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.DisableSagemakerServicecatalogPortfolioInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.DisableSagemakerServicecatalogPortfolioOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.DisableSagemakerServicecatalogPortfolioInput) *sagemaker.DisableSagemakerServicecatalogPortfolioOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.DisableSagemakerServicecatalogPortfolioOutput)
		}
	}

	return r0, r1
}

// DisableSagemakerServicecatalogPortfolioWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) DisableSagemakerServicecatalogPortfolioWithContext(_a0 context.Context, _a1 *sagemaker.DisableSagemakerServicecatalogPortfolioInput, _a2 ...request.Option) (*sagemaker.DisableSagemakerServicecatalogPortfolioOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.DisableSagemakerServicecatalogPortfolioOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.DisableSagemakerServicecatalogPortfolioInput, ...request.Option) *sagemaker.DisableSagemakerServicecatalogPortfolioOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DisableSagemakerServicecatalogPortfolioOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.DisableSagemakerServicecatalogPortfolioInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DisassociateTrialComponent provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DisassociateTrialComponent(_a0 *sagemaker.DisassociateTrialComponentInput) (*sagemaker.DisassociateTrialComponentOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.DisassociateTrialComponentOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.DisassociateTrialComponentInput) *sagemaker.DisassociateTrialComponentOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DisassociateTrialComponentOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.DisassociateTrialComponentInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DisassociateTrialComponentRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) DisassociateTrialComponentRequest(_a0 *sagemaker.DisassociateTrialComponentInput) (*request.Request, *sagemaker.DisassociateTrialComponentOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.DisassociateTrialComponentInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.DisassociateTrialComponentOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.DisassociateTrialComponentInput) *sagemaker.DisassociateTrialComponentOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.DisassociateTrialComponentOutput)
		}
	}

	return r0, r1
}

// DisassociateTrialComponentWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) DisassociateTrialComponentWithContext(_a0 context.Context, _a1 *sagemaker.DisassociateTrialComponentInput, _a2 ...request.Option) (*sagemaker.DisassociateTrialComponentOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.DisassociateTrialComponentOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.DisassociateTrialComponentInput, ...request.Option) *sagemaker.DisassociateTrialComponentOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.DisassociateTrialComponentOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.DisassociateTrialComponentInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EnableSagemakerServicecatalogPortfolio provides a mock function with given fields: _a0
func (_m *SageMakerAPI) EnableSagemakerServicecatalogPortfolio(_a0 *sagemaker.EnableSagemakerServicecatalogPortfolioInput) (*sagemaker.EnableSagemakerServicecatalogPortfolioOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.EnableSagemakerServicecatalogPortfolioOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.EnableSagemakerServicecatalogPortfolioInput) *sagemaker.EnableSagemakerServicecatalogPortfolioOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.EnableSagemakerServicecatalogPortfolioOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.EnableSagemakerServicecatalogPortfolioInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EnableSagemakerServicecatalogPortfolioRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) EnableSagemakerServicecatalogPortfolioRequest(_a0 *sagemaker.EnableSagemakerServicecatalogPortfolioInput) (*request.Request, *sagemaker.EnableSagemakerServicecatalogPortfolioOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.EnableSagemakerServicecatalogPortfolioInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.EnableSagemakerServicecatalogPortfolioOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.EnableSagemakerServicecatalogPortfolioInput) *sagemaker.EnableSagemakerServicecatalogPortfolioOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.EnableSagemakerServicecatalogPortfolioOutput)
		}
	}

	return r0, r1
}

// EnableSagemakerServicecatalogPortfolioWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) EnableSagemakerServicecatalogPortfolioWithContext(_a0 context.Context, _a1 *sagemaker.EnableSagemakerServicecatalogPortfolioInput, _a2 ...request.Option) (*sagemaker.EnableSagemakerServicecatalogPortfolioOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.EnableSagemakerServicecatalogPortfolioOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.EnableSagemakerServicecatalogPortfolioInput, ...request.Option) *sagemaker.EnableSagemakerServicecatalogPortfolioOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.EnableSagemakerServicecatalogPortfolioOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.EnableSagemakerServicecatalogPortfolioInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetDeviceFleetReport provides a mock function with given fields: _a0
func (_m *SageMakerAPI) GetDeviceFleetReport(_a0 *sagemaker.GetDeviceFleetReportInput) (*sagemaker.GetDeviceFleetReportOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.GetDeviceFleetReportOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.GetDeviceFleetReportInput) *sagemaker.GetDeviceFleetReportOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.GetDeviceFleetReportOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.GetDeviceFleetReportInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetDeviceFleetReportRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) GetDeviceFleetReportRequest(_a0 *sagemaker.GetDeviceFleetReportInput) (*request.Request, *sagemaker.GetDeviceFleetReportOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.GetDeviceFleetReportInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.GetDeviceFleetReportOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.GetDeviceFleetReportInput) *sagemaker.GetDeviceFleetReportOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.GetDeviceFleetReportOutput)
		}
	}

	return r0, r1
}

// GetDeviceFleetReportWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) GetDeviceFleetReportWithContext(_a0 context.Context, _a1 *sagemaker.GetDeviceFleetReportInput, _a2 ...request.Option) (*sagemaker.GetDeviceFleetReportOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.GetDeviceFleetReportOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.GetDeviceFleetReportInput, ...request.Option) *sagemaker.GetDeviceFleetReportOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.GetDeviceFleetReportOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.GetDeviceFleetReportInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetModelPackageGroupPolicy provides a mock function with given fields: _a0
func (_m *SageMakerAPI) GetModelPackageGroupPolicy(_a0 *sagemaker.GetModelPackageGroupPolicyInput) (*sagemaker.GetModelPackageGroupPolicyOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.GetModelPackageGroupPolicyOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.GetModelPackageGroupPolicyInput) *sagemaker.GetModelPackageGroupPolicyOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.GetModelPackageGroupPolicyOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.GetModelPackageGroupPolicyInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetModelPackageGroupPolicyRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) GetModelPackageGroupPolicyRequest(_a0 *sagemaker.GetModelPackageGroupPolicyInput) (*request.Request, *sagemaker.GetModelPackageGroupPolicyOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.GetModelPackageGroupPolicyInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.GetModelPackageGroupPolicyOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.GetModelPackageGroupPolicyInput) *sagemaker.GetModelPackageGroupPolicyOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.GetModelPackageGroupPolicyOutput)
		}
	}

	return r0, r1
}

// GetModelPackageGroupPolicyWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) GetModelPackageGroupPolicyWithContext(_a0 context.Context, _a1 *sagemaker.GetModelPackageGroupPolicyInput, _a2 ...request.Option) (*sagemaker.GetModelPackageGroupPolicyOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.GetModelPackageGroupPolicyOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.GetModelPackageGroupPolicyInput, ...request.Option) *sagemaker.GetModelPackageGroupPolicyOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.GetModelPackageGroupPolicyOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.GetModelPackageGroupPolicyInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetSagemakerServicecatalogPortfolioStatus provides a mock function with given fields: _a0
func (_m *SageMakerAPI) GetSagemakerServicecatalogPortfolioStatus(_a0 *sagemaker.GetSagemakerServicecatalogPortfolioStatusInput) (*sagemaker.GetSagemakerServicecatalogPortfolioStatusOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.GetSagemakerServicecatalogPortfolioStatusOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.GetSagemakerServicecatalogPortfolioStatusInput) *sagemaker.GetSagemakerServicecatalogPortfolioStatusOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.GetSagemakerServicecatalogPortfolioStatusOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.GetSagemakerServicecatalogPortfolioStatusInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetSagemakerServicecatalogPortfolioStatusRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) GetSagemakerServicecatalogPortfolioStatusRequest(_a0 *sagemaker.GetSagemakerServicecatalogPortfolioStatusInput) (*request.Request, *sagemaker.GetSagemakerServicecatalogPortfolioStatusOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.GetSagemakerServicecatalogPortfolioStatusInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.GetSagemakerServicecatalogPortfolioStatusOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.GetSagemakerServicecatalogPortfolioStatusInput) *sagemaker.GetSagemakerServicecatalogPortfolioStatusOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.GetSagemakerServicecatalogPortfolioStatusOutput)
		}
	}

	return r0, r1
}

// GetSagemakerServicecatalogPortfolioStatusWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) GetSagemakerServicecatalogPortfolioStatusWithContext(_a0 context.Context, _a1 *sagemaker.GetSagemakerServicecatalogPortfolioStatusInput, _a2 ...request.Option) (*sagemaker.GetSagemakerServicecatalogPortfolioStatusOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.GetSagemakerServicecatalogPortfolioStatusOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.GetSagemakerServicecatalogPortfolioStatusInput, ...request.Option) *sagemaker.GetSagemakerServicecatalogPortfolioStatusOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.GetSagemakerServicecatalogPortfolioStatusOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.GetSagemakerServicecatalogPortfolioStatusInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetSearchSuggestions provides a mock function with given fields: _a0
func (_m *SageMakerAPI) GetSearchSuggestions(_a0 *sagemaker.GetSearchSuggestionsInput) (*sagemaker.GetSearchSuggestionsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.GetSearchSuggestionsOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.GetSearchSuggestionsInput) *sagemaker.GetSearchSuggestionsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.GetSearchSuggestionsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.GetSearchSuggestionsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetSearchSuggestionsRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) GetSearchSuggestionsRequest(_a0 *sagemaker.GetSearchSuggestionsInput) (*request.Request, *sagemaker.GetSearchSuggestionsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.GetSearchSuggestionsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.GetSearchSuggestionsOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.GetSearchSuggestionsInput) *sagemaker.GetSearchSuggestionsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.GetSearchSuggestionsOutput)
		}
	}

	return r0, r1
}

// GetSearchSuggestionsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) GetSearchSuggestionsWithContext(_a0 context.Context, _a1 *sagemaker.GetSearchSuggestionsInput, _a2 ...request.Option) (*sagemaker.GetSearchSuggestionsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.GetSearchSuggestionsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.GetSearchSuggestionsInput, ...request.Option) *sagemaker.GetSearchSuggestionsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.GetSearchSuggestionsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.GetSearchSuggestionsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListActions provides a mock function with given fields: _a0
func (_m *SageMakerAPI) ListActions(_a0 *sagemaker.ListActionsInput) (*sagemaker.ListActionsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.ListActionsOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.ListActionsInput) *sagemaker.ListActionsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.ListActionsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.ListActionsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListActionsPages provides a mock function with given fields: _a0, _a1
func (_m *SageMakerAPI) ListActionsPages(_a0 *sagemaker.ListActionsInput, _a1 func(*sagemaker.ListActionsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*sagemaker.ListActionsInput, func(*sagemaker.ListActionsOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListActionsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *SageMakerAPI) ListActionsPagesWithContext(_a0 context.Context, _a1 *sagemaker.ListActionsInput, _a2 func(*sagemaker.ListActionsOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.ListActionsInput, func(*sagemaker.ListActionsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListActionsRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) ListActionsRequest(_a0 *sagemaker.ListActionsInput) (*request.Request, *sagemaker.ListActionsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.ListActionsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.ListActionsOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.ListActionsInput) *sagemaker.ListActionsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.ListActionsOutput)
		}
	}

	return r0, r1
}

// ListActionsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) ListActionsWithContext(_a0 context.Context, _a1 *sagemaker.ListActionsInput, _a2 ...request.Option) (*sagemaker.ListActionsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.ListActionsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.ListActionsInput, ...request.Option) *sagemaker.ListActionsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.ListActionsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.ListActionsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListAlgorithms provides a mock function with given fields: _a0
func (_m *SageMakerAPI) ListAlgorithms(_a0 *sagemaker.ListAlgorithmsInput) (*sagemaker.ListAlgorithmsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.ListAlgorithmsOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.ListAlgorithmsInput) *sagemaker.ListAlgorithmsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.ListAlgorithmsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.ListAlgorithmsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListAlgorithmsPages provides a mock function with given fields: _a0, _a1
func (_m *SageMakerAPI) ListAlgorithmsPages(_a0 *sagemaker.ListAlgorithmsInput, _a1 func(*sagemaker.ListAlgorithmsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*sagemaker.ListAlgorithmsInput, func(*sagemaker.ListAlgorithmsOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListAlgorithmsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *SageMakerAPI) ListAlgorithmsPagesWithContext(_a0 context.Context, _a1 *sagemaker.ListAlgorithmsInput, _a2 func(*sagemaker.ListAlgorithmsOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.ListAlgorithmsInput, func(*sagemaker.ListAlgorithmsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListAlgorithmsRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) ListAlgorithmsRequest(_a0 *sagemaker.ListAlgorithmsInput) (*request.Request, *sagemaker.ListAlgorithmsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.ListAlgorithmsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.ListAlgorithmsOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.ListAlgorithmsInput) *sagemaker.ListAlgorithmsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.ListAlgorithmsOutput)
		}
	}

	return r0, r1
}

// ListAlgorithmsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) ListAlgorithmsWithContext(_a0 context.Context, _a1 *sagemaker.ListAlgorithmsInput, _a2 ...request.Option) (*sagemaker.ListAlgorithmsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.ListAlgorithmsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.ListAlgorithmsInput, ...request.Option) *sagemaker.ListAlgorithmsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.ListAlgorithmsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.ListAlgorithmsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListAppImageConfigs provides a mock function with given fields: _a0
func (_m *SageMakerAPI) ListAppImageConfigs(_a0 *sagemaker.ListAppImageConfigsInput) (*sagemaker.ListAppImageConfigsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.ListAppImageConfigsOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.ListAppImageConfigsInput) *sagemaker.ListAppImageConfigsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.ListAppImageConfigsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.ListAppImageConfigsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListAppImageConfigsPages provides a mock function with given fields: _a0, _a1
func (_m *SageMakerAPI) ListAppImageConfigsPages(_a0 *sagemaker.ListAppImageConfigsInput, _a1 func(*sagemaker.ListAppImageConfigsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*sagemaker.ListAppImageConfigsInput, func(*sagemaker.ListAppImageConfigsOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListAppImageConfigsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *SageMakerAPI) ListAppImageConfigsPagesWithContext(_a0 context.Context, _a1 *sagemaker.ListAppImageConfigsInput, _a2 func(*sagemaker.ListAppImageConfigsOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.ListAppImageConfigsInput, func(*sagemaker.ListAppImageConfigsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListAppImageConfigsRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) ListAppImageConfigsRequest(_a0 *sagemaker.ListAppImageConfigsInput) (*request.Request, *sagemaker.ListAppImageConfigsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.ListAppImageConfigsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.ListAppImageConfigsOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.ListAppImageConfigsInput) *sagemaker.ListAppImageConfigsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.ListAppImageConfigsOutput)
		}
	}

	return r0, r1
}

// ListAppImageConfigsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) ListAppImageConfigsWithContext(_a0 context.Context, _a1 *sagemaker.ListAppImageConfigsInput, _a2 ...request.Option) (*sagemaker.ListAppImageConfigsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.ListAppImageConfigsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.ListAppImageConfigsInput, ...request.Option) *sagemaker.ListAppImageConfigsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.ListAppImageConfigsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.ListAppImageConfigsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListApps provides a mock function with given fields: _a0
func (_m *SageMakerAPI) ListApps(_a0 *sagemaker.ListAppsInput) (*sagemaker.ListAppsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.ListAppsOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.ListAppsInput) *sagemaker.ListAppsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.ListAppsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.ListAppsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListAppsPages provides a mock function with given fields: _a0, _a1
func (_m *SageMakerAPI) ListAppsPages(_a0 *sagemaker.ListAppsInput, _a1 func(*sagemaker.ListAppsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*sagemaker.ListAppsInput, func(*sagemaker.ListAppsOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListAppsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *SageMakerAPI) ListAppsPagesWithContext(_a0 context.Context, _a1 *sagemaker.ListAppsInput, _a2 func(*sagemaker.ListAppsOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.ListAppsInput, func(*sagemaker.ListAppsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListAppsRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) ListAppsRequest(_a0 *sagemaker.ListAppsInput) (*request.Request, *sagemaker.ListAppsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.ListAppsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.ListAppsOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.ListAppsInput) *sagemaker.ListAppsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.ListAppsOutput)
		}
	}

	return r0, r1
}

// ListAppsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) ListAppsWithContext(_a0 context.Context, _a1 *sagemaker.ListAppsInput, _a2 ...request.Option) (*sagemaker.ListAppsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.ListAppsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.ListAppsInput, ...request.Option) *sagemaker.ListAppsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.ListAppsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.ListAppsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListArtifacts provides a mock function with given fields: _a0
func (_m *SageMakerAPI) ListArtifacts(_a0 *sagemaker.ListArtifactsInput) (*sagemaker.ListArtifactsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.ListArtifactsOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.ListArtifactsInput) *sagemaker.ListArtifactsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.ListArtifactsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.ListArtifactsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListArtifactsPages provides a mock function with given fields: _a0, _a1
func (_m *SageMakerAPI) ListArtifactsPages(_a0 *sagemaker.ListArtifactsInput, _a1 func(*sagemaker.ListArtifactsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*sagemaker.ListArtifactsInput, func(*sagemaker.ListArtifactsOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListArtifactsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *SageMakerAPI) ListArtifactsPagesWithContext(_a0 context.Context, _a1 *sagemaker.ListArtifactsInput, _a2 func(*sagemaker.ListArtifactsOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.ListArtifactsInput, func(*sagemaker.ListArtifactsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListArtifactsRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) ListArtifactsRequest(_a0 *sagemaker.ListArtifactsInput) (*request.Request, *sagemaker.ListArtifactsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.ListArtifactsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.ListArtifactsOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.ListArtifactsInput) *sagemaker.ListArtifactsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.ListArtifactsOutput)
		}
	}

	return r0, r1
}

// ListArtifactsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) ListArtifactsWithContext(_a0 context.Context, _a1 *sagemaker.ListArtifactsInput, _a2 ...request.Option) (*sagemaker.ListArtifactsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.ListArtifactsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.ListArtifactsInput, ...request.Option) *sagemaker.ListArtifactsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.ListArtifactsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.ListArtifactsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListAssociations provides a mock function with given fields: _a0
func (_m *SageMakerAPI) ListAssociations(_a0 *sagemaker.ListAssociationsInput) (*sagemaker.ListAssociationsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.ListAssociationsOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.ListAssociationsInput) *sagemaker.ListAssociationsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.ListAssociationsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.ListAssociationsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListAssociationsPages provides a mock function with given fields: _a0, _a1
func (_m *SageMakerAPI) ListAssociationsPages(_a0 *sagemaker.ListAssociationsInput, _a1 func(*sagemaker.ListAssociationsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*sagemaker.ListAssociationsInput, func(*sagemaker.ListAssociationsOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListAssociationsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *SageMakerAPI) ListAssociationsPagesWithContext(_a0 context.Context, _a1 *sagemaker.ListAssociationsInput, _a2 func(*sagemaker.ListAssociationsOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.ListAssociationsInput, func(*sagemaker.ListAssociationsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListAssociationsRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) ListAssociationsRequest(_a0 *sagemaker.ListAssociationsInput) (*request.Request, *sagemaker.ListAssociationsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.ListAssociationsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.ListAssociationsOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.ListAssociationsInput) *sagemaker.ListAssociationsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.ListAssociationsOutput)
		}
	}

	return r0, r1
}

// ListAssociationsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) ListAssociationsWithContext(_a0 context.Context, _a1 *sagemaker.ListAssociationsInput, _a2 ...request.Option) (*sagemaker.ListAssociationsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.ListAssociationsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.ListAssociationsInput, ...request.Option) *sagemaker.ListAssociationsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.ListAssociationsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.ListAssociationsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListAutoMLJobs provides a mock function with given fields: _a0
func (_m *SageMakerAPI) ListAutoMLJobs(_a0 *sagemaker.ListAutoMLJobsInput) (*sagemaker.ListAutoMLJobsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.ListAutoMLJobsOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.ListAutoMLJobsInput) *sagemaker.ListAutoMLJobsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.ListAutoMLJobsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.ListAutoMLJobsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListAutoMLJobsPages provides a mock function with given fields: _a0, _a1
func (_m *SageMakerAPI) ListAutoMLJobsPages(_a0 *sagemaker.ListAutoMLJobsInput, _a1 func(*sagemaker.ListAutoMLJobsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*sagemaker.ListAutoMLJobsInput, func(*sagemaker.ListAutoMLJobsOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListAutoMLJobsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *SageMakerAPI) ListAutoMLJobsPagesWithContext(_a0 context.Context, _a1 *sagemaker.ListAutoMLJobsInput, _a2 func(*sagemaker.ListAutoMLJobsOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.ListAutoMLJobsInput, func(*sagemaker.ListAutoMLJobsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListAutoMLJobsRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) ListAutoMLJobsRequest(_a0 *sagemaker.ListAutoMLJobsInput) (*request.Request, *sagemaker.ListAutoMLJobsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.ListAutoMLJobsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.ListAutoMLJobsOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.ListAutoMLJobsInput) *sagemaker.ListAutoMLJobsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.ListAutoMLJobsOutput)
		}
	}

	return r0, r1
}

// ListAutoMLJobsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) ListAutoMLJobsWithContext(_a0 context.Context, _a1 *sagemaker.ListAutoMLJobsInput, _a2 ...request.Option) (*sagemaker.ListAutoMLJobsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.ListAutoMLJobsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.ListAutoMLJobsInput, ...request.Option) *sagemaker.ListAutoMLJobsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.ListAutoMLJobsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.ListAutoMLJobsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListCandidatesForAutoMLJob provides a mock function with given fields: _a0
func (_m *SageMakerAPI) ListCandidatesForAutoMLJob(_a0 *sagemaker.ListCandidatesForAutoMLJobInput) (*sagemaker.ListCandidatesForAutoMLJobOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.ListCandidatesForAutoMLJobOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.ListCandidatesForAutoMLJobInput) *sagemaker.ListCandidatesForAutoMLJobOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.ListCandidatesForAutoMLJobOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.ListCandidatesForAutoMLJobInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListCandidatesForAutoMLJobPages provides a mock function with given fields: _a0, _a1
func (_m *SageMakerAPI) ListCandidatesForAutoMLJobPages(_a0 *sagemaker.ListCandidatesForAutoMLJobInput, _a1 func(*sagemaker.ListCandidatesForAutoMLJobOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*sagemaker.ListCandidatesForAutoMLJobInput, func(*sagemaker.ListCandidatesForAutoMLJobOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListCandidatesForAutoMLJobPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *SageMakerAPI) ListCandidatesForAutoMLJobPagesWithContext(_a0 context.Context, _a1 *sagemaker.ListCandidatesForAutoMLJobInput, _a2 func(*sagemaker.ListCandidatesForAutoMLJobOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.ListCandidatesForAutoMLJobInput, func(*sagemaker.ListCandidatesForAutoMLJobOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListCandidatesForAutoMLJobRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) ListCandidatesForAutoMLJobRequest(_a0 *sagemaker.ListCandidatesForAutoMLJobInput) (*request.Request, *sagemaker.ListCandidatesForAutoMLJobOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.ListCandidatesForAutoMLJobInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.ListCandidatesForAutoMLJobOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.ListCandidatesForAutoMLJobInput) *sagemaker.ListCandidatesForAutoMLJobOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.ListCandidatesForAutoMLJobOutput)
		}
	}

	return r0, r1
}

// ListCandidatesForAutoMLJobWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) ListCandidatesForAutoMLJobWithContext(_a0 context.Context, _a1 *sagemaker.ListCandidatesForAutoMLJobInput, _a2 ...request.Option) (*sagemaker.ListCandidatesForAutoMLJobOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.ListCandidatesForAutoMLJobOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.ListCandidatesForAutoMLJobInput, ...request.Option) *sagemaker.ListCandidatesForAutoMLJobOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.ListCandidatesForAutoMLJobOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.ListCandidatesForAutoMLJobInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListCodeRepositories provides a mock function with given fields: _a0
func (_m *SageMakerAPI) ListCodeRepositories(_a0 *sagemaker.ListCodeRepositoriesInput) (*sagemaker.ListCodeRepositoriesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.ListCodeRepositoriesOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.ListCodeRepositoriesInput) *sagemaker.ListCodeRepositoriesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.ListCodeRepositoriesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.ListCodeRepositoriesInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListCodeRepositoriesPages provides a mock function with given fields: _a0, _a1
func (_m *SageMakerAPI) ListCodeRepositoriesPages(_a0 *sagemaker.ListCodeRepositoriesInput, _a1 func(*sagemaker.ListCodeRepositoriesOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*sagemaker.ListCodeRepositoriesInput, func(*sagemaker.ListCodeRepositoriesOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListCodeRepositoriesPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *SageMakerAPI) ListCodeRepositoriesPagesWithContext(_a0 context.Context, _a1 *sagemaker.ListCodeRepositoriesInput, _a2 func(*sagemaker.ListCodeRepositoriesOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.ListCodeRepositoriesInput, func(*sagemaker.ListCodeRepositoriesOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListCodeRepositoriesRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) ListCodeRepositoriesRequest(_a0 *sagemaker.ListCodeRepositoriesInput) (*request.Request, *sagemaker.ListCodeRepositoriesOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.ListCodeRepositoriesInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.ListCodeRepositoriesOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.ListCodeRepositoriesInput) *sagemaker.ListCodeRepositoriesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.ListCodeRepositoriesOutput)
		}
	}

	return r0, r1
}

// ListCodeRepositoriesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) ListCodeRepositoriesWithContext(_a0 context.Context, _a1 *sagemaker.ListCodeRepositoriesInput, _a2 ...request.Option) (*sagemaker.ListCodeRepositoriesOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.ListCodeRepositoriesOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.ListCodeRepositoriesInput, ...request.Option) *sagemaker.ListCodeRepositoriesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.ListCodeRepositoriesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.ListCodeRepositoriesInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListCompilationJobs provides a mock function with given fields: _a0
func (_m *SageMakerAPI) ListCompilationJobs(_a0 *sagemaker.ListCompilationJobsInput) (*sagemaker.ListCompilationJobsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.ListCompilationJobsOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.ListCompilationJobsInput) *sagemaker.ListCompilationJobsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.ListCompilationJobsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.ListCompilationJobsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListCompilationJobsPages provides a mock function with given fields: _a0, _a1
func (_m *SageMakerAPI) ListCompilationJobsPages(_a0 *sagemaker.ListCompilationJobsInput, _a1 func(*sagemaker.ListCompilationJobsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*sagemaker.ListCompilationJobsInput, func(*sagemaker.ListCompilationJobsOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListCompilationJobsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *SageMakerAPI) ListCompilationJobsPagesWithContext(_a0 context.Context, _a1 *sagemaker.ListCompilationJobsInput, _a2 func(*sagemaker.ListCompilationJobsOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.ListCompilationJobsInput, func(*sagemaker.ListCompilationJobsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListCompilationJobsRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) ListCompilationJobsRequest(_a0 *sagemaker.ListCompilationJobsInput) (*request.Request, *sagemaker.ListCompilationJobsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.ListCompilationJobsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.ListCompilationJobsOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.ListCompilationJobsInput) *sagemaker.ListCompilationJobsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.ListCompilationJobsOutput)
		}
	}

	return r0, r1
}

// ListCompilationJobsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) ListCompilationJobsWithContext(_a0 context.Context, _a1 *sagemaker.ListCompilationJobsInput, _a2 ...request.Option) (*sagemaker.ListCompilationJobsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.ListCompilationJobsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.ListCompilationJobsInput, ...request.Option) *sagemaker.ListCompilationJobsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.ListCompilationJobsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.ListCompilationJobsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListContexts provides a mock function with given fields: _a0
func (_m *SageMakerAPI) ListContexts(_a0 *sagemaker.ListContextsInput) (*sagemaker.ListContextsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.ListContextsOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.ListContextsInput) *sagemaker.ListContextsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.ListContextsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.ListContextsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListContextsPages provides a mock function with given fields: _a0, _a1
func (_m *SageMakerAPI) ListContextsPages(_a0 *sagemaker.ListContextsInput, _a1 func(*sagemaker.ListContextsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*sagemaker.ListContextsInput, func(*sagemaker.ListContextsOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListContextsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *SageMakerAPI) ListContextsPagesWithContext(_a0 context.Context, _a1 *sagemaker.ListContextsInput, _a2 func(*sagemaker.ListContextsOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.ListContextsInput, func(*sagemaker.ListContextsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListContextsRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) ListContextsRequest(_a0 *sagemaker.ListContextsInput) (*request.Request, *sagemaker.ListContextsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.ListContextsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.ListContextsOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.ListContextsInput) *sagemaker.ListContextsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.ListContextsOutput)
		}
	}

	return r0, r1
}

// ListContextsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) ListContextsWithContext(_a0 context.Context, _a1 *sagemaker.ListContextsInput, _a2 ...request.Option) (*sagemaker.ListContextsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.ListContextsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.ListContextsInput, ...request.Option) *sagemaker.ListContextsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.ListContextsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.ListContextsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListDataQualityJobDefinitions provides a mock function with given fields: _a0
func (_m *SageMakerAPI) ListDataQualityJobDefinitions(_a0 *sagemaker.ListDataQualityJobDefinitionsInput) (*sagemaker.ListDataQualityJobDefinitionsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.ListDataQualityJobDefinitionsOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.ListDataQualityJobDefinitionsInput) *sagemaker.ListDataQualityJobDefinitionsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.ListDataQualityJobDefinitionsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.ListDataQualityJobDefinitionsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListDataQualityJobDefinitionsPages provides a mock function with given fields: _a0, _a1
func (_m *SageMakerAPI) ListDataQualityJobDefinitionsPages(_a0 *sagemaker.ListDataQualityJobDefinitionsInput, _a1 func(*sagemaker.ListDataQualityJobDefinitionsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*sagemaker.ListDataQualityJobDefinitionsInput, func(*sagemaker.ListDataQualityJobDefinitionsOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListDataQualityJobDefinitionsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *SageMakerAPI) ListDataQualityJobDefinitionsPagesWithContext(_a0 context.Context, _a1 *sagemaker.ListDataQualityJobDefinitionsInput, _a2 func(*sagemaker.ListDataQualityJobDefinitionsOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.ListDataQualityJobDefinitionsInput, func(*sagemaker.ListDataQualityJobDefinitionsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListDataQualityJobDefinitionsRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) ListDataQualityJobDefinitionsRequest(_a0 *sagemaker.ListDataQualityJobDefinitionsInput) (*request.Request, *sagemaker.ListDataQualityJobDefinitionsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.ListDataQualityJobDefinitionsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.ListDataQualityJobDefinitionsOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.ListDataQualityJobDefinitionsInput) *sagemaker.ListDataQualityJobDefinitionsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.ListDataQualityJobDefinitionsOutput)
		}
	}

	return r0, r1
}

// ListDataQualityJobDefinitionsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) ListDataQualityJobDefinitionsWithContext(_a0 context.Context, _a1 *sagemaker.ListDataQualityJobDefinitionsInput, _a2 ...request.Option) (*sagemaker.ListDataQualityJobDefinitionsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.ListDataQualityJobDefinitionsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.ListDataQualityJobDefinitionsInput, ...request.Option) *sagemaker.ListDataQualityJobDefinitionsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.ListDataQualityJobDefinitionsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.ListDataQualityJobDefinitionsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListDeviceFleets provides a mock function with given fields: _a0
func (_m *SageMakerAPI) ListDeviceFleets(_a0 *sagemaker.ListDeviceFleetsInput) (*sagemaker.ListDeviceFleetsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.ListDeviceFleetsOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.ListDeviceFleetsInput) *sagemaker.ListDeviceFleetsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.ListDeviceFleetsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.ListDeviceFleetsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListDeviceFleetsPages provides a mock function with given fields: _a0, _a1
func (_m *SageMakerAPI) ListDeviceFleetsPages(_a0 *sagemaker.ListDeviceFleetsInput, _a1 func(*sagemaker.ListDeviceFleetsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*sagemaker.ListDeviceFleetsInput, func(*sagemaker.ListDeviceFleetsOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListDeviceFleetsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *SageMakerAPI) ListDeviceFleetsPagesWithContext(_a0 context.Context, _a1 *sagemaker.ListDeviceFleetsInput, _a2 func(*sagemaker.ListDeviceFleetsOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.ListDeviceFleetsInput, func(*sagemaker.ListDeviceFleetsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListDeviceFleetsRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) ListDeviceFleetsRequest(_a0 *sagemaker.ListDeviceFleetsInput) (*request.Request, *sagemaker.ListDeviceFleetsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.ListDeviceFleetsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.ListDeviceFleetsOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.ListDeviceFleetsInput) *sagemaker.ListDeviceFleetsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.ListDeviceFleetsOutput)
		}
	}

	return r0, r1
}

// ListDeviceFleetsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) ListDeviceFleetsWithContext(_a0 context.Context, _a1 *sagemaker.ListDeviceFleetsInput, _a2 ...request.Option) (*sagemaker.ListDeviceFleetsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.ListDeviceFleetsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.ListDeviceFleetsInput, ...request.Option) *sagemaker.ListDeviceFleetsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.ListDeviceFleetsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.ListDeviceFleetsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListDevices provides a mock function with given fields: _a0
func (_m *SageMakerAPI) ListDevices(_a0 *sagemaker.ListDevicesInput) (*sagemaker.ListDevicesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.ListDevicesOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.ListDevicesInput) *sagemaker.ListDevicesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.ListDevicesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.ListDevicesInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListDevicesPages provides a mock function with given fields: _a0, _a1
func (_m *SageMakerAPI) ListDevicesPages(_a0 *sagemaker.ListDevicesInput, _a1 func(*sagemaker.ListDevicesOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*sagemaker.ListDevicesInput, func(*sagemaker.ListDevicesOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListDevicesPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *SageMakerAPI) ListDevicesPagesWithContext(_a0 context.Context, _a1 *sagemaker.ListDevicesInput, _a2 func(*sagemaker.ListDevicesOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.ListDevicesInput, func(*sagemaker.ListDevicesOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListDevicesRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) ListDevicesRequest(_a0 *sagemaker.ListDevicesInput) (*request.Request, *sagemaker.ListDevicesOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.ListDevicesInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.ListDevicesOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.ListDevicesInput) *sagemaker.ListDevicesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.ListDevicesOutput)
		}
	}

	return r0, r1
}

// ListDevicesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) ListDevicesWithContext(_a0 context.Context, _a1 *sagemaker.ListDevicesInput, _a2 ...request.Option) (*sagemaker.ListDevicesOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.ListDevicesOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.ListDevicesInput, ...request.Option) *sagemaker.ListDevicesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.ListDevicesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.ListDevicesInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListDomains provides a mock function with given fields: _a0
func (_m *SageMakerAPI) ListDomains(_a0 *sagemaker.ListDomainsInput) (*sagemaker.ListDomainsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.ListDomainsOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.ListDomainsInput) *sagemaker.ListDomainsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.ListDomainsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.ListDomainsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListDomainsPages provides a mock function with given fields: _a0, _a1
func (_m *SageMakerAPI) ListDomainsPages(_a0 *sagemaker.ListDomainsInput, _a1 func(*sagemaker.ListDomainsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*sagemaker.ListDomainsInput, func(*sagemaker.ListDomainsOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListDomainsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *SageMakerAPI) ListDomainsPagesWithContext(_a0 context.Context, _a1 *sagemaker.ListDomainsInput, _a2 func(*sagemaker.ListDomainsOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.ListDomainsInput, func(*sagemaker.ListDomainsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListDomainsRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) ListDomainsRequest(_a0 *sagemaker.ListDomainsInput) (*request.Request, *sagemaker.ListDomainsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.ListDomainsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.ListDomainsOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.ListDomainsInput) *sagemaker.ListDomainsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.ListDomainsOutput)
		}
	}

	return r0, r1
}

// ListDomainsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) ListDomainsWithContext(_a0 context.Context, _a1 *sagemaker.ListDomainsInput, _a2 ...request.Option) (*sagemaker.ListDomainsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.ListDomainsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.ListDomainsInput, ...request.Option) *sagemaker.ListDomainsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.ListDomainsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.ListDomainsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListEdgePackagingJobs provides a mock function with given fields: _a0
func (_m *SageMakerAPI) ListEdgePackagingJobs(_a0 *sagemaker.ListEdgePackagingJobsInput) (*sagemaker.ListEdgePackagingJobsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.ListEdgePackagingJobsOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.ListEdgePackagingJobsInput) *sagemaker.ListEdgePackagingJobsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.ListEdgePackagingJobsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.ListEdgePackagingJobsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListEdgePackagingJobsPages provides a mock function with given fields: _a0, _a1
func (_m *SageMakerAPI) ListEdgePackagingJobsPages(_a0 *sagemaker.ListEdgePackagingJobsInput, _a1 func(*sagemaker.ListEdgePackagingJobsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*sagemaker.ListEdgePackagingJobsInput, func(*sagemaker.ListEdgePackagingJobsOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListEdgePackagingJobsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *SageMakerAPI) ListEdgePackagingJobsPagesWithContext(_a0 context.Context, _a1 *sagemaker.ListEdgePackagingJobsInput, _a2 func(*sagemaker.ListEdgePackagingJobsOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.ListEdgePackagingJobsInput, func(*sagemaker.ListEdgePackagingJobsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListEdgePackagingJobsRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) ListEdgePackagingJobsRequest(_a0 *sagemaker.ListEdgePackagingJobsInput) (*request.Request, *sagemaker.ListEdgePackagingJobsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.ListEdgePackagingJobsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.ListEdgePackagingJobsOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.ListEdgePackagingJobsInput) *sagemaker.ListEdgePackagingJobsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.ListEdgePackagingJobsOutput)
		}
	}

	return r0, r1
}

// ListEdgePackagingJobsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) ListEdgePackagingJobsWithContext(_a0 context.Context, _a1 *sagemaker.ListEdgePackagingJobsInput, _a2 ...request.Option) (*sagemaker.ListEdgePackagingJobsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.ListEdgePackagingJobsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.ListEdgePackagingJobsInput, ...request.Option) *sagemaker.ListEdgePackagingJobsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.ListEdgePackagingJobsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.ListEdgePackagingJobsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListEndpointConfigs provides a mock function with given fields: _a0
func (_m *SageMakerAPI) ListEndpointConfigs(_a0 *sagemaker.ListEndpointConfigsInput) (*sagemaker.ListEndpointConfigsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.ListEndpointConfigsOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.ListEndpointConfigsInput) *sagemaker.ListEndpointConfigsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.ListEndpointConfigsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.ListEndpointConfigsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListEndpointConfigsPages provides a mock function with given fields: _a0, _a1
func (_m *SageMakerAPI) ListEndpointConfigsPages(_a0 *sagemaker.ListEndpointConfigsInput, _a1 func(*sagemaker.ListEndpointConfigsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*sagemaker.ListEndpointConfigsInput, func(*sagemaker.ListEndpointConfigsOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListEndpointConfigsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *SageMakerAPI) ListEndpointConfigsPagesWithContext(_a0 context.Context, _a1 *sagemaker.ListEndpointConfigsInput, _a2 func(*sagemaker.ListEndpointConfigsOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.ListEndpointConfigsInput, func(*sagemaker.ListEndpointConfigsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListEndpointConfigsRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) ListEndpointConfigsRequest(_a0 *sagemaker.ListEndpointConfigsInput) (*request.Request, *sagemaker.ListEndpointConfigsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.ListEndpointConfigsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.ListEndpointConfigsOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.ListEndpointConfigsInput) *sagemaker.ListEndpointConfigsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.ListEndpointConfigsOutput)
		}
	}

	return r0, r1
}

// ListEndpointConfigsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) ListEndpointConfigsWithContext(_a0 context.Context, _a1 *sagemaker.ListEndpointConfigsInput, _a2 ...request.Option) (*sagemaker.ListEndpointConfigsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.ListEndpointConfigsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.ListEndpointConfigsInput, ...request.Option) *sagemaker.ListEndpointConfigsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.ListEndpointConfigsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.ListEndpointConfigsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListEndpoints provides a mock function with given fields: _a0
func (_m *SageMakerAPI) ListEndpoints(_a0 *sagemaker.ListEndpointsInput) (*sagemaker.ListEndpointsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.ListEndpointsOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.ListEndpointsInput) *sagemaker.ListEndpointsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.ListEndpointsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.ListEndpointsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListEndpointsPages provides a mock function with given fields: _a0, _a1
func (_m *SageMakerAPI) ListEndpointsPages(_a0 *sagemaker.ListEndpointsInput, _a1 func(*sagemaker.ListEndpointsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*sagemaker.ListEndpointsInput, func(*sagemaker.ListEndpointsOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListEndpointsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *SageMakerAPI) ListEndpointsPagesWithContext(_a0 context.Context, _a1 *sagemaker.ListEndpointsInput, _a2 func(*sagemaker.ListEndpointsOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.ListEndpointsInput, func(*sagemaker.ListEndpointsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListEndpointsRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) ListEndpointsRequest(_a0 *sagemaker.ListEndpointsInput) (*request.Request, *sagemaker.ListEndpointsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.ListEndpointsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.ListEndpointsOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.ListEndpointsInput) *sagemaker.ListEndpointsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.ListEndpointsOutput)
		}
	}

	return r0, r1
}

// ListEndpointsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) ListEndpointsWithContext(_a0 context.Context, _a1 *sagemaker.ListEndpointsInput, _a2 ...request.Option) (*sagemaker.ListEndpointsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.ListEndpointsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.ListEndpointsInput, ...request.Option) *sagemaker.ListEndpointsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.ListEndpointsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.ListEndpointsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListExperiments provides a mock function with given fields: _a0
func (_m *SageMakerAPI) ListExperiments(_a0 *sagemaker.ListExperimentsInput) (*sagemaker.ListExperimentsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.ListExperimentsOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.ListExperimentsInput) *sagemaker.ListExperimentsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.ListExperimentsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.ListExperimentsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListExperimentsPages provides a mock function with given fields: _a0, _a1
func (_m *SageMakerAPI) ListExperimentsPages(_a0 *sagemaker.ListExperimentsInput, _a1 func(*sagemaker.ListExperimentsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*sagemaker.ListExperimentsInput, func(*sagemaker.ListExperimentsOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListExperimentsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *SageMakerAPI) ListExperimentsPagesWithContext(_a0 context.Context, _a1 *sagemaker.ListExperimentsInput, _a2 func(*sagemaker.ListExperimentsOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.ListExperimentsInput, func(*sagemaker.ListExperimentsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListExperimentsRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) ListExperimentsRequest(_a0 *sagemaker.ListExperimentsInput) (*request.Request, *sagemaker.ListExperimentsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.ListExperimentsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.ListExperimentsOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.ListExperimentsInput) *sagemaker.ListExperimentsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.ListExperimentsOutput)
		}
	}

	return r0, r1
}

// ListExperimentsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) ListExperimentsWithContext(_a0 context.Context, _a1 *sagemaker.ListExperimentsInput, _a2 ...request.Option) (*sagemaker.ListExperimentsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.ListExperimentsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.ListExperimentsInput, ...request.Option) *sagemaker.ListExperimentsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.ListExperimentsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.ListExperimentsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListFeatureGroups provides a mock function with given fields: _a0
func (_m *SageMakerAPI) ListFeatureGroups(_a0 *sagemaker.ListFeatureGroupsInput) (*sagemaker.ListFeatureGroupsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.ListFeatureGroupsOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.ListFeatureGroupsInput) *sagemaker.ListFeatureGroupsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.ListFeatureGroupsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.ListFeatureGroupsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListFeatureGroupsPages provides a mock function with given fields: _a0, _a1
func (_m *SageMakerAPI) ListFeatureGroupsPages(_a0 *sagemaker.ListFeatureGroupsInput, _a1 func(*sagemaker.ListFeatureGroupsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*sagemaker.ListFeatureGroupsInput, func(*sagemaker.ListFeatureGroupsOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListFeatureGroupsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *SageMakerAPI) ListFeatureGroupsPagesWithContext(_a0 context.Context, _a1 *sagemaker.ListFeatureGroupsInput, _a2 func(*sagemaker.ListFeatureGroupsOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.ListFeatureGroupsInput, func(*sagemaker.ListFeatureGroupsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListFeatureGroupsRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) ListFeatureGroupsRequest(_a0 *sagemaker.ListFeatureGroupsInput) (*request.Request, *sagemaker.ListFeatureGroupsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.ListFeatureGroupsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.ListFeatureGroupsOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.ListFeatureGroupsInput) *sagemaker.ListFeatureGroupsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.ListFeatureGroupsOutput)
		}
	}

	return r0, r1
}

// ListFeatureGroupsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) ListFeatureGroupsWithContext(_a0 context.Context, _a1 *sagemaker.ListFeatureGroupsInput, _a2 ...request.Option) (*sagemaker.ListFeatureGroupsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.ListFeatureGroupsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.ListFeatureGroupsInput, ...request.Option) *sagemaker.ListFeatureGroupsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.ListFeatureGroupsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.ListFeatureGroupsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListFlowDefinitions provides a mock function with given fields: _a0
func (_m *SageMakerAPI) ListFlowDefinitions(_a0 *sagemaker.ListFlowDefinitionsInput) (*sagemaker.ListFlowDefinitionsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.ListFlowDefinitionsOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.ListFlowDefinitionsInput) *sagemaker.ListFlowDefinitionsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.ListFlowDefinitionsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.ListFlowDefinitionsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListFlowDefinitionsPages provides a mock function with given fields: _a0, _a1
func (_m *SageMakerAPI) ListFlowDefinitionsPages(_a0 *sagemaker.ListFlowDefinitionsInput, _a1 func(*sagemaker.ListFlowDefinitionsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*sagemaker.ListFlowDefinitionsInput, func(*sagemaker.ListFlowDefinitionsOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListFlowDefinitionsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *SageMakerAPI) ListFlowDefinitionsPagesWithContext(_a0 context.Context, _a1 *sagemaker.ListFlowDefinitionsInput, _a2 func(*sagemaker.ListFlowDefinitionsOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.ListFlowDefinitionsInput, func(*sagemaker.ListFlowDefinitionsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListFlowDefinitionsRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) ListFlowDefinitionsRequest(_a0 *sagemaker.ListFlowDefinitionsInput) (*request.Request, *sagemaker.ListFlowDefinitionsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.ListFlowDefinitionsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.ListFlowDefinitionsOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.ListFlowDefinitionsInput) *sagemaker.ListFlowDefinitionsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.ListFlowDefinitionsOutput)
		}
	}

	return r0, r1
}

// ListFlowDefinitionsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) ListFlowDefinitionsWithContext(_a0 context.Context, _a1 *sagemaker.ListFlowDefinitionsInput, _a2 ...request.Option) (*sagemaker.ListFlowDefinitionsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.ListFlowDefinitionsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.ListFlowDefinitionsInput, ...request.Option) *sagemaker.ListFlowDefinitionsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.ListFlowDefinitionsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.ListFlowDefinitionsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListHumanTaskUis provides a mock function with given fields: _a0
func (_m *SageMakerAPI) ListHumanTaskUis(_a0 *sagemaker.ListHumanTaskUisInput) (*sagemaker.ListHumanTaskUisOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.ListHumanTaskUisOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.ListHumanTaskUisInput) *sagemaker.ListHumanTaskUisOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.ListHumanTaskUisOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.ListHumanTaskUisInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListHumanTaskUisPages provides a mock function with given fields: _a0, _a1
func (_m *SageMakerAPI) ListHumanTaskUisPages(_a0 *sagemaker.ListHumanTaskUisInput, _a1 func(*sagemaker.ListHumanTaskUisOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*sagemaker.ListHumanTaskUisInput, func(*sagemaker.ListHumanTaskUisOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListHumanTaskUisPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *SageMakerAPI) ListHumanTaskUisPagesWithContext(_a0 context.Context, _a1 *sagemaker.ListHumanTaskUisInput, _a2 func(*sagemaker.ListHumanTaskUisOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.ListHumanTaskUisInput, func(*sagemaker.ListHumanTaskUisOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListHumanTaskUisRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) ListHumanTaskUisRequest(_a0 *sagemaker.ListHumanTaskUisInput) (*request.Request, *sagemaker.ListHumanTaskUisOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.ListHumanTaskUisInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.ListHumanTaskUisOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.ListHumanTaskUisInput) *sagemaker.ListHumanTaskUisOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.ListHumanTaskUisOutput)
		}
	}

	return r0, r1
}

// ListHumanTaskUisWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) ListHumanTaskUisWithContext(_a0 context.Context, _a1 *sagemaker.ListHumanTaskUisInput, _a2 ...request.Option) (*sagemaker.ListHumanTaskUisOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.ListHumanTaskUisOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.ListHumanTaskUisInput, ...request.Option) *sagemaker.ListHumanTaskUisOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.ListHumanTaskUisOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.ListHumanTaskUisInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListHyperParameterTuningJobs provides a mock function with given fields: _a0
func (_m *SageMakerAPI) ListHyperParameterTuningJobs(_a0 *sagemaker.ListHyperParameterTuningJobsInput) (*sagemaker.ListHyperParameterTuningJobsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.ListHyperParameterTuningJobsOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.ListHyperParameterTuningJobsInput) *sagemaker.ListHyperParameterTuningJobsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.ListHyperParameterTuningJobsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.ListHyperParameterTuningJobsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListHyperParameterTuningJobsPages provides a mock function with given fields: _a0, _a1
func (_m *SageMakerAPI) ListHyperParameterTuningJobsPages(_a0 *sagemaker.ListHyperParameterTuningJobsInput, _a1 func(*sagemaker.ListHyperParameterTuningJobsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*sagemaker.ListHyperParameterTuningJobsInput, func(*sagemaker.ListHyperParameterTuningJobsOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListHyperParameterTuningJobsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *SageMakerAPI) ListHyperParameterTuningJobsPagesWithContext(_a0 context.Context, _a1 *sagemaker.ListHyperParameterTuningJobsInput, _a2 func(*sagemaker.ListHyperParameterTuningJobsOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.ListHyperParameterTuningJobsInput, func(*sagemaker.ListHyperParameterTuningJobsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListHyperParameterTuningJobsRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) ListHyperParameterTuningJobsRequest(_a0 *sagemaker.ListHyperParameterTuningJobsInput) (*request.Request, *sagemaker.ListHyperParameterTuningJobsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.ListHyperParameterTuningJobsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.ListHyperParameterTuningJobsOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.ListHyperParameterTuningJobsInput) *sagemaker.ListHyperParameterTuningJobsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.ListHyperParameterTuningJobsOutput)
		}
	}

	return r0, r1
}

// ListHyperParameterTuningJobsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) ListHyperParameterTuningJobsWithContext(_a0 context.Context, _a1 *sagemaker.ListHyperParameterTuningJobsInput, _a2 ...request.Option) (*sagemaker.ListHyperParameterTuningJobsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.ListHyperParameterTuningJobsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.ListHyperParameterTuningJobsInput, ...request.Option) *sagemaker.ListHyperParameterTuningJobsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.ListHyperParameterTuningJobsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.ListHyperParameterTuningJobsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListImageVersions provides a mock function with given fields: _a0
func (_m *SageMakerAPI) ListImageVersions(_a0 *sagemaker.ListImageVersionsInput) (*sagemaker.ListImageVersionsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.ListImageVersionsOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.ListImageVersionsInput) *sagemaker.ListImageVersionsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.ListImageVersionsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.ListImageVersionsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListImageVersionsPages provides a mock function with given fields: _a0, _a1
func (_m *SageMakerAPI) ListImageVersionsPages(_a0 *sagemaker.ListImageVersionsInput, _a1 func(*sagemaker.ListImageVersionsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*sagemaker.ListImageVersionsInput, func(*sagemaker.ListImageVersionsOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListImageVersionsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *SageMakerAPI) ListImageVersionsPagesWithContext(_a0 context.Context, _a1 *sagemaker.ListImageVersionsInput, _a2 func(*sagemaker.ListImageVersionsOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.ListImageVersionsInput, func(*sagemaker.ListImageVersionsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListImageVersionsRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) ListImageVersionsRequest(_a0 *sagemaker.ListImageVersionsInput) (*request.Request, *sagemaker.ListImageVersionsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.ListImageVersionsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.ListImageVersionsOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.ListImageVersionsInput) *sagemaker.ListImageVersionsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.ListImageVersionsOutput)
		}
	}

	return r0, r1
}

// ListImageVersionsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) ListImageVersionsWithContext(_a0 context.Context, _a1 *sagemaker.ListImageVersionsInput, _a2 ...request.Option) (*sagemaker.ListImageVersionsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.ListImageVersionsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.ListImageVersionsInput, ...request.Option) *sagemaker.ListImageVersionsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.ListImageVersionsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.ListImageVersionsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListImages provides a mock function with given fields: _a0
func (_m *SageMakerAPI) ListImages(_a0 *sagemaker.ListImagesInput) (*sagemaker.ListImagesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.ListImagesOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.ListImagesInput) *sagemaker.ListImagesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.ListImagesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.ListImagesInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListImagesPages provides a mock function with given fields: _a0, _a1
func (_m *SageMakerAPI) ListImagesPages(_a0 *sagemaker.ListImagesInput, _a1 func(*sagemaker.ListImagesOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*sagemaker.ListImagesInput, func(*sagemaker.ListImagesOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListImagesPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *SageMakerAPI) ListImagesPagesWithContext(_a0 context.Context, _a1 *sagemaker.ListImagesInput, _a2 func(*sagemaker.ListImagesOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.ListImagesInput, func(*sagemaker.ListImagesOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListImagesRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) ListImagesRequest(_a0 *sagemaker.ListImagesInput) (*request.Request, *sagemaker.ListImagesOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.ListImagesInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.ListImagesOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.ListImagesInput) *sagemaker.ListImagesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.ListImagesOutput)
		}
	}

	return r0, r1
}

// ListImagesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) ListImagesWithContext(_a0 context.Context, _a1 *sagemaker.ListImagesInput, _a2 ...request.Option) (*sagemaker.ListImagesOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.ListImagesOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.ListImagesInput, ...request.Option) *sagemaker.ListImagesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.ListImagesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.ListImagesInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListLabelingJobs provides a mock function with given fields: _a0
func (_m *SageMakerAPI) ListLabelingJobs(_a0 *sagemaker.ListLabelingJobsInput) (*sagemaker.ListLabelingJobsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.ListLabelingJobsOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.ListLabelingJobsInput) *sagemaker.ListLabelingJobsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.ListLabelingJobsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.ListLabelingJobsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListLabelingJobsForWorkteam provides a mock function with given fields: _a0
func (_m *SageMakerAPI) ListLabelingJobsForWorkteam(_a0 *sagemaker.ListLabelingJobsForWorkteamInput) (*sagemaker.ListLabelingJobsForWorkteamOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.ListLabelingJobsForWorkteamOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.ListLabelingJobsForWorkteamInput) *sagemaker.ListLabelingJobsForWorkteamOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.ListLabelingJobsForWorkteamOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.ListLabelingJobsForWorkteamInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListLabelingJobsForWorkteamPages provides a mock function with given fields: _a0, _a1
func (_m *SageMakerAPI) ListLabelingJobsForWorkteamPages(_a0 *sagemaker.ListLabelingJobsForWorkteamInput, _a1 func(*sagemaker.ListLabelingJobsForWorkteamOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*sagemaker.ListLabelingJobsForWorkteamInput, func(*sagemaker.ListLabelingJobsForWorkteamOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListLabelingJobsForWorkteamPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *SageMakerAPI) ListLabelingJobsForWorkteamPagesWithContext(_a0 context.Context, _a1 *sagemaker.ListLabelingJobsForWorkteamInput, _a2 func(*sagemaker.ListLabelingJobsForWorkteamOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.ListLabelingJobsForWorkteamInput, func(*sagemaker.ListLabelingJobsForWorkteamOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListLabelingJobsForWorkteamRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) ListLabelingJobsForWorkteamRequest(_a0 *sagemaker.ListLabelingJobsForWorkteamInput) (*request.Request, *sagemaker.ListLabelingJobsForWorkteamOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.ListLabelingJobsForWorkteamInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.ListLabelingJobsForWorkteamOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.ListLabelingJobsForWorkteamInput) *sagemaker.ListLabelingJobsForWorkteamOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.ListLabelingJobsForWorkteamOutput)
		}
	}

	return r0, r1
}

// ListLabelingJobsForWorkteamWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) ListLabelingJobsForWorkteamWithContext(_a0 context.Context, _a1 *sagemaker.ListLabelingJobsForWorkteamInput, _a2 ...request.Option) (*sagemaker.ListLabelingJobsForWorkteamOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.ListLabelingJobsForWorkteamOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.ListLabelingJobsForWorkteamInput, ...request.Option) *sagemaker.ListLabelingJobsForWorkteamOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.ListLabelingJobsForWorkteamOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.ListLabelingJobsForWorkteamInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListLabelingJobsPages provides a mock function with given fields: _a0, _a1
func (_m *SageMakerAPI) ListLabelingJobsPages(_a0 *sagemaker.ListLabelingJobsInput, _a1 func(*sagemaker.ListLabelingJobsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*sagemaker.ListLabelingJobsInput, func(*sagemaker.ListLabelingJobsOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListLabelingJobsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *SageMakerAPI) ListLabelingJobsPagesWithContext(_a0 context.Context, _a1 *sagemaker.ListLabelingJobsInput, _a2 func(*sagemaker.ListLabelingJobsOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.ListLabelingJobsInput, func(*sagemaker.ListLabelingJobsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListLabelingJobsRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) ListLabelingJobsRequest(_a0 *sagemaker.ListLabelingJobsInput) (*request.Request, *sagemaker.ListLabelingJobsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.ListLabelingJobsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.ListLabelingJobsOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.ListLabelingJobsInput) *sagemaker.ListLabelingJobsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.ListLabelingJobsOutput)
		}
	}

	return r0, r1
}

// ListLabelingJobsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) ListLabelingJobsWithContext(_a0 context.Context, _a1 *sagemaker.ListLabelingJobsInput, _a2 ...request.Option) (*sagemaker.ListLabelingJobsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.ListLabelingJobsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.ListLabelingJobsInput, ...request.Option) *sagemaker.ListLabelingJobsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.ListLabelingJobsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.ListLabelingJobsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListModelBiasJobDefinitions provides a mock function with given fields: _a0
func (_m *SageMakerAPI) ListModelBiasJobDefinitions(_a0 *sagemaker.ListModelBiasJobDefinitionsInput) (*sagemaker.ListModelBiasJobDefinitionsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.ListModelBiasJobDefinitionsOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.ListModelBiasJobDefinitionsInput) *sagemaker.ListModelBiasJobDefinitionsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.ListModelBiasJobDefinitionsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.ListModelBiasJobDefinitionsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListModelBiasJobDefinitionsPages provides a mock function with given fields: _a0, _a1
func (_m *SageMakerAPI) ListModelBiasJobDefinitionsPages(_a0 *sagemaker.ListModelBiasJobDefinitionsInput, _a1 func(*sagemaker.ListModelBiasJobDefinitionsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*sagemaker.ListModelBiasJobDefinitionsInput, func(*sagemaker.ListModelBiasJobDefinitionsOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListModelBiasJobDefinitionsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *SageMakerAPI) ListModelBiasJobDefinitionsPagesWithContext(_a0 context.Context, _a1 *sagemaker.ListModelBiasJobDefinitionsInput, _a2 func(*sagemaker.ListModelBiasJobDefinitionsOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.ListModelBiasJobDefinitionsInput, func(*sagemaker.ListModelBiasJobDefinitionsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListModelBiasJobDefinitionsRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) ListModelBiasJobDefinitionsRequest(_a0 *sagemaker.ListModelBiasJobDefinitionsInput) (*request.Request, *sagemaker.ListModelBiasJobDefinitionsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.ListModelBiasJobDefinitionsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.ListModelBiasJobDefinitionsOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.ListModelBiasJobDefinitionsInput) *sagemaker.ListModelBiasJobDefinitionsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.ListModelBiasJobDefinitionsOutput)
		}
	}

	return r0, r1
}

// ListModelBiasJobDefinitionsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) ListModelBiasJobDefinitionsWithContext(_a0 context.Context, _a1 *sagemaker.ListModelBiasJobDefinitionsInput, _a2 ...request.Option) (*sagemaker.ListModelBiasJobDefinitionsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.ListModelBiasJobDefinitionsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.ListModelBiasJobDefinitionsInput, ...request.Option) *sagemaker.ListModelBiasJobDefinitionsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.ListModelBiasJobDefinitionsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.ListModelBiasJobDefinitionsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListModelExplainabilityJobDefinitions provides a mock function with given fields: _a0
func (_m *SageMakerAPI) ListModelExplainabilityJobDefinitions(_a0 *sagemaker.ListModelExplainabilityJobDefinitionsInput) (*sagemaker.ListModelExplainabilityJobDefinitionsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.ListModelExplainabilityJobDefinitionsOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.ListModelExplainabilityJobDefinitionsInput) *sagemaker.ListModelExplainabilityJobDefinitionsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.ListModelExplainabilityJobDefinitionsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.ListModelExplainabilityJobDefinitionsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListModelExplainabilityJobDefinitionsPages provides a mock function with given fields: _a0, _a1
func (_m *SageMakerAPI) ListModelExplainabilityJobDefinitionsPages(_a0 *sagemaker.ListModelExplainabilityJobDefinitionsInput, _a1 func(*sagemaker.ListModelExplainabilityJobDefinitionsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*sagemaker.ListModelExplainabilityJobDefinitionsInput, func(*sagemaker.ListModelExplainabilityJobDefinitionsOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListModelExplainabilityJobDefinitionsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *SageMakerAPI) ListModelExplainabilityJobDefinitionsPagesWithContext(_a0 context.Context, _a1 *sagemaker.ListModelExplainabilityJobDefinitionsInput, _a2 func(*sagemaker.ListModelExplainabilityJobDefinitionsOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.ListModelExplainabilityJobDefinitionsInput, func(*sagemaker.ListModelExplainabilityJobDefinitionsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListModelExplainabilityJobDefinitionsRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) ListModelExplainabilityJobDefinitionsRequest(_a0 *sagemaker.ListModelExplainabilityJobDefinitionsInput) (*request.Request, *sagemaker.ListModelExplainabilityJobDefinitionsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.ListModelExplainabilityJobDefinitionsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.ListModelExplainabilityJobDefinitionsOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.ListModelExplainabilityJobDefinitionsInput) *sagemaker.ListModelExplainabilityJobDefinitionsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.ListModelExplainabilityJobDefinitionsOutput)
		}
	}

	return r0, r1
}

// ListModelExplainabilityJobDefinitionsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) ListModelExplainabilityJobDefinitionsWithContext(_a0 context.Context, _a1 *sagemaker.ListModelExplainabilityJobDefinitionsInput, _a2 ...request.Option) (*sagemaker.ListModelExplainabilityJobDefinitionsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.ListModelExplainabilityJobDefinitionsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.ListModelExplainabilityJobDefinitionsInput, ...request.Option) *sagemaker.ListModelExplainabilityJobDefinitionsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.ListModelExplainabilityJobDefinitionsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.ListModelExplainabilityJobDefinitionsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListModelPackageGroups provides a mock function with given fields: _a0
func (_m *SageMakerAPI) ListModelPackageGroups(_a0 *sagemaker.ListModelPackageGroupsInput) (*sagemaker.ListModelPackageGroupsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.ListModelPackageGroupsOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.ListModelPackageGroupsInput) *sagemaker.ListModelPackageGroupsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.ListModelPackageGroupsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.ListModelPackageGroupsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListModelPackageGroupsPages provides a mock function with given fields: _a0, _a1
func (_m *SageMakerAPI) ListModelPackageGroupsPages(_a0 *sagemaker.ListModelPackageGroupsInput, _a1 func(*sagemaker.ListModelPackageGroupsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*sagemaker.ListModelPackageGroupsInput, func(*sagemaker.ListModelPackageGroupsOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListModelPackageGroupsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *SageMakerAPI) ListModelPackageGroupsPagesWithContext(_a0 context.Context, _a1 *sagemaker.ListModelPackageGroupsInput, _a2 func(*sagemaker.ListModelPackageGroupsOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.ListModelPackageGroupsInput, func(*sagemaker.ListModelPackageGroupsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListModelPackageGroupsRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) ListModelPackageGroupsRequest(_a0 *sagemaker.ListModelPackageGroupsInput) (*request.Request, *sagemaker.ListModelPackageGroupsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.ListModelPackageGroupsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.ListModelPackageGroupsOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.ListModelPackageGroupsInput) *sagemaker.ListModelPackageGroupsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.ListModelPackageGroupsOutput)
		}
	}

	return r0, r1
}

// ListModelPackageGroupsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) ListModelPackageGroupsWithContext(_a0 context.Context, _a1 *sagemaker.ListModelPackageGroupsInput, _a2 ...request.Option) (*sagemaker.ListModelPackageGroupsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.ListModelPackageGroupsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.ListModelPackageGroupsInput, ...request.Option) *sagemaker.ListModelPackageGroupsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.ListModelPackageGroupsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.ListModelPackageGroupsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListModelPackages provides a mock function with given fields: _a0
func (_m *SageMakerAPI) ListModelPackages(_a0 *sagemaker.ListModelPackagesInput) (*sagemaker.ListModelPackagesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.ListModelPackagesOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.ListModelPackagesInput) *sagemaker.ListModelPackagesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.ListModelPackagesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.ListModelPackagesInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListModelPackagesPages provides a mock function with given fields: _a0, _a1
func (_m *SageMakerAPI) ListModelPackagesPages(_a0 *sagemaker.ListModelPackagesInput, _a1 func(*sagemaker.ListModelPackagesOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*sagemaker.ListModelPackagesInput, func(*sagemaker.ListModelPackagesOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListModelPackagesPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *SageMakerAPI) ListModelPackagesPagesWithContext(_a0 context.Context, _a1 *sagemaker.ListModelPackagesInput, _a2 func(*sagemaker.ListModelPackagesOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.ListModelPackagesInput, func(*sagemaker.ListModelPackagesOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListModelPackagesRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) ListModelPackagesRequest(_a0 *sagemaker.ListModelPackagesInput) (*request.Request, *sagemaker.ListModelPackagesOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.ListModelPackagesInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.ListModelPackagesOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.ListModelPackagesInput) *sagemaker.ListModelPackagesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.ListModelPackagesOutput)
		}
	}

	return r0, r1
}

// ListModelPackagesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) ListModelPackagesWithContext(_a0 context.Context, _a1 *sagemaker.ListModelPackagesInput, _a2 ...request.Option) (*sagemaker.ListModelPackagesOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.ListModelPackagesOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.ListModelPackagesInput, ...request.Option) *sagemaker.ListModelPackagesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.ListModelPackagesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.ListModelPackagesInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListModelQualityJobDefinitions provides a mock function with given fields: _a0
func (_m *SageMakerAPI) ListModelQualityJobDefinitions(_a0 *sagemaker.ListModelQualityJobDefinitionsInput) (*sagemaker.ListModelQualityJobDefinitionsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.ListModelQualityJobDefinitionsOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.ListModelQualityJobDefinitionsInput) *sagemaker.ListModelQualityJobDefinitionsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.ListModelQualityJobDefinitionsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.ListModelQualityJobDefinitionsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListModelQualityJobDefinitionsPages provides a mock function with given fields: _a0, _a1
func (_m *SageMakerAPI) ListModelQualityJobDefinitionsPages(_a0 *sagemaker.ListModelQualityJobDefinitionsInput, _a1 func(*sagemaker.ListModelQualityJobDefinitionsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*sagemaker.ListModelQualityJobDefinitionsInput, func(*sagemaker.ListModelQualityJobDefinitionsOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListModelQualityJobDefinitionsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *SageMakerAPI) ListModelQualityJobDefinitionsPagesWithContext(_a0 context.Context, _a1 *sagemaker.ListModelQualityJobDefinitionsInput, _a2 func(*sagemaker.ListModelQualityJobDefinitionsOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.ListModelQualityJobDefinitionsInput, func(*sagemaker.ListModelQualityJobDefinitionsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListModelQualityJobDefinitionsRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) ListModelQualityJobDefinitionsRequest(_a0 *sagemaker.ListModelQualityJobDefinitionsInput) (*request.Request, *sagemaker.ListModelQualityJobDefinitionsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.ListModelQualityJobDefinitionsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.ListModelQualityJobDefinitionsOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.ListModelQualityJobDefinitionsInput) *sagemaker.ListModelQualityJobDefinitionsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.ListModelQualityJobDefinitionsOutput)
		}
	}

	return r0, r1
}

// ListModelQualityJobDefinitionsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) ListModelQualityJobDefinitionsWithContext(_a0 context.Context, _a1 *sagemaker.ListModelQualityJobDefinitionsInput, _a2 ...request.Option) (*sagemaker.ListModelQualityJobDefinitionsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.ListModelQualityJobDefinitionsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.ListModelQualityJobDefinitionsInput, ...request.Option) *sagemaker.ListModelQualityJobDefinitionsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.ListModelQualityJobDefinitionsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.ListModelQualityJobDefinitionsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListModels provides a mock function with given fields: _a0
func (_m *SageMakerAPI) ListModels(_a0 *sagemaker.ListModelsInput) (*sagemaker.ListModelsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.ListModelsOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.ListModelsInput) *sagemaker.ListModelsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.ListModelsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.ListModelsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListModelsPages provides a mock function with given fields: _a0, _a1
func (_m *SageMakerAPI) ListModelsPages(_a0 *sagemaker.ListModelsInput, _a1 func(*sagemaker.ListModelsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*sagemaker.ListModelsInput, func(*sagemaker.ListModelsOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListModelsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *SageMakerAPI) ListModelsPagesWithContext(_a0 context.Context, _a1 *sagemaker.ListModelsInput, _a2 func(*sagemaker.ListModelsOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.ListModelsInput, func(*sagemaker.ListModelsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListModelsRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) ListModelsRequest(_a0 *sagemaker.ListModelsInput) (*request.Request, *sagemaker.ListModelsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.ListModelsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.ListModelsOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.ListModelsInput) *sagemaker.ListModelsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.ListModelsOutput)
		}
	}

	return r0, r1
}

// ListModelsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) ListModelsWithContext(_a0 context.Context, _a1 *sagemaker.ListModelsInput, _a2 ...request.Option) (*sagemaker.ListModelsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.ListModelsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.ListModelsInput, ...request.Option) *sagemaker.ListModelsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.ListModelsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.ListModelsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListMonitoringExecutions provides a mock function with given fields: _a0
func (_m *SageMakerAPI) ListMonitoringExecutions(_a0 *sagemaker.ListMonitoringExecutionsInput) (*sagemaker.ListMonitoringExecutionsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.ListMonitoringExecutionsOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.ListMonitoringExecutionsInput) *sagemaker.ListMonitoringExecutionsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.ListMonitoringExecutionsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.ListMonitoringExecutionsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListMonitoringExecutionsPages provides a mock function with given fields: _a0, _a1
func (_m *SageMakerAPI) ListMonitoringExecutionsPages(_a0 *sagemaker.ListMonitoringExecutionsInput, _a1 func(*sagemaker.ListMonitoringExecutionsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*sagemaker.ListMonitoringExecutionsInput, func(*sagemaker.ListMonitoringExecutionsOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListMonitoringExecutionsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *SageMakerAPI) ListMonitoringExecutionsPagesWithContext(_a0 context.Context, _a1 *sagemaker.ListMonitoringExecutionsInput, _a2 func(*sagemaker.ListMonitoringExecutionsOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.ListMonitoringExecutionsInput, func(*sagemaker.ListMonitoringExecutionsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListMonitoringExecutionsRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) ListMonitoringExecutionsRequest(_a0 *sagemaker.ListMonitoringExecutionsInput) (*request.Request, *sagemaker.ListMonitoringExecutionsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.ListMonitoringExecutionsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.ListMonitoringExecutionsOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.ListMonitoringExecutionsInput) *sagemaker.ListMonitoringExecutionsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.ListMonitoringExecutionsOutput)
		}
	}

	return r0, r1
}

// ListMonitoringExecutionsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) ListMonitoringExecutionsWithContext(_a0 context.Context, _a1 *sagemaker.ListMonitoringExecutionsInput, _a2 ...request.Option) (*sagemaker.ListMonitoringExecutionsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.ListMonitoringExecutionsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.ListMonitoringExecutionsInput, ...request.Option) *sagemaker.ListMonitoringExecutionsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.ListMonitoringExecutionsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.ListMonitoringExecutionsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListMonitoringSchedules provides a mock function with given fields: _a0
func (_m *SageMakerAPI) ListMonitoringSchedules(_a0 *sagemaker.ListMonitoringSchedulesInput) (*sagemaker.ListMonitoringSchedulesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.ListMonitoringSchedulesOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.ListMonitoringSchedulesInput) *sagemaker.ListMonitoringSchedulesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.ListMonitoringSchedulesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.ListMonitoringSchedulesInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListMonitoringSchedulesPages provides a mock function with given fields: _a0, _a1
func (_m *SageMakerAPI) ListMonitoringSchedulesPages(_a0 *sagemaker.ListMonitoringSchedulesInput, _a1 func(*sagemaker.ListMonitoringSchedulesOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*sagemaker.ListMonitoringSchedulesInput, func(*sagemaker.ListMonitoringSchedulesOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListMonitoringSchedulesPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *SageMakerAPI) ListMonitoringSchedulesPagesWithContext(_a0 context.Context, _a1 *sagemaker.ListMonitoringSchedulesInput, _a2 func(*sagemaker.ListMonitoringSchedulesOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.ListMonitoringSchedulesInput, func(*sagemaker.ListMonitoringSchedulesOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListMonitoringSchedulesRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) ListMonitoringSchedulesRequest(_a0 *sagemaker.ListMonitoringSchedulesInput) (*request.Request, *sagemaker.ListMonitoringSchedulesOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.ListMonitoringSchedulesInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.ListMonitoringSchedulesOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.ListMonitoringSchedulesInput) *sagemaker.ListMonitoringSchedulesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.ListMonitoringSchedulesOutput)
		}
	}

	return r0, r1
}

// ListMonitoringSchedulesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) ListMonitoringSchedulesWithContext(_a0 context.Context, _a1 *sagemaker.ListMonitoringSchedulesInput, _a2 ...request.Option) (*sagemaker.ListMonitoringSchedulesOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.ListMonitoringSchedulesOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.ListMonitoringSchedulesInput, ...request.Option) *sagemaker.ListMonitoringSchedulesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.ListMonitoringSchedulesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.ListMonitoringSchedulesInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListNotebookInstanceLifecycleConfigs provides a mock function with given fields: _a0
func (_m *SageMakerAPI) ListNotebookInstanceLifecycleConfigs(_a0 *sagemaker.ListNotebookInstanceLifecycleConfigsInput) (*sagemaker.ListNotebookInstanceLifecycleConfigsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.ListNotebookInstanceLifecycleConfigsOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.ListNotebookInstanceLifecycleConfigsInput) *sagemaker.ListNotebookInstanceLifecycleConfigsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.ListNotebookInstanceLifecycleConfigsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.ListNotebookInstanceLifecycleConfigsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListNotebookInstanceLifecycleConfigsPages provides a mock function with given fields: _a0, _a1
func (_m *SageMakerAPI) ListNotebookInstanceLifecycleConfigsPages(_a0 *sagemaker.ListNotebookInstanceLifecycleConfigsInput, _a1 func(*sagemaker.ListNotebookInstanceLifecycleConfigsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*sagemaker.ListNotebookInstanceLifecycleConfigsInput, func(*sagemaker.ListNotebookInstanceLifecycleConfigsOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListNotebookInstanceLifecycleConfigsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *SageMakerAPI) ListNotebookInstanceLifecycleConfigsPagesWithContext(_a0 context.Context, _a1 *sagemaker.ListNotebookInstanceLifecycleConfigsInput, _a2 func(*sagemaker.ListNotebookInstanceLifecycleConfigsOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.ListNotebookInstanceLifecycleConfigsInput, func(*sagemaker.ListNotebookInstanceLifecycleConfigsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListNotebookInstanceLifecycleConfigsRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) ListNotebookInstanceLifecycleConfigsRequest(_a0 *sagemaker.ListNotebookInstanceLifecycleConfigsInput) (*request.Request, *sagemaker.ListNotebookInstanceLifecycleConfigsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.ListNotebookInstanceLifecycleConfigsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.ListNotebookInstanceLifecycleConfigsOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.ListNotebookInstanceLifecycleConfigsInput) *sagemaker.ListNotebookInstanceLifecycleConfigsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.ListNotebookInstanceLifecycleConfigsOutput)
		}
	}

	return r0, r1
}

// ListNotebookInstanceLifecycleConfigsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) ListNotebookInstanceLifecycleConfigsWithContext(_a0 context.Context, _a1 *sagemaker.ListNotebookInstanceLifecycleConfigsInput, _a2 ...request.Option) (*sagemaker.ListNotebookInstanceLifecycleConfigsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.ListNotebookInstanceLifecycleConfigsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.ListNotebookInstanceLifecycleConfigsInput, ...request.Option) *sagemaker.ListNotebookInstanceLifecycleConfigsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.ListNotebookInstanceLifecycleConfigsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.ListNotebookInstanceLifecycleConfigsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListNotebookInstances provides a mock function with given fields: _a0
func (_m *SageMakerAPI) ListNotebookInstances(_a0 *sagemaker.ListNotebookInstancesInput) (*sagemaker.ListNotebookInstancesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.ListNotebookInstancesOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.ListNotebookInstancesInput) *sagemaker.ListNotebookInstancesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.ListNotebookInstancesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.ListNotebookInstancesInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListNotebookInstancesPages provides a mock function with given fields: _a0, _a1
func (_m *SageMakerAPI) ListNotebookInstancesPages(_a0 *sagemaker.ListNotebookInstancesInput, _a1 func(*sagemaker.ListNotebookInstancesOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*sagemaker.ListNotebookInstancesInput, func(*sagemaker.ListNotebookInstancesOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListNotebookInstancesPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *SageMakerAPI) ListNotebookInstancesPagesWithContext(_a0 context.Context, _a1 *sagemaker.ListNotebookInstancesInput, _a2 func(*sagemaker.ListNotebookInstancesOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.ListNotebookInstancesInput, func(*sagemaker.ListNotebookInstancesOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListNotebookInstancesRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) ListNotebookInstancesRequest(_a0 *sagemaker.ListNotebookInstancesInput) (*request.Request, *sagemaker.ListNotebookInstancesOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.ListNotebookInstancesInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.ListNotebookInstancesOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.ListNotebookInstancesInput) *sagemaker.ListNotebookInstancesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.ListNotebookInstancesOutput)
		}
	}

	return r0, r1
}

// ListNotebookInstancesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) ListNotebookInstancesWithContext(_a0 context.Context, _a1 *sagemaker.ListNotebookInstancesInput, _a2 ...request.Option) (*sagemaker.ListNotebookInstancesOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.ListNotebookInstancesOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.ListNotebookInstancesInput, ...request.Option) *sagemaker.ListNotebookInstancesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.ListNotebookInstancesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.ListNotebookInstancesInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListPipelineExecutionSteps provides a mock function with given fields: _a0
func (_m *SageMakerAPI) ListPipelineExecutionSteps(_a0 *sagemaker.ListPipelineExecutionStepsInput) (*sagemaker.ListPipelineExecutionStepsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.ListPipelineExecutionStepsOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.ListPipelineExecutionStepsInput) *sagemaker.ListPipelineExecutionStepsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.ListPipelineExecutionStepsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.ListPipelineExecutionStepsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListPipelineExecutionStepsPages provides a mock function with given fields: _a0, _a1
func (_m *SageMakerAPI) ListPipelineExecutionStepsPages(_a0 *sagemaker.ListPipelineExecutionStepsInput, _a1 func(*sagemaker.ListPipelineExecutionStepsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*sagemaker.ListPipelineExecutionStepsInput, func(*sagemaker.ListPipelineExecutionStepsOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListPipelineExecutionStepsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *SageMakerAPI) ListPipelineExecutionStepsPagesWithContext(_a0 context.Context, _a1 *sagemaker.ListPipelineExecutionStepsInput, _a2 func(*sagemaker.ListPipelineExecutionStepsOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.ListPipelineExecutionStepsInput, func(*sagemaker.ListPipelineExecutionStepsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListPipelineExecutionStepsRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) ListPipelineExecutionStepsRequest(_a0 *sagemaker.ListPipelineExecutionStepsInput) (*request.Request, *sagemaker.ListPipelineExecutionStepsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.ListPipelineExecutionStepsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.ListPipelineExecutionStepsOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.ListPipelineExecutionStepsInput) *sagemaker.ListPipelineExecutionStepsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.ListPipelineExecutionStepsOutput)
		}
	}

	return r0, r1
}

// ListPipelineExecutionStepsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) ListPipelineExecutionStepsWithContext(_a0 context.Context, _a1 *sagemaker.ListPipelineExecutionStepsInput, _a2 ...request.Option) (*sagemaker.ListPipelineExecutionStepsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.ListPipelineExecutionStepsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.ListPipelineExecutionStepsInput, ...request.Option) *sagemaker.ListPipelineExecutionStepsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.ListPipelineExecutionStepsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.ListPipelineExecutionStepsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListPipelineExecutions provides a mock function with given fields: _a0
func (_m *SageMakerAPI) ListPipelineExecutions(_a0 *sagemaker.ListPipelineExecutionsInput) (*sagemaker.ListPipelineExecutionsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.ListPipelineExecutionsOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.ListPipelineExecutionsInput) *sagemaker.ListPipelineExecutionsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.ListPipelineExecutionsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.ListPipelineExecutionsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListPipelineExecutionsPages provides a mock function with given fields: _a0, _a1
func (_m *SageMakerAPI) ListPipelineExecutionsPages(_a0 *sagemaker.ListPipelineExecutionsInput, _a1 func(*sagemaker.ListPipelineExecutionsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*sagemaker.ListPipelineExecutionsInput, func(*sagemaker.ListPipelineExecutionsOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListPipelineExecutionsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *SageMakerAPI) ListPipelineExecutionsPagesWithContext(_a0 context.Context, _a1 *sagemaker.ListPipelineExecutionsInput, _a2 func(*sagemaker.ListPipelineExecutionsOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.ListPipelineExecutionsInput, func(*sagemaker.ListPipelineExecutionsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListPipelineExecutionsRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) ListPipelineExecutionsRequest(_a0 *sagemaker.ListPipelineExecutionsInput) (*request.Request, *sagemaker.ListPipelineExecutionsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.ListPipelineExecutionsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.ListPipelineExecutionsOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.ListPipelineExecutionsInput) *sagemaker.ListPipelineExecutionsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.ListPipelineExecutionsOutput)
		}
	}

	return r0, r1
}

// ListPipelineExecutionsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) ListPipelineExecutionsWithContext(_a0 context.Context, _a1 *sagemaker.ListPipelineExecutionsInput, _a2 ...request.Option) (*sagemaker.ListPipelineExecutionsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.ListPipelineExecutionsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.ListPipelineExecutionsInput, ...request.Option) *sagemaker.ListPipelineExecutionsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.ListPipelineExecutionsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.ListPipelineExecutionsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListPipelineParametersForExecution provides a mock function with given fields: _a0
func (_m *SageMakerAPI) ListPipelineParametersForExecution(_a0 *sagemaker.ListPipelineParametersForExecutionInput) (*sagemaker.ListPipelineParametersForExecutionOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.ListPipelineParametersForExecutionOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.ListPipelineParametersForExecutionInput) *sagemaker.ListPipelineParametersForExecutionOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.ListPipelineParametersForExecutionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.ListPipelineParametersForExecutionInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListPipelineParametersForExecutionPages provides a mock function with given fields: _a0, _a1
func (_m *SageMakerAPI) ListPipelineParametersForExecutionPages(_a0 *sagemaker.ListPipelineParametersForExecutionInput, _a1 func(*sagemaker.ListPipelineParametersForExecutionOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*sagemaker.ListPipelineParametersForExecutionInput, func(*sagemaker.ListPipelineParametersForExecutionOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListPipelineParametersForExecutionPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *SageMakerAPI) ListPipelineParametersForExecutionPagesWithContext(_a0 context.Context, _a1 *sagemaker.ListPipelineParametersForExecutionInput, _a2 func(*sagemaker.ListPipelineParametersForExecutionOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.ListPipelineParametersForExecutionInput, func(*sagemaker.ListPipelineParametersForExecutionOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListPipelineParametersForExecutionRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) ListPipelineParametersForExecutionRequest(_a0 *sagemaker.ListPipelineParametersForExecutionInput) (*request.Request, *sagemaker.ListPipelineParametersForExecutionOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.ListPipelineParametersForExecutionInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.ListPipelineParametersForExecutionOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.ListPipelineParametersForExecutionInput) *sagemaker.ListPipelineParametersForExecutionOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.ListPipelineParametersForExecutionOutput)
		}
	}

	return r0, r1
}

// ListPipelineParametersForExecutionWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) ListPipelineParametersForExecutionWithContext(_a0 context.Context, _a1 *sagemaker.ListPipelineParametersForExecutionInput, _a2 ...request.Option) (*sagemaker.ListPipelineParametersForExecutionOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.ListPipelineParametersForExecutionOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.ListPipelineParametersForExecutionInput, ...request.Option) *sagemaker.ListPipelineParametersForExecutionOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.ListPipelineParametersForExecutionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.ListPipelineParametersForExecutionInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListPipelines provides a mock function with given fields: _a0
func (_m *SageMakerAPI) ListPipelines(_a0 *sagemaker.ListPipelinesInput) (*sagemaker.ListPipelinesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.ListPipelinesOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.ListPipelinesInput) *sagemaker.ListPipelinesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.ListPipelinesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.ListPipelinesInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListPipelinesPages provides a mock function with given fields: _a0, _a1
func (_m *SageMakerAPI) ListPipelinesPages(_a0 *sagemaker.ListPipelinesInput, _a1 func(*sagemaker.ListPipelinesOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*sagemaker.ListPipelinesInput, func(*sagemaker.ListPipelinesOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListPipelinesPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *SageMakerAPI) ListPipelinesPagesWithContext(_a0 context.Context, _a1 *sagemaker.ListPipelinesInput, _a2 func(*sagemaker.ListPipelinesOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.ListPipelinesInput, func(*sagemaker.ListPipelinesOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListPipelinesRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) ListPipelinesRequest(_a0 *sagemaker.ListPipelinesInput) (*request.Request, *sagemaker.ListPipelinesOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.ListPipelinesInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.ListPipelinesOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.ListPipelinesInput) *sagemaker.ListPipelinesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.ListPipelinesOutput)
		}
	}

	return r0, r1
}

// ListPipelinesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) ListPipelinesWithContext(_a0 context.Context, _a1 *sagemaker.ListPipelinesInput, _a2 ...request.Option) (*sagemaker.ListPipelinesOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.ListPipelinesOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.ListPipelinesInput, ...request.Option) *sagemaker.ListPipelinesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.ListPipelinesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.ListPipelinesInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListProcessingJobs provides a mock function with given fields: _a0
func (_m *SageMakerAPI) ListProcessingJobs(_a0 *sagemaker.ListProcessingJobsInput) (*sagemaker.ListProcessingJobsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.ListProcessingJobsOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.ListProcessingJobsInput) *sagemaker.ListProcessingJobsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.ListProcessingJobsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.ListProcessingJobsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListProcessingJobsPages provides a mock function with given fields: _a0, _a1
func (_m *SageMakerAPI) ListProcessingJobsPages(_a0 *sagemaker.ListProcessingJobsInput, _a1 func(*sagemaker.ListProcessingJobsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*sagemaker.ListProcessingJobsInput, func(*sagemaker.ListProcessingJobsOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListProcessingJobsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *SageMakerAPI) ListProcessingJobsPagesWithContext(_a0 context.Context, _a1 *sagemaker.ListProcessingJobsInput, _a2 func(*sagemaker.ListProcessingJobsOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.ListProcessingJobsInput, func(*sagemaker.ListProcessingJobsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListProcessingJobsRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) ListProcessingJobsRequest(_a0 *sagemaker.ListProcessingJobsInput) (*request.Request, *sagemaker.ListProcessingJobsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.ListProcessingJobsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.ListProcessingJobsOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.ListProcessingJobsInput) *sagemaker.ListProcessingJobsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.ListProcessingJobsOutput)
		}
	}

	return r0, r1
}

// ListProcessingJobsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) ListProcessingJobsWithContext(_a0 context.Context, _a1 *sagemaker.ListProcessingJobsInput, _a2 ...request.Option) (*sagemaker.ListProcessingJobsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.ListProcessingJobsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.ListProcessingJobsInput, ...request.Option) *sagemaker.ListProcessingJobsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.ListProcessingJobsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.ListProcessingJobsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListProjects provides a mock function with given fields: _a0
func (_m *SageMakerAPI) ListProjects(_a0 *sagemaker.ListProjectsInput) (*sagemaker.ListProjectsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.ListProjectsOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.ListProjectsInput) *sagemaker.ListProjectsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.ListProjectsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.ListProjectsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListProjectsPages provides a mock function with given fields: _a0, _a1
func (_m *SageMakerAPI) ListProjectsPages(_a0 *sagemaker.ListProjectsInput, _a1 func(*sagemaker.ListProjectsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*sagemaker.ListProjectsInput, func(*sagemaker.ListProjectsOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListProjectsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *SageMakerAPI) ListProjectsPagesWithContext(_a0 context.Context, _a1 *sagemaker.ListProjectsInput, _a2 func(*sagemaker.ListProjectsOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.ListProjectsInput, func(*sagemaker.ListProjectsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListProjectsRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) ListProjectsRequest(_a0 *sagemaker.ListProjectsInput) (*request.Request, *sagemaker.ListProjectsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.ListProjectsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.ListProjectsOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.ListProjectsInput) *sagemaker.ListProjectsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.ListProjectsOutput)
		}
	}

	return r0, r1
}

// ListProjectsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) ListProjectsWithContext(_a0 context.Context, _a1 *sagemaker.ListProjectsInput, _a2 ...request.Option) (*sagemaker.ListProjectsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.ListProjectsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.ListProjectsInput, ...request.Option) *sagemaker.ListProjectsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.ListProjectsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.ListProjectsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListSubscribedWorkteams provides a mock function with given fields: _a0
func (_m *SageMakerAPI) ListSubscribedWorkteams(_a0 *sagemaker.ListSubscribedWorkteamsInput) (*sagemaker.ListSubscribedWorkteamsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.ListSubscribedWorkteamsOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.ListSubscribedWorkteamsInput) *sagemaker.ListSubscribedWorkteamsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.ListSubscribedWorkteamsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.ListSubscribedWorkteamsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListSubscribedWorkteamsPages provides a mock function with given fields: _a0, _a1
func (_m *SageMakerAPI) ListSubscribedWorkteamsPages(_a0 *sagemaker.ListSubscribedWorkteamsInput, _a1 func(*sagemaker.ListSubscribedWorkteamsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*sagemaker.ListSubscribedWorkteamsInput, func(*sagemaker.ListSubscribedWorkteamsOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListSubscribedWorkteamsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *SageMakerAPI) ListSubscribedWorkteamsPagesWithContext(_a0 context.Context, _a1 *sagemaker.ListSubscribedWorkteamsInput, _a2 func(*sagemaker.ListSubscribedWorkteamsOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.ListSubscribedWorkteamsInput, func(*sagemaker.ListSubscribedWorkteamsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListSubscribedWorkteamsRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) ListSubscribedWorkteamsRequest(_a0 *sagemaker.ListSubscribedWorkteamsInput) (*request.Request, *sagemaker.ListSubscribedWorkteamsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.ListSubscribedWorkteamsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.ListSubscribedWorkteamsOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.ListSubscribedWorkteamsInput) *sagemaker.ListSubscribedWorkteamsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.ListSubscribedWorkteamsOutput)
		}
	}

	return r0, r1
}

// ListSubscribedWorkteamsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) ListSubscribedWorkteamsWithContext(_a0 context.Context, _a1 *sagemaker.ListSubscribedWorkteamsInput, _a2 ...request.Option) (*sagemaker.ListSubscribedWorkteamsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.ListSubscribedWorkteamsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.ListSubscribedWorkteamsInput, ...request.Option) *sagemaker.ListSubscribedWorkteamsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.ListSubscribedWorkteamsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.ListSubscribedWorkteamsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListTags provides a mock function with given fields: _a0
func (_m *SageMakerAPI) ListTags(_a0 *sagemaker.ListTagsInput) (*sagemaker.ListTagsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.ListTagsOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.ListTagsInput) *sagemaker.ListTagsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.ListTagsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.ListTagsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListTagsPages provides a mock function with given fields: _a0, _a1
func (_m *SageMakerAPI) ListTagsPages(_a0 *sagemaker.ListTagsInput, _a1 func(*sagemaker.ListTagsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*sagemaker.ListTagsInput, func(*sagemaker.ListTagsOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListTagsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *SageMakerAPI) ListTagsPagesWithContext(_a0 context.Context, _a1 *sagemaker.ListTagsInput, _a2 func(*sagemaker.ListTagsOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.ListTagsInput, func(*sagemaker.ListTagsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListTagsRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) ListTagsRequest(_a0 *sagemaker.ListTagsInput) (*request.Request, *sagemaker.ListTagsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.ListTagsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.ListTagsOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.ListTagsInput) *sagemaker.ListTagsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.ListTagsOutput)
		}
	}

	return r0, r1
}

// ListTagsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) ListTagsWithContext(_a0 context.Context, _a1 *sagemaker.ListTagsInput, _a2 ...request.Option) (*sagemaker.ListTagsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.ListTagsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.ListTagsInput, ...request.Option) *sagemaker.ListTagsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.ListTagsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.ListTagsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListTrainingJobs provides a mock function with given fields: _a0
func (_m *SageMakerAPI) ListTrainingJobs(_a0 *sagemaker.ListTrainingJobsInput) (*sagemaker.ListTrainingJobsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.ListTrainingJobsOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.ListTrainingJobsInput) *sagemaker.ListTrainingJobsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.ListTrainingJobsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.ListTrainingJobsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListTrainingJobsForHyperParameterTuningJob provides a mock function with given fields: _a0
func (_m *SageMakerAPI) ListTrainingJobsForHyperParameterTuningJob(_a0 *sagemaker.ListTrainingJobsForHyperParameterTuningJobInput) (*sagemaker.ListTrainingJobsForHyperParameterTuningJobOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.ListTrainingJobsForHyperParameterTuningJobOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.ListTrainingJobsForHyperParameterTuningJobInput) *sagemaker.ListTrainingJobsForHyperParameterTuningJobOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.ListTrainingJobsForHyperParameterTuningJobOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.ListTrainingJobsForHyperParameterTuningJobInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListTrainingJobsForHyperParameterTuningJobPages provides a mock function with given fields: _a0, _a1
func (_m *SageMakerAPI) ListTrainingJobsForHyperParameterTuningJobPages(_a0 *sagemaker.ListTrainingJobsForHyperParameterTuningJobInput, _a1 func(*sagemaker.ListTrainingJobsForHyperParameterTuningJobOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*sagemaker.ListTrainingJobsForHyperParameterTuningJobInput, func(*sagemaker.ListTrainingJobsForHyperParameterTuningJobOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListTrainingJobsForHyperParameterTuningJobPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *SageMakerAPI) ListTrainingJobsForHyperParameterTuningJobPagesWithContext(_a0 context.Context, _a1 *sagemaker.ListTrainingJobsForHyperParameterTuningJobInput, _a2 func(*sagemaker.ListTrainingJobsForHyperParameterTuningJobOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.ListTrainingJobsForHyperParameterTuningJobInput, func(*sagemaker.ListTrainingJobsForHyperParameterTuningJobOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListTrainingJobsForHyperParameterTuningJobRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) ListTrainingJobsForHyperParameterTuningJobRequest(_a0 *sagemaker.ListTrainingJobsForHyperParameterTuningJobInput) (*request.Request, *sagemaker.ListTrainingJobsForHyperParameterTuningJobOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.ListTrainingJobsForHyperParameterTuningJobInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.ListTrainingJobsForHyperParameterTuningJobOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.ListTrainingJobsForHyperParameterTuningJobInput) *sagemaker.ListTrainingJobsForHyperParameterTuningJobOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.ListTrainingJobsForHyperParameterTuningJobOutput)
		}
	}

	return r0, r1
}

// ListTrainingJobsForHyperParameterTuningJobWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) ListTrainingJobsForHyperParameterTuningJobWithContext(_a0 context.Context, _a1 *sagemaker.ListTrainingJobsForHyperParameterTuningJobInput, _a2 ...request.Option) (*sagemaker.ListTrainingJobsForHyperParameterTuningJobOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.ListTrainingJobsForHyperParameterTuningJobOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.ListTrainingJobsForHyperParameterTuningJobInput, ...request.Option) *sagemaker.ListTrainingJobsForHyperParameterTuningJobOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.ListTrainingJobsForHyperParameterTuningJobOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.ListTrainingJobsForHyperParameterTuningJobInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListTrainingJobsPages provides a mock function with given fields: _a0, _a1
func (_m *SageMakerAPI) ListTrainingJobsPages(_a0 *sagemaker.ListTrainingJobsInput, _a1 func(*sagemaker.ListTrainingJobsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*sagemaker.ListTrainingJobsInput, func(*sagemaker.ListTrainingJobsOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListTrainingJobsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *SageMakerAPI) ListTrainingJobsPagesWithContext(_a0 context.Context, _a1 *sagemaker.ListTrainingJobsInput, _a2 func(*sagemaker.ListTrainingJobsOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.ListTrainingJobsInput, func(*sagemaker.ListTrainingJobsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListTrainingJobsRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) ListTrainingJobsRequest(_a0 *sagemaker.ListTrainingJobsInput) (*request.Request, *sagemaker.ListTrainingJobsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.ListTrainingJobsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.ListTrainingJobsOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.ListTrainingJobsInput) *sagemaker.ListTrainingJobsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.ListTrainingJobsOutput)
		}
	}

	return r0, r1
}

// ListTrainingJobsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) ListTrainingJobsWithContext(_a0 context.Context, _a1 *sagemaker.ListTrainingJobsInput, _a2 ...request.Option) (*sagemaker.ListTrainingJobsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.ListTrainingJobsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.ListTrainingJobsInput, ...request.Option) *sagemaker.ListTrainingJobsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.ListTrainingJobsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.ListTrainingJobsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListTransformJobs provides a mock function with given fields: _a0
func (_m *SageMakerAPI) ListTransformJobs(_a0 *sagemaker.ListTransformJobsInput) (*sagemaker.ListTransformJobsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.ListTransformJobsOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.ListTransformJobsInput) *sagemaker.ListTransformJobsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.ListTransformJobsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.ListTransformJobsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListTransformJobsPages provides a mock function with given fields: _a0, _a1
func (_m *SageMakerAPI) ListTransformJobsPages(_a0 *sagemaker.ListTransformJobsInput, _a1 func(*sagemaker.ListTransformJobsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*sagemaker.ListTransformJobsInput, func(*sagemaker.ListTransformJobsOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListTransformJobsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *SageMakerAPI) ListTransformJobsPagesWithContext(_a0 context.Context, _a1 *sagemaker.ListTransformJobsInput, _a2 func(*sagemaker.ListTransformJobsOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.ListTransformJobsInput, func(*sagemaker.ListTransformJobsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListTransformJobsRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) ListTransformJobsRequest(_a0 *sagemaker.ListTransformJobsInput) (*request.Request, *sagemaker.ListTransformJobsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.ListTransformJobsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.ListTransformJobsOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.ListTransformJobsInput) *sagemaker.ListTransformJobsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.ListTransformJobsOutput)
		}
	}

	return r0, r1
}

// ListTransformJobsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) ListTransformJobsWithContext(_a0 context.Context, _a1 *sagemaker.ListTransformJobsInput, _a2 ...request.Option) (*sagemaker.ListTransformJobsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.ListTransformJobsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.ListTransformJobsInput, ...request.Option) *sagemaker.ListTransformJobsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.ListTransformJobsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.ListTransformJobsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListTrialComponents provides a mock function with given fields: _a0
func (_m *SageMakerAPI) ListTrialComponents(_a0 *sagemaker.ListTrialComponentsInput) (*sagemaker.ListTrialComponentsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.ListTrialComponentsOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.ListTrialComponentsInput) *sagemaker.ListTrialComponentsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.ListTrialComponentsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.ListTrialComponentsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListTrialComponentsPages provides a mock function with given fields: _a0, _a1
func (_m *SageMakerAPI) ListTrialComponentsPages(_a0 *sagemaker.ListTrialComponentsInput, _a1 func(*sagemaker.ListTrialComponentsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*sagemaker.ListTrialComponentsInput, func(*sagemaker.ListTrialComponentsOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListTrialComponentsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *SageMakerAPI) ListTrialComponentsPagesWithContext(_a0 context.Context, _a1 *sagemaker.ListTrialComponentsInput, _a2 func(*sagemaker.ListTrialComponentsOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.ListTrialComponentsInput, func(*sagemaker.ListTrialComponentsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListTrialComponentsRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) ListTrialComponentsRequest(_a0 *sagemaker.ListTrialComponentsInput) (*request.Request, *sagemaker.ListTrialComponentsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.ListTrialComponentsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.ListTrialComponentsOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.ListTrialComponentsInput) *sagemaker.ListTrialComponentsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.ListTrialComponentsOutput)
		}
	}

	return r0, r1
}

// ListTrialComponentsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) ListTrialComponentsWithContext(_a0 context.Context, _a1 *sagemaker.ListTrialComponentsInput, _a2 ...request.Option) (*sagemaker.ListTrialComponentsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.ListTrialComponentsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.ListTrialComponentsInput, ...request.Option) *sagemaker.ListTrialComponentsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.ListTrialComponentsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.ListTrialComponentsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListTrials provides a mock function with given fields: _a0
func (_m *SageMakerAPI) ListTrials(_a0 *sagemaker.ListTrialsInput) (*sagemaker.ListTrialsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.ListTrialsOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.ListTrialsInput) *sagemaker.ListTrialsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.ListTrialsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.ListTrialsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListTrialsPages provides a mock function with given fields: _a0, _a1
func (_m *SageMakerAPI) ListTrialsPages(_a0 *sagemaker.ListTrialsInput, _a1 func(*sagemaker.ListTrialsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*sagemaker.ListTrialsInput, func(*sagemaker.ListTrialsOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListTrialsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *SageMakerAPI) ListTrialsPagesWithContext(_a0 context.Context, _a1 *sagemaker.ListTrialsInput, _a2 func(*sagemaker.ListTrialsOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.ListTrialsInput, func(*sagemaker.ListTrialsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListTrialsRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) ListTrialsRequest(_a0 *sagemaker.ListTrialsInput) (*request.Request, *sagemaker.ListTrialsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.ListTrialsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.ListTrialsOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.ListTrialsInput) *sagemaker.ListTrialsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.ListTrialsOutput)
		}
	}

	return r0, r1
}

// ListTrialsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) ListTrialsWithContext(_a0 context.Context, _a1 *sagemaker.ListTrialsInput, _a2 ...request.Option) (*sagemaker.ListTrialsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.ListTrialsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.ListTrialsInput, ...request.Option) *sagemaker.ListTrialsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.ListTrialsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.ListTrialsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListUserProfiles provides a mock function with given fields: _a0
func (_m *SageMakerAPI) ListUserProfiles(_a0 *sagemaker.ListUserProfilesInput) (*sagemaker.ListUserProfilesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.ListUserProfilesOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.ListUserProfilesInput) *sagemaker.ListUserProfilesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.ListUserProfilesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.ListUserProfilesInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListUserProfilesPages provides a mock function with given fields: _a0, _a1
func (_m *SageMakerAPI) ListUserProfilesPages(_a0 *sagemaker.ListUserProfilesInput, _a1 func(*sagemaker.ListUserProfilesOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*sagemaker.ListUserProfilesInput, func(*sagemaker.ListUserProfilesOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListUserProfilesPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *SageMakerAPI) ListUserProfilesPagesWithContext(_a0 context.Context, _a1 *sagemaker.ListUserProfilesInput, _a2 func(*sagemaker.ListUserProfilesOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.ListUserProfilesInput, func(*sagemaker.ListUserProfilesOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListUserProfilesRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) ListUserProfilesRequest(_a0 *sagemaker.ListUserProfilesInput) (*request.Request, *sagemaker.ListUserProfilesOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.ListUserProfilesInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.ListUserProfilesOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.ListUserProfilesInput) *sagemaker.ListUserProfilesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.ListUserProfilesOutput)
		}
	}

	return r0, r1
}

// ListUserProfilesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) ListUserProfilesWithContext(_a0 context.Context, _a1 *sagemaker.ListUserProfilesInput, _a2 ...request.Option) (*sagemaker.ListUserProfilesOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.ListUserProfilesOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.ListUserProfilesInput, ...request.Option) *sagemaker.ListUserProfilesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.ListUserProfilesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.ListUserProfilesInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListWorkforces provides a mock function with given fields: _a0
func (_m *SageMakerAPI) ListWorkforces(_a0 *sagemaker.ListWorkforcesInput) (*sagemaker.ListWorkforcesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.ListWorkforcesOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.ListWorkforcesInput) *sagemaker.ListWorkforcesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.ListWorkforcesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.ListWorkforcesInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListWorkforcesPages provides a mock function with given fields: _a0, _a1
func (_m *SageMakerAPI) ListWorkforcesPages(_a0 *sagemaker.ListWorkforcesInput, _a1 func(*sagemaker.ListWorkforcesOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*sagemaker.ListWorkforcesInput, func(*sagemaker.ListWorkforcesOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListWorkforcesPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *SageMakerAPI) ListWorkforcesPagesWithContext(_a0 context.Context, _a1 *sagemaker.ListWorkforcesInput, _a2 func(*sagemaker.ListWorkforcesOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.ListWorkforcesInput, func(*sagemaker.ListWorkforcesOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListWorkforcesRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) ListWorkforcesRequest(_a0 *sagemaker.ListWorkforcesInput) (*request.Request, *sagemaker.ListWorkforcesOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.ListWorkforcesInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.ListWorkforcesOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.ListWorkforcesInput) *sagemaker.ListWorkforcesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.ListWorkforcesOutput)
		}
	}

	return r0, r1
}

// ListWorkforcesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) ListWorkforcesWithContext(_a0 context.Context, _a1 *sagemaker.ListWorkforcesInput, _a2 ...request.Option) (*sagemaker.ListWorkforcesOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.ListWorkforcesOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.ListWorkforcesInput, ...request.Option) *sagemaker.ListWorkforcesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.ListWorkforcesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.ListWorkforcesInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListWorkteams provides a mock function with given fields: _a0
func (_m *SageMakerAPI) ListWorkteams(_a0 *sagemaker.ListWorkteamsInput) (*sagemaker.ListWorkteamsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.ListWorkteamsOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.ListWorkteamsInput) *sagemaker.ListWorkteamsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.ListWorkteamsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.ListWorkteamsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListWorkteamsPages provides a mock function with given fields: _a0, _a1
func (_m *SageMakerAPI) ListWorkteamsPages(_a0 *sagemaker.ListWorkteamsInput, _a1 func(*sagemaker.ListWorkteamsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*sagemaker.ListWorkteamsInput, func(*sagemaker.ListWorkteamsOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListWorkteamsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *SageMakerAPI) ListWorkteamsPagesWithContext(_a0 context.Context, _a1 *sagemaker.ListWorkteamsInput, _a2 func(*sagemaker.ListWorkteamsOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.ListWorkteamsInput, func(*sagemaker.ListWorkteamsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListWorkteamsRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) ListWorkteamsRequest(_a0 *sagemaker.ListWorkteamsInput) (*request.Request, *sagemaker.ListWorkteamsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.ListWorkteamsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.ListWorkteamsOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.ListWorkteamsInput) *sagemaker.ListWorkteamsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.ListWorkteamsOutput)
		}
	}

	return r0, r1
}

// ListWorkteamsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) ListWorkteamsWithContext(_a0 context.Context, _a1 *sagemaker.ListWorkteamsInput, _a2 ...request.Option) (*sagemaker.ListWorkteamsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.ListWorkteamsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.ListWorkteamsInput, ...request.Option) *sagemaker.ListWorkteamsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.ListWorkteamsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.ListWorkteamsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// PutModelPackageGroupPolicy provides a mock function with given fields: _a0
func (_m *SageMakerAPI) PutModelPackageGroupPolicy(_a0 *sagemaker.PutModelPackageGroupPolicyInput) (*sagemaker.PutModelPackageGroupPolicyOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.PutModelPackageGroupPolicyOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.PutModelPackageGroupPolicyInput) *sagemaker.PutModelPackageGroupPolicyOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.PutModelPackageGroupPolicyOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.PutModelPackageGroupPolicyInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// PutModelPackageGroupPolicyRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) PutModelPackageGroupPolicyRequest(_a0 *sagemaker.PutModelPackageGroupPolicyInput) (*request.Request, *sagemaker.PutModelPackageGroupPolicyOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.PutModelPackageGroupPolicyInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.PutModelPackageGroupPolicyOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.PutModelPackageGroupPolicyInput) *sagemaker.PutModelPackageGroupPolicyOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.PutModelPackageGroupPolicyOutput)
		}
	}

	return r0, r1
}

// PutModelPackageGroupPolicyWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) PutModelPackageGroupPolicyWithContext(_a0 context.Context, _a1 *sagemaker.PutModelPackageGroupPolicyInput, _a2 ...request.Option) (*sagemaker.PutModelPackageGroupPolicyOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.PutModelPackageGroupPolicyOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.PutModelPackageGroupPolicyInput, ...request.Option) *sagemaker.PutModelPackageGroupPolicyOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.PutModelPackageGroupPolicyOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.PutModelPackageGroupPolicyInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// RegisterDevices provides a mock function with given fields: _a0
func (_m *SageMakerAPI) RegisterDevices(_a0 *sagemaker.RegisterDevicesInput) (*sagemaker.RegisterDevicesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.RegisterDevicesOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.RegisterDevicesInput) *sagemaker.RegisterDevicesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.RegisterDevicesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.RegisterDevicesInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// RegisterDevicesRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) RegisterDevicesRequest(_a0 *sagemaker.RegisterDevicesInput) (*request.Request, *sagemaker.RegisterDevicesOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.RegisterDevicesInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.RegisterDevicesOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.RegisterDevicesInput) *sagemaker.RegisterDevicesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.RegisterDevicesOutput)
		}
	}

	return r0, r1
}

// RegisterDevicesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) RegisterDevicesWithContext(_a0 context.Context, _a1 *sagemaker.RegisterDevicesInput, _a2 ...request.Option) (*sagemaker.RegisterDevicesOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.RegisterDevicesOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.RegisterDevicesInput, ...request.Option) *sagemaker.RegisterDevicesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.RegisterDevicesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.RegisterDevicesInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// RenderUiTemplate provides a mock function with given fields: _a0
func (_m *SageMakerAPI) RenderUiTemplate(_a0 *sagemaker.RenderUiTemplateInput) (*sagemaker.RenderUiTemplateOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.RenderUiTemplateOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.RenderUiTemplateInput) *sagemaker.RenderUiTemplateOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.RenderUiTemplateOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.RenderUiTemplateInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// RenderUiTemplateRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) RenderUiTemplateRequest(_a0 *sagemaker.RenderUiTemplateInput) (*request.Request, *sagemaker.RenderUiTemplateOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.RenderUiTemplateInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.RenderUiTemplateOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.RenderUiTemplateInput) *sagemaker.RenderUiTemplateOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.RenderUiTemplateOutput)
		}
	}

	return r0, r1
}

// RenderUiTemplateWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) RenderUiTemplateWithContext(_a0 context.Context, _a1 *sagemaker.RenderUiTemplateInput, _a2 ...request.Option) (*sagemaker.RenderUiTemplateOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.RenderUiTemplateOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.RenderUiTemplateInput, ...request.Option) *sagemaker.RenderUiTemplateOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.RenderUiTemplateOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.RenderUiTemplateInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// Search provides a mock function with given fields: _a0
func (_m *SageMakerAPI) Search(_a0 *sagemaker.SearchInput) (*sagemaker.SearchOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.SearchOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.SearchInput) *sagemaker.SearchOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.SearchOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.SearchInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// SearchPages provides a mock function with given fields: _a0, _a1
func (_m *SageMakerAPI) SearchPages(_a0 *sagemaker.SearchInput, _a1 func(*sagemaker.SearchOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*sagemaker.SearchInput, func(*sagemaker.SearchOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// SearchPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *SageMakerAPI) SearchPagesWithContext(_a0 context.Context, _a1 *sagemaker.SearchInput, _a2 func(*sagemaker.SearchOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.SearchInput, func(*sagemaker.SearchOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// SearchRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) SearchRequest(_a0 *sagemaker.SearchInput) (*request.Request, *sagemaker.SearchOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.SearchInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.SearchOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.SearchInput) *sagemaker.SearchOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.SearchOutput)
		}
	}

	return r0, r1
}

// SearchWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) SearchWithContext(_a0 context.Context, _a1 *sagemaker.SearchInput, _a2 ...request.Option) (*sagemaker.SearchOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.SearchOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.SearchInput, ...request.Option) *sagemaker.SearchOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.SearchOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.SearchInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// StartMonitoringSchedule provides a mock function with given fields: _a0
func (_m *SageMakerAPI) StartMonitoringSchedule(_a0 *sagemaker.StartMonitoringScheduleInput) (*sagemaker.StartMonitoringScheduleOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.StartMonitoringScheduleOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.StartMonitoringScheduleInput) *sagemaker.StartMonitoringScheduleOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.StartMonitoringScheduleOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.StartMonitoringScheduleInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// StartMonitoringScheduleRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) StartMonitoringScheduleRequest(_a0 *sagemaker.StartMonitoringScheduleInput) (*request.Request, *sagemaker.StartMonitoringScheduleOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.StartMonitoringScheduleInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.StartMonitoringScheduleOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.StartMonitoringScheduleInput) *sagemaker.StartMonitoringScheduleOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.StartMonitoringScheduleOutput)
		}
	}

	return r0, r1
}

// StartMonitoringScheduleWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) StartMonitoringScheduleWithContext(_a0 context.Context, _a1 *sagemaker.StartMonitoringScheduleInput, _a2 ...request.Option) (*sagemaker.StartMonitoringScheduleOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.StartMonitoringScheduleOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.StartMonitoringScheduleInput, ...request.Option) *sagemaker.StartMonitoringScheduleOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.StartMonitoringScheduleOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.StartMonitoringScheduleInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// StartNotebookInstance provides a mock function with given fields: _a0
func (_m *SageMakerAPI) StartNotebookInstance(_a0 *sagemaker.StartNotebookInstanceInput) (*sagemaker.StartNotebookInstanceOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.StartNotebookInstanceOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.StartNotebookInstanceInput) *sagemaker.StartNotebookInstanceOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.StartNotebookInstanceOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.StartNotebookInstanceInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// StartNotebookInstanceRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) StartNotebookInstanceRequest(_a0 *sagemaker.StartNotebookInstanceInput) (*request.Request, *sagemaker.StartNotebookInstanceOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.StartNotebookInstanceInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.StartNotebookInstanceOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.StartNotebookInstanceInput) *sagemaker.StartNotebookInstanceOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.StartNotebookInstanceOutput)
		}
	}

	return r0, r1
}

// StartNotebookInstanceWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) StartNotebookInstanceWithContext(_a0 context.Context, _a1 *sagemaker.StartNotebookInstanceInput, _a2 ...request.Option) (*sagemaker.StartNotebookInstanceOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.StartNotebookInstanceOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.StartNotebookInstanceInput, ...request.Option) *sagemaker.StartNotebookInstanceOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.StartNotebookInstanceOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.StartNotebookInstanceInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// StartPipelineExecution provides a mock function with given fields: _a0
func (_m *SageMakerAPI) StartPipelineExecution(_a0 *sagemaker.StartPipelineExecutionInput) (*sagemaker.StartPipelineExecutionOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.StartPipelineExecutionOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.StartPipelineExecutionInput) *sagemaker.StartPipelineExecutionOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.StartPipelineExecutionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.StartPipelineExecutionInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// StartPipelineExecutionRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) StartPipelineExecutionRequest(_a0 *sagemaker.StartPipelineExecutionInput) (*request.Request, *sagemaker.StartPipelineExecutionOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.StartPipelineExecutionInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.StartPipelineExecutionOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.StartPipelineExecutionInput) *sagemaker.StartPipelineExecutionOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.StartPipelineExecutionOutput)
		}
	}

	return r0, r1
}

// StartPipelineExecutionWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) StartPipelineExecutionWithContext(_a0 context.Context, _a1 *sagemaker.StartPipelineExecutionInput, _a2 ...request.Option) (*sagemaker.StartPipelineExecutionOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.StartPipelineExecutionOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.StartPipelineExecutionInput, ...request.Option) *sagemaker.StartPipelineExecutionOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.StartPipelineExecutionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.StartPipelineExecutionInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// StopAutoMLJob provides a mock function with given fields: _a0
func (_m *SageMakerAPI) StopAutoMLJob(_a0 *sagemaker.StopAutoMLJobInput) (*sagemaker.StopAutoMLJobOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.StopAutoMLJobOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.StopAutoMLJobInput) *sagemaker.StopAutoMLJobOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.StopAutoMLJobOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.StopAutoMLJobInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// StopAutoMLJobRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) StopAutoMLJobRequest(_a0 *sagemaker.StopAutoMLJobInput) (*request.Request, *sagemaker.StopAutoMLJobOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.StopAutoMLJobInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.StopAutoMLJobOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.StopAutoMLJobInput) *sagemaker.StopAutoMLJobOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.StopAutoMLJobOutput)
		}
	}

	return r0, r1
}

// StopAutoMLJobWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) StopAutoMLJobWithContext(_a0 context.Context, _a1 *sagemaker.StopAutoMLJobInput, _a2 ...request.Option) (*sagemaker.StopAutoMLJobOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.StopAutoMLJobOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.StopAutoMLJobInput, ...request.Option) *sagemaker.StopAutoMLJobOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.StopAutoMLJobOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.StopAutoMLJobInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// StopCompilationJob provides a mock function with given fields: _a0
func (_m *SageMakerAPI) StopCompilationJob(_a0 *sagemaker.StopCompilationJobInput) (*sagemaker.StopCompilationJobOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.StopCompilationJobOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.StopCompilationJobInput) *sagemaker.StopCompilationJobOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.StopCompilationJobOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.StopCompilationJobInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// StopCompilationJobRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) StopCompilationJobRequest(_a0 *sagemaker.StopCompilationJobInput) (*request.Request, *sagemaker.StopCompilationJobOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.StopCompilationJobInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.StopCompilationJobOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.StopCompilationJobInput) *sagemaker.StopCompilationJobOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.StopCompilationJobOutput)
		}
	}

	return r0, r1
}

// StopCompilationJobWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) StopCompilationJobWithContext(_a0 context.Context, _a1 *sagemaker.StopCompilationJobInput, _a2 ...request.Option) (*sagemaker.StopCompilationJobOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.StopCompilationJobOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.StopCompilationJobInput, ...request.Option) *sagemaker.StopCompilationJobOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.StopCompilationJobOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.StopCompilationJobInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// StopEdgePackagingJob provides a mock function with given fields: _a0
func (_m *SageMakerAPI) StopEdgePackagingJob(_a0 *sagemaker.StopEdgePackagingJobInput) (*sagemaker.StopEdgePackagingJobOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.StopEdgePackagingJobOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.StopEdgePackagingJobInput) *sagemaker.StopEdgePackagingJobOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.StopEdgePackagingJobOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.StopEdgePackagingJobInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// StopEdgePackagingJobRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) StopEdgePackagingJobRequest(_a0 *sagemaker.StopEdgePackagingJobInput) (*request.Request, *sagemaker.StopEdgePackagingJobOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.StopEdgePackagingJobInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.StopEdgePackagingJobOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.StopEdgePackagingJobInput) *sagemaker.StopEdgePackagingJobOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.StopEdgePackagingJobOutput)
		}
	}

	return r0, r1
}

// StopEdgePackagingJobWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) StopEdgePackagingJobWithContext(_a0 context.Context, _a1 *sagemaker.StopEdgePackagingJobInput, _a2 ...request.Option) (*sagemaker.StopEdgePackagingJobOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.StopEdgePackagingJobOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.StopEdgePackagingJobInput, ...request.Option) *sagemaker.StopEdgePackagingJobOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.StopEdgePackagingJobOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.StopEdgePackagingJobInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// StopHyperParameterTuningJob provides a mock function with given fields: _a0
func (_m *SageMakerAPI) StopHyperParameterTuningJob(_a0 *sagemaker.StopHyperParameterTuningJobInput) (*sagemaker.StopHyperParameterTuningJobOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.StopHyperParameterTuningJobOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.StopHyperParameterTuningJobInput) *sagemaker.StopHyperParameterTuningJobOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.StopHyperParameterTuningJobOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.StopHyperParameterTuningJobInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// StopHyperParameterTuningJobRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) StopHyperParameterTuningJobRequest(_a0 *sagemaker.StopHyperParameterTuningJobInput) (*request.Request, *sagemaker.StopHyperParameterTuningJobOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.StopHyperParameterTuningJobInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.StopHyperParameterTuningJobOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.StopHyperParameterTuningJobInput) *sagemaker.StopHyperParameterTuningJobOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.StopHyperParameterTuningJobOutput)
		}
	}

	return r0, r1
}

// StopHyperParameterTuningJobWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) StopHyperParameterTuningJobWithContext(_a0 context.Context, _a1 *sagemaker.StopHyperParameterTuningJobInput, _a2 ...request.Option) (*sagemaker.StopHyperParameterTuningJobOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.StopHyperParameterTuningJobOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.StopHyperParameterTuningJobInput, ...request.Option) *sagemaker.StopHyperParameterTuningJobOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.StopHyperParameterTuningJobOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.StopHyperParameterTuningJobInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// StopLabelingJob provides a mock function with given fields: _a0
func (_m *SageMakerAPI) StopLabelingJob(_a0 *sagemaker.StopLabelingJobInput) (*sagemaker.StopLabelingJobOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.StopLabelingJobOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.StopLabelingJobInput) *sagemaker.StopLabelingJobOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.StopLabelingJobOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.StopLabelingJobInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// StopLabelingJobRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) StopLabelingJobRequest(_a0 *sagemaker.StopLabelingJobInput) (*request.Request, *sagemaker.StopLabelingJobOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.StopLabelingJobInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.StopLabelingJobOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.StopLabelingJobInput) *sagemaker.StopLabelingJobOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.StopLabelingJobOutput)
		}
	}

	return r0, r1
}

// StopLabelingJobWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) StopLabelingJobWithContext(_a0 context.Context, _a1 *sagemaker.StopLabelingJobInput, _a2 ...request.Option) (*sagemaker.StopLabelingJobOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.StopLabelingJobOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.StopLabelingJobInput, ...request.Option) *sagemaker.StopLabelingJobOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.StopLabelingJobOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.StopLabelingJobInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// StopMonitoringSchedule provides a mock function with given fields: _a0
func (_m *SageMakerAPI) StopMonitoringSchedule(_a0 *sagemaker.StopMonitoringScheduleInput) (*sagemaker.StopMonitoringScheduleOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.StopMonitoringScheduleOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.StopMonitoringScheduleInput) *sagemaker.StopMonitoringScheduleOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.StopMonitoringScheduleOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.StopMonitoringScheduleInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// StopMonitoringScheduleRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) StopMonitoringScheduleRequest(_a0 *sagemaker.StopMonitoringScheduleInput) (*request.Request, *sagemaker.StopMonitoringScheduleOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.StopMonitoringScheduleInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.StopMonitoringScheduleOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.StopMonitoringScheduleInput) *sagemaker.StopMonitoringScheduleOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.StopMonitoringScheduleOutput)
		}
	}

	return r0, r1
}

// StopMonitoringScheduleWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) StopMonitoringScheduleWithContext(_a0 context.Context, _a1 *sagemaker.StopMonitoringScheduleInput, _a2 ...request.Option) (*sagemaker.StopMonitoringScheduleOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.StopMonitoringScheduleOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.StopMonitoringScheduleInput, ...request.Option) *sagemaker.StopMonitoringScheduleOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.StopMonitoringScheduleOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.StopMonitoringScheduleInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// StopNotebookInstance provides a mock function with given fields: _a0
func (_m *SageMakerAPI) StopNotebookInstance(_a0 *sagemaker.StopNotebookInstanceInput) (*sagemaker.StopNotebookInstanceOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.StopNotebookInstanceOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.StopNotebookInstanceInput) *sagemaker.StopNotebookInstanceOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.StopNotebookInstanceOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.StopNotebookInstanceInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// StopNotebookInstanceRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) StopNotebookInstanceRequest(_a0 *sagemaker.StopNotebookInstanceInput) (*request.Request, *sagemaker.StopNotebookInstanceOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.StopNotebookInstanceInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.StopNotebookInstanceOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.StopNotebookInstanceInput) *sagemaker.StopNotebookInstanceOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.StopNotebookInstanceOutput)
		}
	}

	return r0, r1
}

// StopNotebookInstanceWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) StopNotebookInstanceWithContext(_a0 context.Context, _a1 *sagemaker.StopNotebookInstanceInput, _a2 ...request.Option) (*sagemaker.StopNotebookInstanceOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.StopNotebookInstanceOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.StopNotebookInstanceInput, ...request.Option) *sagemaker.StopNotebookInstanceOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.StopNotebookInstanceOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.StopNotebookInstanceInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// StopPipelineExecution provides a mock function with given fields: _a0
func (_m *SageMakerAPI) StopPipelineExecution(_a0 *sagemaker.StopPipelineExecutionInput) (*sagemaker.StopPipelineExecutionOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.StopPipelineExecutionOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.StopPipelineExecutionInput) *sagemaker.StopPipelineExecutionOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.StopPipelineExecutionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.StopPipelineExecutionInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// StopPipelineExecutionRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) StopPipelineExecutionRequest(_a0 *sagemaker.StopPipelineExecutionInput) (*request.Request, *sagemaker.StopPipelineExecutionOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.StopPipelineExecutionInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.StopPipelineExecutionOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.StopPipelineExecutionInput) *sagemaker.StopPipelineExecutionOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.StopPipelineExecutionOutput)
		}
	}

	return r0, r1
}

// StopPipelineExecutionWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) StopPipelineExecutionWithContext(_a0 context.Context, _a1 *sagemaker.StopPipelineExecutionInput, _a2 ...request.Option) (*sagemaker.StopPipelineExecutionOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.StopPipelineExecutionOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.StopPipelineExecutionInput, ...request.Option) *sagemaker.StopPipelineExecutionOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.StopPipelineExecutionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.StopPipelineExecutionInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// StopProcessingJob provides a mock function with given fields: _a0
func (_m *SageMakerAPI) StopProcessingJob(_a0 *sagemaker.StopProcessingJobInput) (*sagemaker.StopProcessingJobOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.StopProcessingJobOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.StopProcessingJobInput) *sagemaker.StopProcessingJobOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.StopProcessingJobOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.StopProcessingJobInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// StopProcessingJobRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) StopProcessingJobRequest(_a0 *sagemaker.StopProcessingJobInput) (*request.Request, *sagemaker.StopProcessingJobOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.StopProcessingJobInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.StopProcessingJobOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.StopProcessingJobInput) *sagemaker.StopProcessingJobOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.StopProcessingJobOutput)
		}
	}

	return r0, r1
}

// StopProcessingJobWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) StopProcessingJobWithContext(_a0 context.Context, _a1 *sagemaker.StopProcessingJobInput, _a2 ...request.Option) (*sagemaker.StopProcessingJobOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.StopProcessingJobOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.StopProcessingJobInput, ...request.Option) *sagemaker.StopProcessingJobOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.StopProcessingJobOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.StopProcessingJobInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// StopTrainingJob provides a mock function with given fields: _a0
func (_m *SageMakerAPI) StopTrainingJob(_a0 *sagemaker.StopTrainingJobInput) (*sagemaker.StopTrainingJobOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.StopTrainingJobOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.StopTrainingJobInput) *sagemaker.StopTrainingJobOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.StopTrainingJobOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.StopTrainingJobInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// StopTrainingJobRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) StopTrainingJobRequest(_a0 *sagemaker.StopTrainingJobInput) (*request.Request, *sagemaker.StopTrainingJobOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.StopTrainingJobInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.StopTrainingJobOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.StopTrainingJobInput) *sagemaker.StopTrainingJobOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.StopTrainingJobOutput)
		}
	}

	return r0, r1
}

// StopTrainingJobWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) StopTrainingJobWithContext(_a0 context.Context, _a1 *sagemaker.StopTrainingJobInput, _a2 ...request.Option) (*sagemaker.StopTrainingJobOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.StopTrainingJobOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.StopTrainingJobInput, ...request.Option) *sagemaker.StopTrainingJobOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.StopTrainingJobOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.StopTrainingJobInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// StopTransformJob provides a mock function with given fields: _a0
func (_m *SageMakerAPI) StopTransformJob(_a0 *sagemaker.StopTransformJobInput) (*sagemaker.StopTransformJobOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.StopTransformJobOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.StopTransformJobInput) *sagemaker.StopTransformJobOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.StopTransformJobOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.StopTransformJobInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// StopTransformJobRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) StopTransformJobRequest(_a0 *sagemaker.StopTransformJobInput) (*request.Request, *sagemaker.StopTransformJobOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.StopTransformJobInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.StopTransformJobOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.StopTransformJobInput) *sagemaker.StopTransformJobOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.StopTransformJobOutput)
		}
	}

	return r0, r1
}

// StopTransformJobWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) StopTransformJobWithContext(_a0 context.Context, _a1 *sagemaker.StopTransformJobInput, _a2 ...request.Option) (*sagemaker.StopTransformJobOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.StopTransformJobOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.StopTransformJobInput, ...request.Option) *sagemaker.StopTransformJobOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.StopTransformJobOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.StopTransformJobInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateAction provides a mock function with given fields: _a0
func (_m *SageMakerAPI) UpdateAction(_a0 *sagemaker.UpdateActionInput) (*sagemaker.UpdateActionOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.UpdateActionOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.UpdateActionInput) *sagemaker.UpdateActionOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.UpdateActionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.UpdateActionInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateActionRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) UpdateActionRequest(_a0 *sagemaker.UpdateActionInput) (*request.Request, *sagemaker.UpdateActionOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.UpdateActionInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.UpdateActionOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.UpdateActionInput) *sagemaker.UpdateActionOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.UpdateActionOutput)
		}
	}

	return r0, r1
}

// UpdateActionWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) UpdateActionWithContext(_a0 context.Context, _a1 *sagemaker.UpdateActionInput, _a2 ...request.Option) (*sagemaker.UpdateActionOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.UpdateActionOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.UpdateActionInput, ...request.Option) *sagemaker.UpdateActionOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.UpdateActionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.UpdateActionInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateAppImageConfig provides a mock function with given fields: _a0
func (_m *SageMakerAPI) UpdateAppImageConfig(_a0 *sagemaker.UpdateAppImageConfigInput) (*sagemaker.UpdateAppImageConfigOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.UpdateAppImageConfigOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.UpdateAppImageConfigInput) *sagemaker.UpdateAppImageConfigOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.UpdateAppImageConfigOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.UpdateAppImageConfigInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateAppImageConfigRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) UpdateAppImageConfigRequest(_a0 *sagemaker.UpdateAppImageConfigInput) (*request.Request, *sagemaker.UpdateAppImageConfigOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.UpdateAppImageConfigInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.UpdateAppImageConfigOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.UpdateAppImageConfigInput) *sagemaker.UpdateAppImageConfigOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.UpdateAppImageConfigOutput)
		}
	}

	return r0, r1
}

// UpdateAppImageConfigWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) UpdateAppImageConfigWithContext(_a0 context.Context, _a1 *sagemaker.UpdateAppImageConfigInput, _a2 ...request.Option) (*sagemaker.UpdateAppImageConfigOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.UpdateAppImageConfigOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.UpdateAppImageConfigInput, ...request.Option) *sagemaker.UpdateAppImageConfigOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.UpdateAppImageConfigOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.UpdateAppImageConfigInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateArtifact provides a mock function with given fields: _a0
func (_m *SageMakerAPI) UpdateArtifact(_a0 *sagemaker.UpdateArtifactInput) (*sagemaker.UpdateArtifactOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.UpdateArtifactOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.UpdateArtifactInput) *sagemaker.UpdateArtifactOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.UpdateArtifactOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.UpdateArtifactInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateArtifactRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) UpdateArtifactRequest(_a0 *sagemaker.UpdateArtifactInput) (*request.Request, *sagemaker.UpdateArtifactOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.UpdateArtifactInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.UpdateArtifactOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.UpdateArtifactInput) *sagemaker.UpdateArtifactOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.UpdateArtifactOutput)
		}
	}

	return r0, r1
}

// UpdateArtifactWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) UpdateArtifactWithContext(_a0 context.Context, _a1 *sagemaker.UpdateArtifactInput, _a2 ...request.Option) (*sagemaker.UpdateArtifactOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.UpdateArtifactOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.UpdateArtifactInput, ...request.Option) *sagemaker.UpdateArtifactOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.UpdateArtifactOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.UpdateArtifactInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateCodeRepository provides a mock function with given fields: _a0
func (_m *SageMakerAPI) UpdateCodeRepository(_a0 *sagemaker.UpdateCodeRepositoryInput) (*sagemaker.UpdateCodeRepositoryOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.UpdateCodeRepositoryOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.UpdateCodeRepositoryInput) *sagemaker.UpdateCodeRepositoryOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.UpdateCodeRepositoryOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.UpdateCodeRepositoryInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateCodeRepositoryRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) UpdateCodeRepositoryRequest(_a0 *sagemaker.UpdateCodeRepositoryInput) (*request.Request, *sagemaker.UpdateCodeRepositoryOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.UpdateCodeRepositoryInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.UpdateCodeRepositoryOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.UpdateCodeRepositoryInput) *sagemaker.UpdateCodeRepositoryOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.UpdateCodeRepositoryOutput)
		}
	}

	return r0, r1
}

// UpdateCodeRepositoryWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) UpdateCodeRepositoryWithContext(_a0 context.Context, _a1 *sagemaker.UpdateCodeRepositoryInput, _a2 ...request.Option) (*sagemaker.UpdateCodeRepositoryOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.UpdateCodeRepositoryOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.UpdateCodeRepositoryInput, ...request.Option) *sagemaker.UpdateCodeRepositoryOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.UpdateCodeRepositoryOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.UpdateCodeRepositoryInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateContext provides a mock function with given fields: _a0
func (_m *SageMakerAPI) UpdateContext(_a0 *sagemaker.UpdateContextInput) (*sagemaker.UpdateContextOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.UpdateContextOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.UpdateContextInput) *sagemaker.UpdateContextOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.UpdateContextOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.UpdateContextInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateContextRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) UpdateContextRequest(_a0 *sagemaker.UpdateContextInput) (*request.Request, *sagemaker.UpdateContextOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.UpdateContextInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.UpdateContextOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.UpdateContextInput) *sagemaker.UpdateContextOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.UpdateContextOutput)
		}
	}

	return r0, r1
}

// UpdateContextWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) UpdateContextWithContext(_a0 context.Context, _a1 *sagemaker.UpdateContextInput, _a2 ...request.Option) (*sagemaker.UpdateContextOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.UpdateContextOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.UpdateContextInput, ...request.Option) *sagemaker.UpdateContextOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.UpdateContextOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.UpdateContextInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateDeviceFleet provides a mock function with given fields: _a0
func (_m *SageMakerAPI) UpdateDeviceFleet(_a0 *sagemaker.UpdateDeviceFleetInput) (*sagemaker.UpdateDeviceFleetOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.UpdateDeviceFleetOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.UpdateDeviceFleetInput) *sagemaker.UpdateDeviceFleetOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.UpdateDeviceFleetOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.UpdateDeviceFleetInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateDeviceFleetRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) UpdateDeviceFleetRequest(_a0 *sagemaker.UpdateDeviceFleetInput) (*request.Request, *sagemaker.UpdateDeviceFleetOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.UpdateDeviceFleetInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.UpdateDeviceFleetOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.UpdateDeviceFleetInput) *sagemaker.UpdateDeviceFleetOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.UpdateDeviceFleetOutput)
		}
	}

	return r0, r1
}

// UpdateDeviceFleetWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) UpdateDeviceFleetWithContext(_a0 context.Context, _a1 *sagemaker.UpdateDeviceFleetInput, _a2 ...request.Option) (*sagemaker.UpdateDeviceFleetOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.UpdateDeviceFleetOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.UpdateDeviceFleetInput, ...request.Option) *sagemaker.UpdateDeviceFleetOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.UpdateDeviceFleetOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.UpdateDeviceFleetInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateDevices provides a mock function with given fields: _a0
func (_m *SageMakerAPI) UpdateDevices(_a0 *sagemaker.UpdateDevicesInput) (*sagemaker.UpdateDevicesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.UpdateDevicesOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.UpdateDevicesInput) *sagemaker.UpdateDevicesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.UpdateDevicesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.UpdateDevicesInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateDevicesRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) UpdateDevicesRequest(_a0 *sagemaker.UpdateDevicesInput) (*request.Request, *sagemaker.UpdateDevicesOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.UpdateDevicesInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.UpdateDevicesOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.UpdateDevicesInput) *sagemaker.UpdateDevicesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.UpdateDevicesOutput)
		}
	}

	return r0, r1
}

// UpdateDevicesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) UpdateDevicesWithContext(_a0 context.Context, _a1 *sagemaker.UpdateDevicesInput, _a2 ...request.Option) (*sagemaker.UpdateDevicesOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.UpdateDevicesOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.UpdateDevicesInput, ...request.Option) *sagemaker.UpdateDevicesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.UpdateDevicesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.UpdateDevicesInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateDomain provides a mock function with given fields: _a0
func (_m *SageMakerAPI) UpdateDomain(_a0 *sagemaker.UpdateDomainInput) (*sagemaker.UpdateDomainOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.UpdateDomainOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.UpdateDomainInput) *sagemaker.UpdateDomainOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.UpdateDomainOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.UpdateDomainInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateDomainRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) UpdateDomainRequest(_a0 *sagemaker.UpdateDomainInput) (*request.Request, *sagemaker.UpdateDomainOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.UpdateDomainInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.UpdateDomainOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.UpdateDomainInput) *sagemaker.UpdateDomainOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.UpdateDomainOutput)
		}
	}

	return r0, r1
}

// UpdateDomainWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) UpdateDomainWithContext(_a0 context.Context, _a1 *sagemaker.UpdateDomainInput, _a2 ...request.Option) (*sagemaker.UpdateDomainOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.UpdateDomainOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.UpdateDomainInput, ...request.Option) *sagemaker.UpdateDomainOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.UpdateDomainOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.UpdateDomainInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateEndpoint provides a mock function with given fields: _a0
func (_m *SageMakerAPI) UpdateEndpoint(_a0 *sagemaker.UpdateEndpointInput) (*sagemaker.UpdateEndpointOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.UpdateEndpointOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.UpdateEndpointInput) *sagemaker.UpdateEndpointOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.UpdateEndpointOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.UpdateEndpointInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateEndpointRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) UpdateEndpointRequest(_a0 *sagemaker.UpdateEndpointInput) (*request.Request, *sagemaker.UpdateEndpointOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.UpdateEndpointInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.UpdateEndpointOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.UpdateEndpointInput) *sagemaker.UpdateEndpointOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.UpdateEndpointOutput)
		}
	}

	return r0, r1
}

// UpdateEndpointWeightsAndCapacities provides a mock function with given fields: _a0
func (_m *SageMakerAPI) UpdateEndpointWeightsAndCapacities(_a0 *sagemaker.UpdateEndpointWeightsAndCapacitiesInput) (*sagemaker.UpdateEndpointWeightsAndCapacitiesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.UpdateEndpointWeightsAndCapacitiesOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.UpdateEndpointWeightsAndCapacitiesInput) *sagemaker.UpdateEndpointWeightsAndCapacitiesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.UpdateEndpointWeightsAndCapacitiesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.UpdateEndpointWeightsAndCapacitiesInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateEndpointWeightsAndCapacitiesRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) UpdateEndpointWeightsAndCapacitiesRequest(_a0 *sagemaker.UpdateEndpointWeightsAndCapacitiesInput) (*request.Request, *sagemaker.UpdateEndpointWeightsAndCapacitiesOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.UpdateEndpointWeightsAndCapacitiesInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.UpdateEndpointWeightsAndCapacitiesOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.UpdateEndpointWeightsAndCapacitiesInput) *sagemaker.UpdateEndpointWeightsAndCapacitiesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.UpdateEndpointWeightsAndCapacitiesOutput)
		}
	}

	return r0, r1
}

// UpdateEndpointWeightsAndCapacitiesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) UpdateEndpointWeightsAndCapacitiesWithContext(_a0 context.Context, _a1 *sagemaker.UpdateEndpointWeightsAndCapacitiesInput, _a2 ...request.Option) (*sagemaker.UpdateEndpointWeightsAndCapacitiesOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.UpdateEndpointWeightsAndCapacitiesOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.UpdateEndpointWeightsAndCapacitiesInput, ...request.Option) *sagemaker.UpdateEndpointWeightsAndCapacitiesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.UpdateEndpointWeightsAndCapacitiesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.UpdateEndpointWeightsAndCapacitiesInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateEndpointWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) UpdateEndpointWithContext(_a0 context.Context, _a1 *sagemaker.UpdateEndpointInput, _a2 ...request.Option) (*sagemaker.UpdateEndpointOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.UpdateEndpointOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.UpdateEndpointInput, ...request.Option) *sagemaker.UpdateEndpointOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.UpdateEndpointOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.UpdateEndpointInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateExperiment provides a mock function with given fields: _a0
func (_m *SageMakerAPI) UpdateExperiment(_a0 *sagemaker.UpdateExperimentInput) (*sagemaker.UpdateExperimentOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.UpdateExperimentOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.UpdateExperimentInput) *sagemaker.UpdateExperimentOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.UpdateExperimentOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.UpdateExperimentInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateExperimentRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) UpdateExperimentRequest(_a0 *sagemaker.UpdateExperimentInput) (*request.Request, *sagemaker.UpdateExperimentOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.UpdateExperimentInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.UpdateExperimentOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.UpdateExperimentInput) *sagemaker.UpdateExperimentOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.UpdateExperimentOutput)
		}
	}

	return r0, r1
}

// UpdateExperimentWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) UpdateExperimentWithContext(_a0 context.Context, _a1 *sagemaker.UpdateExperimentInput, _a2 ...request.Option) (*sagemaker.UpdateExperimentOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.UpdateExperimentOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.UpdateExperimentInput, ...request.Option) *sagemaker.UpdateExperimentOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.UpdateExperimentOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.UpdateExperimentInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateImage provides a mock function with given fields: _a0
func (_m *SageMakerAPI) UpdateImage(_a0 *sagemaker.UpdateImageInput) (*sagemaker.UpdateImageOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.UpdateImageOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.UpdateImageInput) *sagemaker.UpdateImageOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.UpdateImageOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.UpdateImageInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateImageRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) UpdateImageRequest(_a0 *sagemaker.UpdateImageInput) (*request.Request, *sagemaker.UpdateImageOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.UpdateImageInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.UpdateImageOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.UpdateImageInput) *sagemaker.UpdateImageOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.UpdateImageOutput)
		}
	}

	return r0, r1
}

// UpdateImageWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) UpdateImageWithContext(_a0 context.Context, _a1 *sagemaker.UpdateImageInput, _a2 ...request.Option) (*sagemaker.UpdateImageOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.UpdateImageOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.UpdateImageInput, ...request.Option) *sagemaker.UpdateImageOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.UpdateImageOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.UpdateImageInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateModelPackage provides a mock function with given fields: _a0
func (_m *SageMakerAPI) UpdateModelPackage(_a0 *sagemaker.UpdateModelPackageInput) (*sagemaker.UpdateModelPackageOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.UpdateModelPackageOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.UpdateModelPackageInput) *sagemaker.UpdateModelPackageOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.UpdateModelPackageOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.UpdateModelPackageInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateModelPackageRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) UpdateModelPackageRequest(_a0 *sagemaker.UpdateModelPackageInput) (*request.Request, *sagemaker.UpdateModelPackageOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.UpdateModelPackageInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.UpdateModelPackageOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.UpdateModelPackageInput) *sagemaker.UpdateModelPackageOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.UpdateModelPackageOutput)
		}
	}

	return r0, r1
}

// UpdateModelPackageWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) UpdateModelPackageWithContext(_a0 context.Context, _a1 *sagemaker.UpdateModelPackageInput, _a2 ...request.Option) (*sagemaker.UpdateModelPackageOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.UpdateModelPackageOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.UpdateModelPackageInput, ...request.Option) *sagemaker.UpdateModelPackageOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.UpdateModelPackageOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.UpdateModelPackageInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateMonitoringSchedule provides a mock function with given fields: _a0
func (_m *SageMakerAPI) UpdateMonitoringSchedule(_a0 *sagemaker.UpdateMonitoringScheduleInput) (*sagemaker.UpdateMonitoringScheduleOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.UpdateMonitoringScheduleOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.UpdateMonitoringScheduleInput) *sagemaker.UpdateMonitoringScheduleOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.UpdateMonitoringScheduleOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.UpdateMonitoringScheduleInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateMonitoringScheduleRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) UpdateMonitoringScheduleRequest(_a0 *sagemaker.UpdateMonitoringScheduleInput) (*request.Request, *sagemaker.UpdateMonitoringScheduleOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.UpdateMonitoringScheduleInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.UpdateMonitoringScheduleOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.UpdateMonitoringScheduleInput) *sagemaker.UpdateMonitoringScheduleOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.UpdateMonitoringScheduleOutput)
		}
	}

	return r0, r1
}

// UpdateMonitoringScheduleWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) UpdateMonitoringScheduleWithContext(_a0 context.Context, _a1 *sagemaker.UpdateMonitoringScheduleInput, _a2 ...request.Option) (*sagemaker.UpdateMonitoringScheduleOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.UpdateMonitoringScheduleOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.UpdateMonitoringScheduleInput, ...request.Option) *sagemaker.UpdateMonitoringScheduleOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.UpdateMonitoringScheduleOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.UpdateMonitoringScheduleInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateNotebookInstance provides a mock function with given fields: _a0
func (_m *SageMakerAPI) UpdateNotebookInstance(_a0 *sagemaker.UpdateNotebookInstanceInput) (*sagemaker.UpdateNotebookInstanceOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.UpdateNotebookInstanceOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.UpdateNotebookInstanceInput) *sagemaker.UpdateNotebookInstanceOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.UpdateNotebookInstanceOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.UpdateNotebookInstanceInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateNotebookInstanceLifecycleConfig provides a mock function with given fields: _a0
func (_m *SageMakerAPI) UpdateNotebookInstanceLifecycleConfig(_a0 *sagemaker.UpdateNotebookInstanceLifecycleConfigInput) (*sagemaker.UpdateNotebookInstanceLifecycleConfigOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.UpdateNotebookInstanceLifecycleConfigOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.UpdateNotebookInstanceLifecycleConfigInput) *sagemaker.UpdateNotebookInstanceLifecycleConfigOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.UpdateNotebookInstanceLifecycleConfigOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.UpdateNotebookInstanceLifecycleConfigInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateNotebookInstanceLifecycleConfigRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) UpdateNotebookInstanceLifecycleConfigRequest(_a0 *sagemaker.UpdateNotebookInstanceLifecycleConfigInput) (*request.Request, *sagemaker.UpdateNotebookInstanceLifecycleConfigOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.UpdateNotebookInstanceLifecycleConfigInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.UpdateNotebookInstanceLifecycleConfigOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.UpdateNotebookInstanceLifecycleConfigInput) *sagemaker.UpdateNotebookInstanceLifecycleConfigOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.UpdateNotebookInstanceLifecycleConfigOutput)
		}
	}

	return r0, r1
}

// UpdateNotebookInstanceLifecycleConfigWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) UpdateNotebookInstanceLifecycleConfigWithContext(_a0 context.Context, _a1 *sagemaker.UpdateNotebookInstanceLifecycleConfigInput, _a2 ...request.Option) (*sagemaker.UpdateNotebookInstanceLifecycleConfigOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.UpdateNotebookInstanceLifecycleConfigOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.UpdateNotebookInstanceLifecycleConfigInput, ...request.Option) *sagemaker.UpdateNotebookInstanceLifecycleConfigOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.UpdateNotebookInstanceLifecycleConfigOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.UpdateNotebookInstanceLifecycleConfigInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateNotebookInstanceRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) UpdateNotebookInstanceRequest(_a0 *sagemaker.UpdateNotebookInstanceInput) (*request.Request, *sagemaker.UpdateNotebookInstanceOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.UpdateNotebookInstanceInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.UpdateNotebookInstanceOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.UpdateNotebookInstanceInput) *sagemaker.UpdateNotebookInstanceOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.UpdateNotebookInstanceOutput)
		}
	}

	return r0, r1
}

// UpdateNotebookInstanceWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) UpdateNotebookInstanceWithContext(_a0 context.Context, _a1 *sagemaker.UpdateNotebookInstanceInput, _a2 ...request.Option) (*sagemaker.UpdateNotebookInstanceOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.UpdateNotebookInstanceOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.UpdateNotebookInstanceInput, ...request.Option) *sagemaker.UpdateNotebookInstanceOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.UpdateNotebookInstanceOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.UpdateNotebookInstanceInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdatePipeline provides a mock function with given fields: _a0
func (_m *SageMakerAPI) UpdatePipeline(_a0 *sagemaker.UpdatePipelineInput) (*sagemaker.UpdatePipelineOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.UpdatePipelineOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.UpdatePipelineInput) *sagemaker.UpdatePipelineOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.UpdatePipelineOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.UpdatePipelineInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdatePipelineExecution provides a mock function with given fields: _a0
func (_m *SageMakerAPI) UpdatePipelineExecution(_a0 *sagemaker.UpdatePipelineExecutionInput) (*sagemaker.UpdatePipelineExecutionOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.UpdatePipelineExecutionOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.UpdatePipelineExecutionInput) *sagemaker.UpdatePipelineExecutionOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.UpdatePipelineExecutionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.UpdatePipelineExecutionInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdatePipelineExecutionRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) UpdatePipelineExecutionRequest(_a0 *sagemaker.UpdatePipelineExecutionInput) (*request.Request, *sagemaker.UpdatePipelineExecutionOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.UpdatePipelineExecutionInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.UpdatePipelineExecutionOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.UpdatePipelineExecutionInput) *sagemaker.UpdatePipelineExecutionOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.UpdatePipelineExecutionOutput)
		}
	}

	return r0, r1
}

// UpdatePipelineExecutionWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) UpdatePipelineExecutionWithContext(_a0 context.Context, _a1 *sagemaker.UpdatePipelineExecutionInput, _a2 ...request.Option) (*sagemaker.UpdatePipelineExecutionOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.UpdatePipelineExecutionOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.UpdatePipelineExecutionInput, ...request.Option) *sagemaker.UpdatePipelineExecutionOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.UpdatePipelineExecutionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.UpdatePipelineExecutionInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdatePipelineRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) UpdatePipelineRequest(_a0 *sagemaker.UpdatePipelineInput) (*request.Request, *sagemaker.UpdatePipelineOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.UpdatePipelineInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.UpdatePipelineOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.UpdatePipelineInput) *sagemaker.UpdatePipelineOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.UpdatePipelineOutput)
		}
	}

	return r0, r1
}

// UpdatePipelineWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) UpdatePipelineWithContext(_a0 context.Context, _a1 *sagemaker.UpdatePipelineInput, _a2 ...request.Option) (*sagemaker.UpdatePipelineOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.UpdatePipelineOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.UpdatePipelineInput, ...request.Option) *sagemaker.UpdatePipelineOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.UpdatePipelineOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.UpdatePipelineInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateTrainingJob provides a mock function with given fields: _a0
func (_m *SageMakerAPI) UpdateTrainingJob(_a0 *sagemaker.UpdateTrainingJobInput) (*sagemaker.UpdateTrainingJobOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.UpdateTrainingJobOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.UpdateTrainingJobInput) *sagemaker.UpdateTrainingJobOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.UpdateTrainingJobOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.UpdateTrainingJobInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateTrainingJobRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) UpdateTrainingJobRequest(_a0 *sagemaker.UpdateTrainingJobInput) (*request.Request, *sagemaker.UpdateTrainingJobOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.UpdateTrainingJobInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.UpdateTrainingJobOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.UpdateTrainingJobInput) *sagemaker.UpdateTrainingJobOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.UpdateTrainingJobOutput)
		}
	}

	return r0, r1
}

// UpdateTrainingJobWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) UpdateTrainingJobWithContext(_a0 context.Context, _a1 *sagemaker.UpdateTrainingJobInput, _a2 ...request.Option) (*sagemaker.UpdateTrainingJobOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.UpdateTrainingJobOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.UpdateTrainingJobInput, ...request.Option) *sagemaker.UpdateTrainingJobOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.UpdateTrainingJobOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.UpdateTrainingJobInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateTrial provides a mock function with given fields: _a0
func (_m *SageMakerAPI) UpdateTrial(_a0 *sagemaker.UpdateTrialInput) (*sagemaker.UpdateTrialOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.UpdateTrialOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.UpdateTrialInput) *sagemaker.UpdateTrialOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.UpdateTrialOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.UpdateTrialInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateTrialComponent provides a mock function with given fields: _a0
func (_m *SageMakerAPI) UpdateTrialComponent(_a0 *sagemaker.UpdateTrialComponentInput) (*sagemaker.UpdateTrialComponentOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.UpdateTrialComponentOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.UpdateTrialComponentInput) *sagemaker.UpdateTrialComponentOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.UpdateTrialComponentOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.UpdateTrialComponentInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateTrialComponentRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) UpdateTrialComponentRequest(_a0 *sagemaker.UpdateTrialComponentInput) (*request.Request, *sagemaker.UpdateTrialComponentOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.UpdateTrialComponentInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.UpdateTrialComponentOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.UpdateTrialComponentInput) *sagemaker.UpdateTrialComponentOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.UpdateTrialComponentOutput)
		}
	}

	return r0, r1
}

// UpdateTrialComponentWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) UpdateTrialComponentWithContext(_a0 context.Context, _a1 *sagemaker.UpdateTrialComponentInput, _a2 ...request.Option) (*sagemaker.UpdateTrialComponentOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.UpdateTrialComponentOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.UpdateTrialComponentInput, ...request.Option) *sagemaker.UpdateTrialComponentOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.UpdateTrialComponentOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.UpdateTrialComponentInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateTrialRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) UpdateTrialRequest(_a0 *sagemaker.UpdateTrialInput) (*request.Request, *sagemaker.UpdateTrialOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.UpdateTrialInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.UpdateTrialOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.UpdateTrialInput) *sagemaker.UpdateTrialOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.UpdateTrialOutput)
		}
	}

	return r0, r1
}

// UpdateTrialWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) UpdateTrialWithContext(_a0 context.Context, _a1 *sagemaker.UpdateTrialInput, _a2 ...request.Option) (*sagemaker.UpdateTrialOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.UpdateTrialOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.UpdateTrialInput, ...request.Option) *sagemaker.UpdateTrialOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.UpdateTrialOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.UpdateTrialInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateUserProfile provides a mock function with given fields: _a0
func (_m *SageMakerAPI) UpdateUserProfile(_a0 *sagemaker.UpdateUserProfileInput) (*sagemaker.UpdateUserProfileOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.UpdateUserProfileOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.UpdateUserProfileInput) *sagemaker.UpdateUserProfileOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.UpdateUserProfileOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.UpdateUserProfileInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateUserProfileRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) UpdateUserProfileRequest(_a0 *sagemaker.UpdateUserProfileInput) (*request.Request, *sagemaker.UpdateUserProfileOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.UpdateUserProfileInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.UpdateUserProfileOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.UpdateUserProfileInput) *sagemaker.UpdateUserProfileOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.UpdateUserProfileOutput)
		}
	}

	return r0, r1
}

// UpdateUserProfileWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) UpdateUserProfileWithContext(_a0 context.Context, _a1 *sagemaker.UpdateUserProfileInput, _a2 ...request.Option) (*sagemaker.UpdateUserProfileOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.UpdateUserProfileOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.UpdateUserProfileInput, ...request.Option) *sagemaker.UpdateUserProfileOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.UpdateUserProfileOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.UpdateUserProfileInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateWorkforce provides a mock function with given fields: _a0
func (_m *SageMakerAPI) UpdateWorkforce(_a0 *sagemaker.UpdateWorkforceInput) (*sagemaker.UpdateWorkforceOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.UpdateWorkforceOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.UpdateWorkforceInput) *sagemaker.UpdateWorkforceOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.UpdateWorkforceOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.UpdateWorkforceInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateWorkforceRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) UpdateWorkforceRequest(_a0 *sagemaker.UpdateWorkforceInput) (*request.Request, *sagemaker.UpdateWorkforceOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.UpdateWorkforceInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.UpdateWorkforceOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.UpdateWorkforceInput) *sagemaker.UpdateWorkforceOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.UpdateWorkforceOutput)
		}
	}

	return r0, r1
}

// UpdateWorkforceWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) UpdateWorkforceWithContext(_a0 context.Context, _a1 *sagemaker.UpdateWorkforceInput, _a2 ...request.Option) (*sagemaker.UpdateWorkforceOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.UpdateWorkforceOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.UpdateWorkforceInput, ...request.Option) *sagemaker.UpdateWorkforceOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.UpdateWorkforceOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.UpdateWorkforceInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateWorkteam provides a mock function with given fields: _a0
func (_m *SageMakerAPI) UpdateWorkteam(_a0 *sagemaker.UpdateWorkteamInput) (*sagemaker.UpdateWorkteamOutput, error) {
	ret := _m.Called(_a0)

	var r0 *sagemaker.UpdateWorkteamOutput
	if rf, ok := ret.Get(0).(func(*sagemaker.UpdateWorkteamInput) *sagemaker.UpdateWorkteamOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.UpdateWorkteamOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*sagemaker.UpdateWorkteamInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateWorkteamRequest provides a mock function with given fields: _a0
func (_m *SageMakerAPI) UpdateWorkteamRequest(_a0 *sagemaker.UpdateWorkteamInput) (*request.Request, *sagemaker.UpdateWorkteamOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*sagemaker.UpdateWorkteamInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *sagemaker.UpdateWorkteamOutput
	if rf, ok := ret.Get(1).(func(*sagemaker.UpdateWorkteamInput) *sagemaker.UpdateWorkteamOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sagemaker.UpdateWorkteamOutput)
		}
	}

	return r0, r1
}

// UpdateWorkteamWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) UpdateWorkteamWithContext(_a0 context.Context, _a1 *sagemaker.UpdateWorkteamInput, _a2 ...request.Option) (*sagemaker.UpdateWorkteamOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *sagemaker.UpdateWorkteamOutput
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.UpdateWorkteamInput, ...request.Option) *sagemaker.UpdateWorkteamOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sagemaker.UpdateWorkteamOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *sagemaker.UpdateWorkteamInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// WaitUntilEndpointDeleted provides a mock function with given fields: _a0
func (_m *SageMakerAPI) WaitUntilEndpointDeleted(_a0 *sagemaker.DescribeEndpointInput) error {
	ret := _m.Called(_a0)

	var r0 error
	if rf, ok := ret.Get(0).(func(*sagemaker.DescribeEndpointInput) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilEndpointDeletedWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) WaitUntilEndpointDeletedWithContext(_a0 context.Context, _a1 *sagemaker.DescribeEndpointInput, _a2 ...request.WaiterOption) error {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.DescribeEndpointInput, ...request.WaiterOption) error); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilEndpointInService provides a mock function with given fields: _a0
func (_m *SageMakerAPI) WaitUntilEndpointInService(_a0 *sagemaker.DescribeEndpointInput) error {
	ret := _m.Called(_a0)

	var r0 error
	if rf, ok := ret.Get(0).(func(*sagemaker.DescribeEndpointInput) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilEndpointInServiceWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) WaitUntilEndpointInServiceWithContext(_a0 context.Context, _a1 *sagemaker.DescribeEndpointInput, _a2 ...request.WaiterOption) error {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.DescribeEndpointInput, ...request.WaiterOption) error); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilNotebookInstanceDeleted provides a mock function with given fields: _a0
func (_m *SageMakerAPI) WaitUntilNotebookInstanceDeleted(_a0 *sagemaker.DescribeNotebookInstanceInput) error {
	ret := _m.Called(_a0)

	var r0 error
	if rf, ok := ret.Get(0).(func(*sagemaker.DescribeNotebookInstanceInput) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilNotebookInstanceDeletedWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) WaitUntilNotebookInstanceDeletedWithContext(_a0 context.Context, _a1 *sagemaker.DescribeNotebookInstanceInput, _a2 ...request.WaiterOption) error {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.DescribeNotebookInstanceInput, ...request.WaiterOption) error); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilNotebookInstanceInService provides a mock function with given fields: _a0
func (_m *SageMakerAPI) WaitUntilNotebookInstanceInService(_a0 *sagemaker.DescribeNotebookInstanceInput) error {
	ret := _m.Called(_a0)

	var r0 error
	if rf, ok := ret.Get(0).(func(*sagemaker.DescribeNotebookInstanceInput) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilNotebookInstanceInServiceWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) WaitUntilNotebookInstanceInServiceWithContext(_a0 context.Context, _a1 *sagemaker.DescribeNotebookInstanceInput, _a2 ...request.WaiterOption) error {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.DescribeNotebookInstanceInput, ...request.WaiterOption) error); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilNotebookInstanceStopped provides a mock function with given fields: _a0
func (_m *SageMakerAPI) WaitUntilNotebookInstanceStopped(_a0 *sagemaker.DescribeNotebookInstanceInput) error {
	ret := _m.Called(_a0)

	var r0 error
	if rf, ok := ret.Get(0).(func(*sagemaker.DescribeNotebookInstanceInput) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilNotebookInstanceStoppedWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) WaitUntilNotebookInstanceStoppedWithContext(_a0 context.Context, _a1 *sagemaker.DescribeNotebookInstanceInput, _a2 ...request.WaiterOption) error {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.DescribeNotebookInstanceInput, ...request.WaiterOption) error); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilProcessingJobCompletedOrStopped provides a mock function with given fields: _a0
func (_m *SageMakerAPI) WaitUntilProcessingJobCompletedOrStopped(_a0 *sagemaker.DescribeProcessingJobInput) error {
	ret := _m.Called(_a0)

	var r0 error
	if rf, ok := ret.Get(0).(func(*sagemaker.DescribeProcessingJobInput) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilProcessingJobCompletedOrStoppedWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) WaitUntilProcessingJobCompletedOrStoppedWithContext(_a0 context.Context, _a1 *sagemaker.DescribeProcessingJobInput, _a2 ...request.WaiterOption) error {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.DescribeProcessingJobInput, ...request.WaiterOption) error); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilTrainingJobCompletedOrStopped provides a mock function with given fields: _a0
func (_m *SageMakerAPI) WaitUntilTrainingJobCompletedOrStopped(_a0 *sagemaker.DescribeTrainingJobInput) error {
	ret := _m.Called(_a0)

	var r0 error
	if rf, ok := ret.Get(0).(func(*sagemaker.DescribeTrainingJobInput) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilTrainingJobCompletedOrStoppedWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) WaitUntilTrainingJobCompletedOrStoppedWithContext(_a0 context.Context, _a1 *sagemaker.DescribeTrainingJobInput, _a2 ...request.WaiterOption) error {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.DescribeTrainingJobInput, ...request.WaiterOption) error); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilTransformJobCompletedOrStopped provides a mock function with given fields: _a0
func (_m *SageMakerAPI) WaitUntilTransformJobCompletedOrStopped(_a0 *sagemaker.DescribeTransformJobInput) error {
	ret := _m.Called(_a0)

	var r0 error
	if rf, ok := ret.Get(0).(func(*sagemaker.DescribeTransformJobInput) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilTransformJobCompletedOrStoppedWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SageMakerAPI) WaitUntilTransformJobCompletedOrStoppedWithContext(_a0 context.Context, _a1 *sagemaker.DescribeTransformJobInput, _a2 ...request.WaiterOption) error {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *sagemaker.DescribeTransformJobInput, ...request.WaiterOption) error); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}