// Code generated by mockery v1.0.0
package mocks

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

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

// AddTagsToResource provides a mock function with given fields: _a0
func (_m *SSMAPI) AddTagsToResource(_a0 *ssm.AddTagsToResourceInput) (*ssm.AddTagsToResourceOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ssm.AddTagsToResourceOutput
	if rf, ok := ret.Get(0).(func(*ssm.AddTagsToResourceInput) *ssm.AddTagsToResourceOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.AddTagsToResourceOutput)
		}
	}

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

	return r0, r1
}

// AddTagsToResourceRequest provides a mock function with given fields: _a0
func (_m *SSMAPI) AddTagsToResourceRequest(_a0 *ssm.AddTagsToResourceInput) (*request.Request, *ssm.AddTagsToResourceOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ssm.AddTagsToResourceOutput
	if rf, ok := ret.Get(1).(func(*ssm.AddTagsToResourceInput) *ssm.AddTagsToResourceOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ssm.AddTagsToResourceOutput)
		}
	}

	return r0, r1
}

// AddTagsToResourceWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) AddTagsToResourceWithContext(_a0 aws.Context, _a1 *ssm.AddTagsToResourceInput, _a2 ...request.Option) (*ssm.AddTagsToResourceOutput, 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 *ssm.AddTagsToResourceOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ssm.AddTagsToResourceInput, ...request.Option) *ssm.AddTagsToResourceOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.AddTagsToResourceOutput)
		}
	}

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

	return r0, r1
}

// CancelCommand provides a mock function with given fields: _a0
func (_m *SSMAPI) CancelCommand(_a0 *ssm.CancelCommandInput) (*ssm.CancelCommandOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ssm.CancelCommandOutput
	if rf, ok := ret.Get(0).(func(*ssm.CancelCommandInput) *ssm.CancelCommandOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.CancelCommandOutput)
		}
	}

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

	return r0, r1
}

// CancelCommandRequest provides a mock function with given fields: _a0
func (_m *SSMAPI) CancelCommandRequest(_a0 *ssm.CancelCommandInput) (*request.Request, *ssm.CancelCommandOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ssm.CancelCommandOutput
	if rf, ok := ret.Get(1).(func(*ssm.CancelCommandInput) *ssm.CancelCommandOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ssm.CancelCommandOutput)
		}
	}

	return r0, r1
}

// CancelCommandWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) CancelCommandWithContext(_a0 aws.Context, _a1 *ssm.CancelCommandInput, _a2 ...request.Option) (*ssm.CancelCommandOutput, 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 *ssm.CancelCommandOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ssm.CancelCommandInput, ...request.Option) *ssm.CancelCommandOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.CancelCommandOutput)
		}
	}

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

	return r0, r1
}

// CreateActivation provides a mock function with given fields: _a0
func (_m *SSMAPI) CreateActivation(_a0 *ssm.CreateActivationInput) (*ssm.CreateActivationOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ssm.CreateActivationOutput
	if rf, ok := ret.Get(0).(func(*ssm.CreateActivationInput) *ssm.CreateActivationOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.CreateActivationOutput)
		}
	}

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

	return r0, r1
}

// CreateActivationRequest provides a mock function with given fields: _a0
func (_m *SSMAPI) CreateActivationRequest(_a0 *ssm.CreateActivationInput) (*request.Request, *ssm.CreateActivationOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ssm.CreateActivationOutput
	if rf, ok := ret.Get(1).(func(*ssm.CreateActivationInput) *ssm.CreateActivationOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ssm.CreateActivationOutput)
		}
	}

	return r0, r1
}

// CreateActivationWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) CreateActivationWithContext(_a0 aws.Context, _a1 *ssm.CreateActivationInput, _a2 ...request.Option) (*ssm.CreateActivationOutput, 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 *ssm.CreateActivationOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ssm.CreateActivationInput, ...request.Option) *ssm.CreateActivationOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.CreateActivationOutput)
		}
	}

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

	return r0, r1
}

// CreateAssociation provides a mock function with given fields: _a0
func (_m *SSMAPI) CreateAssociation(_a0 *ssm.CreateAssociationInput) (*ssm.CreateAssociationOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ssm.CreateAssociationOutput
	if rf, ok := ret.Get(0).(func(*ssm.CreateAssociationInput) *ssm.CreateAssociationOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.CreateAssociationOutput)
		}
	}

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

	return r0, r1
}

// CreateAssociationBatch provides a mock function with given fields: _a0
func (_m *SSMAPI) CreateAssociationBatch(_a0 *ssm.CreateAssociationBatchInput) (*ssm.CreateAssociationBatchOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ssm.CreateAssociationBatchOutput
	if rf, ok := ret.Get(0).(func(*ssm.CreateAssociationBatchInput) *ssm.CreateAssociationBatchOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.CreateAssociationBatchOutput)
		}
	}

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

	return r0, r1
}

// CreateAssociationBatchRequest provides a mock function with given fields: _a0
func (_m *SSMAPI) CreateAssociationBatchRequest(_a0 *ssm.CreateAssociationBatchInput) (*request.Request, *ssm.CreateAssociationBatchOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ssm.CreateAssociationBatchOutput
	if rf, ok := ret.Get(1).(func(*ssm.CreateAssociationBatchInput) *ssm.CreateAssociationBatchOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ssm.CreateAssociationBatchOutput)
		}
	}

	return r0, r1
}

// CreateAssociationBatchWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) CreateAssociationBatchWithContext(_a0 aws.Context, _a1 *ssm.CreateAssociationBatchInput, _a2 ...request.Option) (*ssm.CreateAssociationBatchOutput, 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 *ssm.CreateAssociationBatchOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ssm.CreateAssociationBatchInput, ...request.Option) *ssm.CreateAssociationBatchOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.CreateAssociationBatchOutput)
		}
	}

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

	return r0, r1
}

// CreateAssociationRequest provides a mock function with given fields: _a0
func (_m *SSMAPI) CreateAssociationRequest(_a0 *ssm.CreateAssociationInput) (*request.Request, *ssm.CreateAssociationOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ssm.CreateAssociationOutput
	if rf, ok := ret.Get(1).(func(*ssm.CreateAssociationInput) *ssm.CreateAssociationOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ssm.CreateAssociationOutput)
		}
	}

	return r0, r1
}

// CreateAssociationWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) CreateAssociationWithContext(_a0 aws.Context, _a1 *ssm.CreateAssociationInput, _a2 ...request.Option) (*ssm.CreateAssociationOutput, 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 *ssm.CreateAssociationOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ssm.CreateAssociationInput, ...request.Option) *ssm.CreateAssociationOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.CreateAssociationOutput)
		}
	}

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

	return r0, r1
}

// CreateDocument provides a mock function with given fields: _a0
func (_m *SSMAPI) CreateDocument(_a0 *ssm.CreateDocumentInput) (*ssm.CreateDocumentOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ssm.CreateDocumentOutput
	if rf, ok := ret.Get(0).(func(*ssm.CreateDocumentInput) *ssm.CreateDocumentOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.CreateDocumentOutput)
		}
	}

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

	return r0, r1
}

// CreateDocumentRequest provides a mock function with given fields: _a0
func (_m *SSMAPI) CreateDocumentRequest(_a0 *ssm.CreateDocumentInput) (*request.Request, *ssm.CreateDocumentOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ssm.CreateDocumentOutput
	if rf, ok := ret.Get(1).(func(*ssm.CreateDocumentInput) *ssm.CreateDocumentOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ssm.CreateDocumentOutput)
		}
	}

	return r0, r1
}

// CreateDocumentWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) CreateDocumentWithContext(_a0 aws.Context, _a1 *ssm.CreateDocumentInput, _a2 ...request.Option) (*ssm.CreateDocumentOutput, 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 *ssm.CreateDocumentOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ssm.CreateDocumentInput, ...request.Option) *ssm.CreateDocumentOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.CreateDocumentOutput)
		}
	}

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

	return r0, r1
}

// CreateMaintenanceWindow provides a mock function with given fields: _a0
func (_m *SSMAPI) CreateMaintenanceWindow(_a0 *ssm.CreateMaintenanceWindowInput) (*ssm.CreateMaintenanceWindowOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ssm.CreateMaintenanceWindowOutput
	if rf, ok := ret.Get(0).(func(*ssm.CreateMaintenanceWindowInput) *ssm.CreateMaintenanceWindowOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.CreateMaintenanceWindowOutput)
		}
	}

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

	return r0, r1
}

// CreateMaintenanceWindowRequest provides a mock function with given fields: _a0
func (_m *SSMAPI) CreateMaintenanceWindowRequest(_a0 *ssm.CreateMaintenanceWindowInput) (*request.Request, *ssm.CreateMaintenanceWindowOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ssm.CreateMaintenanceWindowOutput
	if rf, ok := ret.Get(1).(func(*ssm.CreateMaintenanceWindowInput) *ssm.CreateMaintenanceWindowOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ssm.CreateMaintenanceWindowOutput)
		}
	}

	return r0, r1
}

// CreateMaintenanceWindowWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) CreateMaintenanceWindowWithContext(_a0 aws.Context, _a1 *ssm.CreateMaintenanceWindowInput, _a2 ...request.Option) (*ssm.CreateMaintenanceWindowOutput, 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 *ssm.CreateMaintenanceWindowOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ssm.CreateMaintenanceWindowInput, ...request.Option) *ssm.CreateMaintenanceWindowOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.CreateMaintenanceWindowOutput)
		}
	}

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

	return r0, r1
}

// CreatePatchBaseline provides a mock function with given fields: _a0
func (_m *SSMAPI) CreatePatchBaseline(_a0 *ssm.CreatePatchBaselineInput) (*ssm.CreatePatchBaselineOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ssm.CreatePatchBaselineOutput
	if rf, ok := ret.Get(0).(func(*ssm.CreatePatchBaselineInput) *ssm.CreatePatchBaselineOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.CreatePatchBaselineOutput)
		}
	}

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

	return r0, r1
}

// CreatePatchBaselineRequest provides a mock function with given fields: _a0
func (_m *SSMAPI) CreatePatchBaselineRequest(_a0 *ssm.CreatePatchBaselineInput) (*request.Request, *ssm.CreatePatchBaselineOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ssm.CreatePatchBaselineOutput
	if rf, ok := ret.Get(1).(func(*ssm.CreatePatchBaselineInput) *ssm.CreatePatchBaselineOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ssm.CreatePatchBaselineOutput)
		}
	}

	return r0, r1
}

// CreatePatchBaselineWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) CreatePatchBaselineWithContext(_a0 aws.Context, _a1 *ssm.CreatePatchBaselineInput, _a2 ...request.Option) (*ssm.CreatePatchBaselineOutput, 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 *ssm.CreatePatchBaselineOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ssm.CreatePatchBaselineInput, ...request.Option) *ssm.CreatePatchBaselineOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.CreatePatchBaselineOutput)
		}
	}

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

	return r0, r1
}

// CreateResourceDataSync provides a mock function with given fields: _a0
func (_m *SSMAPI) CreateResourceDataSync(_a0 *ssm.CreateResourceDataSyncInput) (*ssm.CreateResourceDataSyncOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ssm.CreateResourceDataSyncOutput
	if rf, ok := ret.Get(0).(func(*ssm.CreateResourceDataSyncInput) *ssm.CreateResourceDataSyncOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.CreateResourceDataSyncOutput)
		}
	}

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

	return r0, r1
}

// CreateResourceDataSyncRequest provides a mock function with given fields: _a0
func (_m *SSMAPI) CreateResourceDataSyncRequest(_a0 *ssm.CreateResourceDataSyncInput) (*request.Request, *ssm.CreateResourceDataSyncOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ssm.CreateResourceDataSyncOutput
	if rf, ok := ret.Get(1).(func(*ssm.CreateResourceDataSyncInput) *ssm.CreateResourceDataSyncOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ssm.CreateResourceDataSyncOutput)
		}
	}

	return r0, r1
}

// CreateResourceDataSyncWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) CreateResourceDataSyncWithContext(_a0 aws.Context, _a1 *ssm.CreateResourceDataSyncInput, _a2 ...request.Option) (*ssm.CreateResourceDataSyncOutput, 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 *ssm.CreateResourceDataSyncOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ssm.CreateResourceDataSyncInput, ...request.Option) *ssm.CreateResourceDataSyncOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.CreateResourceDataSyncOutput)
		}
	}

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

	return r0, r1
}

// DeleteActivation provides a mock function with given fields: _a0
func (_m *SSMAPI) DeleteActivation(_a0 *ssm.DeleteActivationInput) (*ssm.DeleteActivationOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ssm.DeleteActivationOutput
	if rf, ok := ret.Get(0).(func(*ssm.DeleteActivationInput) *ssm.DeleteActivationOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.DeleteActivationOutput)
		}
	}

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

	return r0, r1
}

// DeleteActivationRequest provides a mock function with given fields: _a0
func (_m *SSMAPI) DeleteActivationRequest(_a0 *ssm.DeleteActivationInput) (*request.Request, *ssm.DeleteActivationOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ssm.DeleteActivationOutput
	if rf, ok := ret.Get(1).(func(*ssm.DeleteActivationInput) *ssm.DeleteActivationOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ssm.DeleteActivationOutput)
		}
	}

	return r0, r1
}

// DeleteActivationWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) DeleteActivationWithContext(_a0 aws.Context, _a1 *ssm.DeleteActivationInput, _a2 ...request.Option) (*ssm.DeleteActivationOutput, 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 *ssm.DeleteActivationOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ssm.DeleteActivationInput, ...request.Option) *ssm.DeleteActivationOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.DeleteActivationOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(aws.Context, *ssm.DeleteActivationInput, ...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 *SSMAPI) DeleteAssociation(_a0 *ssm.DeleteAssociationInput) (*ssm.DeleteAssociationOutput, error) {
	ret := _m.Called(_a0)

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

	var r1 error
	if rf, ok := ret.Get(1).(func(*ssm.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 *SSMAPI) DeleteAssociationRequest(_a0 *ssm.DeleteAssociationInput) (*request.Request, *ssm.DeleteAssociationOutput) {
	ret := _m.Called(_a0)

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

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

	return r0, r1
}

// DeleteAssociationWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) DeleteAssociationWithContext(_a0 aws.Context, _a1 *ssm.DeleteAssociationInput, _a2 ...request.Option) (*ssm.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 *ssm.DeleteAssociationOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ssm.DeleteAssociationInput, ...request.Option) *ssm.DeleteAssociationOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.DeleteAssociationOutput)
		}
	}

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

	return r0, r1
}

// DeleteDocument provides a mock function with given fields: _a0
func (_m *SSMAPI) DeleteDocument(_a0 *ssm.DeleteDocumentInput) (*ssm.DeleteDocumentOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ssm.DeleteDocumentOutput
	if rf, ok := ret.Get(0).(func(*ssm.DeleteDocumentInput) *ssm.DeleteDocumentOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.DeleteDocumentOutput)
		}
	}

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

	return r0, r1
}

// DeleteDocumentRequest provides a mock function with given fields: _a0
func (_m *SSMAPI) DeleteDocumentRequest(_a0 *ssm.DeleteDocumentInput) (*request.Request, *ssm.DeleteDocumentOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ssm.DeleteDocumentOutput
	if rf, ok := ret.Get(1).(func(*ssm.DeleteDocumentInput) *ssm.DeleteDocumentOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ssm.DeleteDocumentOutput)
		}
	}

	return r0, r1
}

// DeleteDocumentWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) DeleteDocumentWithContext(_a0 aws.Context, _a1 *ssm.DeleteDocumentInput, _a2 ...request.Option) (*ssm.DeleteDocumentOutput, 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 *ssm.DeleteDocumentOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ssm.DeleteDocumentInput, ...request.Option) *ssm.DeleteDocumentOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.DeleteDocumentOutput)
		}
	}

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

	return r0, r1
}

// DeleteInventory provides a mock function with given fields: _a0
func (_m *SSMAPI) DeleteInventory(_a0 *ssm.DeleteInventoryInput) (*ssm.DeleteInventoryOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ssm.DeleteInventoryOutput
	if rf, ok := ret.Get(0).(func(*ssm.DeleteInventoryInput) *ssm.DeleteInventoryOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.DeleteInventoryOutput)
		}
	}

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

	return r0, r1
}

// DeleteInventoryRequest provides a mock function with given fields: _a0
func (_m *SSMAPI) DeleteInventoryRequest(_a0 *ssm.DeleteInventoryInput) (*request.Request, *ssm.DeleteInventoryOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ssm.DeleteInventoryOutput
	if rf, ok := ret.Get(1).(func(*ssm.DeleteInventoryInput) *ssm.DeleteInventoryOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ssm.DeleteInventoryOutput)
		}
	}

	return r0, r1
}

// DeleteInventoryWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) DeleteInventoryWithContext(_a0 aws.Context, _a1 *ssm.DeleteInventoryInput, _a2 ...request.Option) (*ssm.DeleteInventoryOutput, 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 *ssm.DeleteInventoryOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ssm.DeleteInventoryInput, ...request.Option) *ssm.DeleteInventoryOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.DeleteInventoryOutput)
		}
	}

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

	return r0, r1
}

// DeleteMaintenanceWindow provides a mock function with given fields: _a0
func (_m *SSMAPI) DeleteMaintenanceWindow(_a0 *ssm.DeleteMaintenanceWindowInput) (*ssm.DeleteMaintenanceWindowOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ssm.DeleteMaintenanceWindowOutput
	if rf, ok := ret.Get(0).(func(*ssm.DeleteMaintenanceWindowInput) *ssm.DeleteMaintenanceWindowOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.DeleteMaintenanceWindowOutput)
		}
	}

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

	return r0, r1
}

// DeleteMaintenanceWindowRequest provides a mock function with given fields: _a0
func (_m *SSMAPI) DeleteMaintenanceWindowRequest(_a0 *ssm.DeleteMaintenanceWindowInput) (*request.Request, *ssm.DeleteMaintenanceWindowOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ssm.DeleteMaintenanceWindowOutput
	if rf, ok := ret.Get(1).(func(*ssm.DeleteMaintenanceWindowInput) *ssm.DeleteMaintenanceWindowOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ssm.DeleteMaintenanceWindowOutput)
		}
	}

	return r0, r1
}

// DeleteMaintenanceWindowWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) DeleteMaintenanceWindowWithContext(_a0 aws.Context, _a1 *ssm.DeleteMaintenanceWindowInput, _a2 ...request.Option) (*ssm.DeleteMaintenanceWindowOutput, 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 *ssm.DeleteMaintenanceWindowOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ssm.DeleteMaintenanceWindowInput, ...request.Option) *ssm.DeleteMaintenanceWindowOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.DeleteMaintenanceWindowOutput)
		}
	}

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

	return r0, r1
}

// DeleteParameter provides a mock function with given fields: _a0
func (_m *SSMAPI) DeleteParameter(_a0 *ssm.DeleteParameterInput) (*ssm.DeleteParameterOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ssm.DeleteParameterOutput
	if rf, ok := ret.Get(0).(func(*ssm.DeleteParameterInput) *ssm.DeleteParameterOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.DeleteParameterOutput)
		}
	}

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

	return r0, r1
}

// DeleteParameterRequest provides a mock function with given fields: _a0
func (_m *SSMAPI) DeleteParameterRequest(_a0 *ssm.DeleteParameterInput) (*request.Request, *ssm.DeleteParameterOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ssm.DeleteParameterOutput
	if rf, ok := ret.Get(1).(func(*ssm.DeleteParameterInput) *ssm.DeleteParameterOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ssm.DeleteParameterOutput)
		}
	}

	return r0, r1
}

// DeleteParameterWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) DeleteParameterWithContext(_a0 aws.Context, _a1 *ssm.DeleteParameterInput, _a2 ...request.Option) (*ssm.DeleteParameterOutput, 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 *ssm.DeleteParameterOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ssm.DeleteParameterInput, ...request.Option) *ssm.DeleteParameterOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.DeleteParameterOutput)
		}
	}

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

	return r0, r1
}

// DeleteParameters provides a mock function with given fields: _a0
func (_m *SSMAPI) DeleteParameters(_a0 *ssm.DeleteParametersInput) (*ssm.DeleteParametersOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ssm.DeleteParametersOutput
	if rf, ok := ret.Get(0).(func(*ssm.DeleteParametersInput) *ssm.DeleteParametersOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.DeleteParametersOutput)
		}
	}

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

	return r0, r1
}

// DeleteParametersRequest provides a mock function with given fields: _a0
func (_m *SSMAPI) DeleteParametersRequest(_a0 *ssm.DeleteParametersInput) (*request.Request, *ssm.DeleteParametersOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ssm.DeleteParametersOutput
	if rf, ok := ret.Get(1).(func(*ssm.DeleteParametersInput) *ssm.DeleteParametersOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ssm.DeleteParametersOutput)
		}
	}

	return r0, r1
}

// DeleteParametersWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) DeleteParametersWithContext(_a0 aws.Context, _a1 *ssm.DeleteParametersInput, _a2 ...request.Option) (*ssm.DeleteParametersOutput, 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 *ssm.DeleteParametersOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ssm.DeleteParametersInput, ...request.Option) *ssm.DeleteParametersOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.DeleteParametersOutput)
		}
	}

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

	return r0, r1
}

// DeletePatchBaseline provides a mock function with given fields: _a0
func (_m *SSMAPI) DeletePatchBaseline(_a0 *ssm.DeletePatchBaselineInput) (*ssm.DeletePatchBaselineOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ssm.DeletePatchBaselineOutput
	if rf, ok := ret.Get(0).(func(*ssm.DeletePatchBaselineInput) *ssm.DeletePatchBaselineOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.DeletePatchBaselineOutput)
		}
	}

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

	return r0, r1
}

// DeletePatchBaselineRequest provides a mock function with given fields: _a0
func (_m *SSMAPI) DeletePatchBaselineRequest(_a0 *ssm.DeletePatchBaselineInput) (*request.Request, *ssm.DeletePatchBaselineOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ssm.DeletePatchBaselineOutput
	if rf, ok := ret.Get(1).(func(*ssm.DeletePatchBaselineInput) *ssm.DeletePatchBaselineOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ssm.DeletePatchBaselineOutput)
		}
	}

	return r0, r1
}

// DeletePatchBaselineWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) DeletePatchBaselineWithContext(_a0 aws.Context, _a1 *ssm.DeletePatchBaselineInput, _a2 ...request.Option) (*ssm.DeletePatchBaselineOutput, 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 *ssm.DeletePatchBaselineOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ssm.DeletePatchBaselineInput, ...request.Option) *ssm.DeletePatchBaselineOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.DeletePatchBaselineOutput)
		}
	}

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

	return r0, r1
}

// DeleteResourceDataSync provides a mock function with given fields: _a0
func (_m *SSMAPI) DeleteResourceDataSync(_a0 *ssm.DeleteResourceDataSyncInput) (*ssm.DeleteResourceDataSyncOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ssm.DeleteResourceDataSyncOutput
	if rf, ok := ret.Get(0).(func(*ssm.DeleteResourceDataSyncInput) *ssm.DeleteResourceDataSyncOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.DeleteResourceDataSyncOutput)
		}
	}

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

	return r0, r1
}

// DeleteResourceDataSyncRequest provides a mock function with given fields: _a0
func (_m *SSMAPI) DeleteResourceDataSyncRequest(_a0 *ssm.DeleteResourceDataSyncInput) (*request.Request, *ssm.DeleteResourceDataSyncOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ssm.DeleteResourceDataSyncOutput
	if rf, ok := ret.Get(1).(func(*ssm.DeleteResourceDataSyncInput) *ssm.DeleteResourceDataSyncOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ssm.DeleteResourceDataSyncOutput)
		}
	}

	return r0, r1
}

// DeleteResourceDataSyncWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) DeleteResourceDataSyncWithContext(_a0 aws.Context, _a1 *ssm.DeleteResourceDataSyncInput, _a2 ...request.Option) (*ssm.DeleteResourceDataSyncOutput, 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 *ssm.DeleteResourceDataSyncOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ssm.DeleteResourceDataSyncInput, ...request.Option) *ssm.DeleteResourceDataSyncOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.DeleteResourceDataSyncOutput)
		}
	}

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

	return r0, r1
}

// DeregisterManagedInstance provides a mock function with given fields: _a0
func (_m *SSMAPI) DeregisterManagedInstance(_a0 *ssm.DeregisterManagedInstanceInput) (*ssm.DeregisterManagedInstanceOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ssm.DeregisterManagedInstanceOutput
	if rf, ok := ret.Get(0).(func(*ssm.DeregisterManagedInstanceInput) *ssm.DeregisterManagedInstanceOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.DeregisterManagedInstanceOutput)
		}
	}

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

	return r0, r1
}

// DeregisterManagedInstanceRequest provides a mock function with given fields: _a0
func (_m *SSMAPI) DeregisterManagedInstanceRequest(_a0 *ssm.DeregisterManagedInstanceInput) (*request.Request, *ssm.DeregisterManagedInstanceOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ssm.DeregisterManagedInstanceOutput
	if rf, ok := ret.Get(1).(func(*ssm.DeregisterManagedInstanceInput) *ssm.DeregisterManagedInstanceOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ssm.DeregisterManagedInstanceOutput)
		}
	}

	return r0, r1
}

// DeregisterManagedInstanceWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) DeregisterManagedInstanceWithContext(_a0 aws.Context, _a1 *ssm.DeregisterManagedInstanceInput, _a2 ...request.Option) (*ssm.DeregisterManagedInstanceOutput, 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 *ssm.DeregisterManagedInstanceOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ssm.DeregisterManagedInstanceInput, ...request.Option) *ssm.DeregisterManagedInstanceOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.DeregisterManagedInstanceOutput)
		}
	}

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

	return r0, r1
}

// DeregisterPatchBaselineForPatchGroup provides a mock function with given fields: _a0
func (_m *SSMAPI) DeregisterPatchBaselineForPatchGroup(_a0 *ssm.DeregisterPatchBaselineForPatchGroupInput) (*ssm.DeregisterPatchBaselineForPatchGroupOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ssm.DeregisterPatchBaselineForPatchGroupOutput
	if rf, ok := ret.Get(0).(func(*ssm.DeregisterPatchBaselineForPatchGroupInput) *ssm.DeregisterPatchBaselineForPatchGroupOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.DeregisterPatchBaselineForPatchGroupOutput)
		}
	}

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

	return r0, r1
}

// DeregisterPatchBaselineForPatchGroupRequest provides a mock function with given fields: _a0
func (_m *SSMAPI) DeregisterPatchBaselineForPatchGroupRequest(_a0 *ssm.DeregisterPatchBaselineForPatchGroupInput) (*request.Request, *ssm.DeregisterPatchBaselineForPatchGroupOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ssm.DeregisterPatchBaselineForPatchGroupOutput
	if rf, ok := ret.Get(1).(func(*ssm.DeregisterPatchBaselineForPatchGroupInput) *ssm.DeregisterPatchBaselineForPatchGroupOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ssm.DeregisterPatchBaselineForPatchGroupOutput)
		}
	}

	return r0, r1
}

// DeregisterPatchBaselineForPatchGroupWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) DeregisterPatchBaselineForPatchGroupWithContext(_a0 aws.Context, _a1 *ssm.DeregisterPatchBaselineForPatchGroupInput, _a2 ...request.Option) (*ssm.DeregisterPatchBaselineForPatchGroupOutput, 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 *ssm.DeregisterPatchBaselineForPatchGroupOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ssm.DeregisterPatchBaselineForPatchGroupInput, ...request.Option) *ssm.DeregisterPatchBaselineForPatchGroupOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.DeregisterPatchBaselineForPatchGroupOutput)
		}
	}

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

	return r0, r1
}

// DeregisterTargetFromMaintenanceWindow provides a mock function with given fields: _a0
func (_m *SSMAPI) DeregisterTargetFromMaintenanceWindow(_a0 *ssm.DeregisterTargetFromMaintenanceWindowInput) (*ssm.DeregisterTargetFromMaintenanceWindowOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ssm.DeregisterTargetFromMaintenanceWindowOutput
	if rf, ok := ret.Get(0).(func(*ssm.DeregisterTargetFromMaintenanceWindowInput) *ssm.DeregisterTargetFromMaintenanceWindowOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.DeregisterTargetFromMaintenanceWindowOutput)
		}
	}

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

	return r0, r1
}

// DeregisterTargetFromMaintenanceWindowRequest provides a mock function with given fields: _a0
func (_m *SSMAPI) DeregisterTargetFromMaintenanceWindowRequest(_a0 *ssm.DeregisterTargetFromMaintenanceWindowInput) (*request.Request, *ssm.DeregisterTargetFromMaintenanceWindowOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ssm.DeregisterTargetFromMaintenanceWindowOutput
	if rf, ok := ret.Get(1).(func(*ssm.DeregisterTargetFromMaintenanceWindowInput) *ssm.DeregisterTargetFromMaintenanceWindowOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ssm.DeregisterTargetFromMaintenanceWindowOutput)
		}
	}

	return r0, r1
}

// DeregisterTargetFromMaintenanceWindowWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) DeregisterTargetFromMaintenanceWindowWithContext(_a0 aws.Context, _a1 *ssm.DeregisterTargetFromMaintenanceWindowInput, _a2 ...request.Option) (*ssm.DeregisterTargetFromMaintenanceWindowOutput, 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 *ssm.DeregisterTargetFromMaintenanceWindowOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ssm.DeregisterTargetFromMaintenanceWindowInput, ...request.Option) *ssm.DeregisterTargetFromMaintenanceWindowOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.DeregisterTargetFromMaintenanceWindowOutput)
		}
	}

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

	return r0, r1
}

// DeregisterTaskFromMaintenanceWindow provides a mock function with given fields: _a0
func (_m *SSMAPI) DeregisterTaskFromMaintenanceWindow(_a0 *ssm.DeregisterTaskFromMaintenanceWindowInput) (*ssm.DeregisterTaskFromMaintenanceWindowOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ssm.DeregisterTaskFromMaintenanceWindowOutput
	if rf, ok := ret.Get(0).(func(*ssm.DeregisterTaskFromMaintenanceWindowInput) *ssm.DeregisterTaskFromMaintenanceWindowOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.DeregisterTaskFromMaintenanceWindowOutput)
		}
	}

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

	return r0, r1
}

// DeregisterTaskFromMaintenanceWindowRequest provides a mock function with given fields: _a0
func (_m *SSMAPI) DeregisterTaskFromMaintenanceWindowRequest(_a0 *ssm.DeregisterTaskFromMaintenanceWindowInput) (*request.Request, *ssm.DeregisterTaskFromMaintenanceWindowOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ssm.DeregisterTaskFromMaintenanceWindowOutput
	if rf, ok := ret.Get(1).(func(*ssm.DeregisterTaskFromMaintenanceWindowInput) *ssm.DeregisterTaskFromMaintenanceWindowOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ssm.DeregisterTaskFromMaintenanceWindowOutput)
		}
	}

	return r0, r1
}

// DeregisterTaskFromMaintenanceWindowWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) DeregisterTaskFromMaintenanceWindowWithContext(_a0 aws.Context, _a1 *ssm.DeregisterTaskFromMaintenanceWindowInput, _a2 ...request.Option) (*ssm.DeregisterTaskFromMaintenanceWindowOutput, 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 *ssm.DeregisterTaskFromMaintenanceWindowOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ssm.DeregisterTaskFromMaintenanceWindowInput, ...request.Option) *ssm.DeregisterTaskFromMaintenanceWindowOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.DeregisterTaskFromMaintenanceWindowOutput)
		}
	}

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

	return r0, r1
}

// DescribeActivations provides a mock function with given fields: _a0
func (_m *SSMAPI) DescribeActivations(_a0 *ssm.DescribeActivationsInput) (*ssm.DescribeActivationsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ssm.DescribeActivationsOutput
	if rf, ok := ret.Get(0).(func(*ssm.DescribeActivationsInput) *ssm.DescribeActivationsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.DescribeActivationsOutput)
		}
	}

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

	return r0, r1
}

// DescribeActivationsPages provides a mock function with given fields: _a0, _a1
func (_m *SSMAPI) DescribeActivationsPages(_a0 *ssm.DescribeActivationsInput, _a1 func(*ssm.DescribeActivationsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*ssm.DescribeActivationsInput, func(*ssm.DescribeActivationsOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeActivationsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *SSMAPI) DescribeActivationsPagesWithContext(_a0 aws.Context, _a1 *ssm.DescribeActivationsInput, _a2 func(*ssm.DescribeActivationsOutput, 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(aws.Context, *ssm.DescribeActivationsInput, func(*ssm.DescribeActivationsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeActivationsRequest provides a mock function with given fields: _a0
func (_m *SSMAPI) DescribeActivationsRequest(_a0 *ssm.DescribeActivationsInput) (*request.Request, *ssm.DescribeActivationsOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ssm.DescribeActivationsOutput
	if rf, ok := ret.Get(1).(func(*ssm.DescribeActivationsInput) *ssm.DescribeActivationsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ssm.DescribeActivationsOutput)
		}
	}

	return r0, r1
}

// DescribeActivationsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) DescribeActivationsWithContext(_a0 aws.Context, _a1 *ssm.DescribeActivationsInput, _a2 ...request.Option) (*ssm.DescribeActivationsOutput, 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 *ssm.DescribeActivationsOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ssm.DescribeActivationsInput, ...request.Option) *ssm.DescribeActivationsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.DescribeActivationsOutput)
		}
	}

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

	return r0, r1
}

// DescribeAssociation provides a mock function with given fields: _a0
func (_m *SSMAPI) DescribeAssociation(_a0 *ssm.DescribeAssociationInput) (*ssm.DescribeAssociationOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ssm.DescribeAssociationOutput
	if rf, ok := ret.Get(0).(func(*ssm.DescribeAssociationInput) *ssm.DescribeAssociationOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.DescribeAssociationOutput)
		}
	}

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

	return r0, r1
}

// DescribeAssociationRequest provides a mock function with given fields: _a0
func (_m *SSMAPI) DescribeAssociationRequest(_a0 *ssm.DescribeAssociationInput) (*request.Request, *ssm.DescribeAssociationOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ssm.DescribeAssociationOutput
	if rf, ok := ret.Get(1).(func(*ssm.DescribeAssociationInput) *ssm.DescribeAssociationOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ssm.DescribeAssociationOutput)
		}
	}

	return r0, r1
}

// DescribeAssociationWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) DescribeAssociationWithContext(_a0 aws.Context, _a1 *ssm.DescribeAssociationInput, _a2 ...request.Option) (*ssm.DescribeAssociationOutput, 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 *ssm.DescribeAssociationOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ssm.DescribeAssociationInput, ...request.Option) *ssm.DescribeAssociationOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.DescribeAssociationOutput)
		}
	}

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

	return r0, r1
}

// DescribeAutomationExecutions provides a mock function with given fields: _a0
func (_m *SSMAPI) DescribeAutomationExecutions(_a0 *ssm.DescribeAutomationExecutionsInput) (*ssm.DescribeAutomationExecutionsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ssm.DescribeAutomationExecutionsOutput
	if rf, ok := ret.Get(0).(func(*ssm.DescribeAutomationExecutionsInput) *ssm.DescribeAutomationExecutionsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.DescribeAutomationExecutionsOutput)
		}
	}

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

	return r0, r1
}

// DescribeAutomationExecutionsRequest provides a mock function with given fields: _a0
func (_m *SSMAPI) DescribeAutomationExecutionsRequest(_a0 *ssm.DescribeAutomationExecutionsInput) (*request.Request, *ssm.DescribeAutomationExecutionsOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ssm.DescribeAutomationExecutionsOutput
	if rf, ok := ret.Get(1).(func(*ssm.DescribeAutomationExecutionsInput) *ssm.DescribeAutomationExecutionsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ssm.DescribeAutomationExecutionsOutput)
		}
	}

	return r0, r1
}

// DescribeAutomationExecutionsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) DescribeAutomationExecutionsWithContext(_a0 aws.Context, _a1 *ssm.DescribeAutomationExecutionsInput, _a2 ...request.Option) (*ssm.DescribeAutomationExecutionsOutput, 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 *ssm.DescribeAutomationExecutionsOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ssm.DescribeAutomationExecutionsInput, ...request.Option) *ssm.DescribeAutomationExecutionsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.DescribeAutomationExecutionsOutput)
		}
	}

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

	return r0, r1
}

// DescribeAutomationStepExecutions provides a mock function with given fields: _a0
func (_m *SSMAPI) DescribeAutomationStepExecutions(_a0 *ssm.DescribeAutomationStepExecutionsInput) (*ssm.DescribeAutomationStepExecutionsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ssm.DescribeAutomationStepExecutionsOutput
	if rf, ok := ret.Get(0).(func(*ssm.DescribeAutomationStepExecutionsInput) *ssm.DescribeAutomationStepExecutionsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.DescribeAutomationStepExecutionsOutput)
		}
	}

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

	return r0, r1
}

// DescribeAutomationStepExecutionsRequest provides a mock function with given fields: _a0
func (_m *SSMAPI) DescribeAutomationStepExecutionsRequest(_a0 *ssm.DescribeAutomationStepExecutionsInput) (*request.Request, *ssm.DescribeAutomationStepExecutionsOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ssm.DescribeAutomationStepExecutionsOutput
	if rf, ok := ret.Get(1).(func(*ssm.DescribeAutomationStepExecutionsInput) *ssm.DescribeAutomationStepExecutionsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ssm.DescribeAutomationStepExecutionsOutput)
		}
	}

	return r0, r1
}

// DescribeAutomationStepExecutionsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) DescribeAutomationStepExecutionsWithContext(_a0 aws.Context, _a1 *ssm.DescribeAutomationStepExecutionsInput, _a2 ...request.Option) (*ssm.DescribeAutomationStepExecutionsOutput, 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 *ssm.DescribeAutomationStepExecutionsOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ssm.DescribeAutomationStepExecutionsInput, ...request.Option) *ssm.DescribeAutomationStepExecutionsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.DescribeAutomationStepExecutionsOutput)
		}
	}

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

	return r0, r1
}

// DescribeAvailablePatches provides a mock function with given fields: _a0
func (_m *SSMAPI) DescribeAvailablePatches(_a0 *ssm.DescribeAvailablePatchesInput) (*ssm.DescribeAvailablePatchesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ssm.DescribeAvailablePatchesOutput
	if rf, ok := ret.Get(0).(func(*ssm.DescribeAvailablePatchesInput) *ssm.DescribeAvailablePatchesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.DescribeAvailablePatchesOutput)
		}
	}

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

	return r0, r1
}

// DescribeAvailablePatchesRequest provides a mock function with given fields: _a0
func (_m *SSMAPI) DescribeAvailablePatchesRequest(_a0 *ssm.DescribeAvailablePatchesInput) (*request.Request, *ssm.DescribeAvailablePatchesOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ssm.DescribeAvailablePatchesOutput
	if rf, ok := ret.Get(1).(func(*ssm.DescribeAvailablePatchesInput) *ssm.DescribeAvailablePatchesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ssm.DescribeAvailablePatchesOutput)
		}
	}

	return r0, r1
}

// DescribeAvailablePatchesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) DescribeAvailablePatchesWithContext(_a0 aws.Context, _a1 *ssm.DescribeAvailablePatchesInput, _a2 ...request.Option) (*ssm.DescribeAvailablePatchesOutput, 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 *ssm.DescribeAvailablePatchesOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ssm.DescribeAvailablePatchesInput, ...request.Option) *ssm.DescribeAvailablePatchesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.DescribeAvailablePatchesOutput)
		}
	}

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

	return r0, r1
}

// DescribeDocument provides a mock function with given fields: _a0
func (_m *SSMAPI) DescribeDocument(_a0 *ssm.DescribeDocumentInput) (*ssm.DescribeDocumentOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ssm.DescribeDocumentOutput
	if rf, ok := ret.Get(0).(func(*ssm.DescribeDocumentInput) *ssm.DescribeDocumentOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.DescribeDocumentOutput)
		}
	}

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

	return r0, r1
}

// DescribeDocumentPermission provides a mock function with given fields: _a0
func (_m *SSMAPI) DescribeDocumentPermission(_a0 *ssm.DescribeDocumentPermissionInput) (*ssm.DescribeDocumentPermissionOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ssm.DescribeDocumentPermissionOutput
	if rf, ok := ret.Get(0).(func(*ssm.DescribeDocumentPermissionInput) *ssm.DescribeDocumentPermissionOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.DescribeDocumentPermissionOutput)
		}
	}

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

	return r0, r1
}

// DescribeDocumentPermissionRequest provides a mock function with given fields: _a0
func (_m *SSMAPI) DescribeDocumentPermissionRequest(_a0 *ssm.DescribeDocumentPermissionInput) (*request.Request, *ssm.DescribeDocumentPermissionOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ssm.DescribeDocumentPermissionOutput
	if rf, ok := ret.Get(1).(func(*ssm.DescribeDocumentPermissionInput) *ssm.DescribeDocumentPermissionOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ssm.DescribeDocumentPermissionOutput)
		}
	}

	return r0, r1
}

// DescribeDocumentPermissionWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) DescribeDocumentPermissionWithContext(_a0 aws.Context, _a1 *ssm.DescribeDocumentPermissionInput, _a2 ...request.Option) (*ssm.DescribeDocumentPermissionOutput, 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 *ssm.DescribeDocumentPermissionOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ssm.DescribeDocumentPermissionInput, ...request.Option) *ssm.DescribeDocumentPermissionOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.DescribeDocumentPermissionOutput)
		}
	}

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

	return r0, r1
}

// DescribeDocumentRequest provides a mock function with given fields: _a0
func (_m *SSMAPI) DescribeDocumentRequest(_a0 *ssm.DescribeDocumentInput) (*request.Request, *ssm.DescribeDocumentOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ssm.DescribeDocumentOutput
	if rf, ok := ret.Get(1).(func(*ssm.DescribeDocumentInput) *ssm.DescribeDocumentOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ssm.DescribeDocumentOutput)
		}
	}

	return r0, r1
}

// DescribeDocumentWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) DescribeDocumentWithContext(_a0 aws.Context, _a1 *ssm.DescribeDocumentInput, _a2 ...request.Option) (*ssm.DescribeDocumentOutput, 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 *ssm.DescribeDocumentOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ssm.DescribeDocumentInput, ...request.Option) *ssm.DescribeDocumentOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.DescribeDocumentOutput)
		}
	}

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

	return r0, r1
}

// DescribeEffectiveInstanceAssociations provides a mock function with given fields: _a0
func (_m *SSMAPI) DescribeEffectiveInstanceAssociations(_a0 *ssm.DescribeEffectiveInstanceAssociationsInput) (*ssm.DescribeEffectiveInstanceAssociationsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ssm.DescribeEffectiveInstanceAssociationsOutput
	if rf, ok := ret.Get(0).(func(*ssm.DescribeEffectiveInstanceAssociationsInput) *ssm.DescribeEffectiveInstanceAssociationsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.DescribeEffectiveInstanceAssociationsOutput)
		}
	}

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

	return r0, r1
}

// DescribeEffectiveInstanceAssociationsRequest provides a mock function with given fields: _a0
func (_m *SSMAPI) DescribeEffectiveInstanceAssociationsRequest(_a0 *ssm.DescribeEffectiveInstanceAssociationsInput) (*request.Request, *ssm.DescribeEffectiveInstanceAssociationsOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ssm.DescribeEffectiveInstanceAssociationsOutput
	if rf, ok := ret.Get(1).(func(*ssm.DescribeEffectiveInstanceAssociationsInput) *ssm.DescribeEffectiveInstanceAssociationsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ssm.DescribeEffectiveInstanceAssociationsOutput)
		}
	}

	return r0, r1
}

// DescribeEffectiveInstanceAssociationsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) DescribeEffectiveInstanceAssociationsWithContext(_a0 aws.Context, _a1 *ssm.DescribeEffectiveInstanceAssociationsInput, _a2 ...request.Option) (*ssm.DescribeEffectiveInstanceAssociationsOutput, 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 *ssm.DescribeEffectiveInstanceAssociationsOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ssm.DescribeEffectiveInstanceAssociationsInput, ...request.Option) *ssm.DescribeEffectiveInstanceAssociationsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.DescribeEffectiveInstanceAssociationsOutput)
		}
	}

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

	return r0, r1
}

// DescribeEffectivePatchesForPatchBaseline provides a mock function with given fields: _a0
func (_m *SSMAPI) DescribeEffectivePatchesForPatchBaseline(_a0 *ssm.DescribeEffectivePatchesForPatchBaselineInput) (*ssm.DescribeEffectivePatchesForPatchBaselineOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ssm.DescribeEffectivePatchesForPatchBaselineOutput
	if rf, ok := ret.Get(0).(func(*ssm.DescribeEffectivePatchesForPatchBaselineInput) *ssm.DescribeEffectivePatchesForPatchBaselineOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.DescribeEffectivePatchesForPatchBaselineOutput)
		}
	}

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

	return r0, r1
}

// DescribeEffectivePatchesForPatchBaselineRequest provides a mock function with given fields: _a0
func (_m *SSMAPI) DescribeEffectivePatchesForPatchBaselineRequest(_a0 *ssm.DescribeEffectivePatchesForPatchBaselineInput) (*request.Request, *ssm.DescribeEffectivePatchesForPatchBaselineOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ssm.DescribeEffectivePatchesForPatchBaselineOutput
	if rf, ok := ret.Get(1).(func(*ssm.DescribeEffectivePatchesForPatchBaselineInput) *ssm.DescribeEffectivePatchesForPatchBaselineOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ssm.DescribeEffectivePatchesForPatchBaselineOutput)
		}
	}

	return r0, r1
}

// DescribeEffectivePatchesForPatchBaselineWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) DescribeEffectivePatchesForPatchBaselineWithContext(_a0 aws.Context, _a1 *ssm.DescribeEffectivePatchesForPatchBaselineInput, _a2 ...request.Option) (*ssm.DescribeEffectivePatchesForPatchBaselineOutput, 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 *ssm.DescribeEffectivePatchesForPatchBaselineOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ssm.DescribeEffectivePatchesForPatchBaselineInput, ...request.Option) *ssm.DescribeEffectivePatchesForPatchBaselineOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.DescribeEffectivePatchesForPatchBaselineOutput)
		}
	}

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

	return r0, r1
}

// DescribeInstanceAssociationsStatus provides a mock function with given fields: _a0
func (_m *SSMAPI) DescribeInstanceAssociationsStatus(_a0 *ssm.DescribeInstanceAssociationsStatusInput) (*ssm.DescribeInstanceAssociationsStatusOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ssm.DescribeInstanceAssociationsStatusOutput
	if rf, ok := ret.Get(0).(func(*ssm.DescribeInstanceAssociationsStatusInput) *ssm.DescribeInstanceAssociationsStatusOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.DescribeInstanceAssociationsStatusOutput)
		}
	}

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

	return r0, r1
}

// DescribeInstanceAssociationsStatusRequest provides a mock function with given fields: _a0
func (_m *SSMAPI) DescribeInstanceAssociationsStatusRequest(_a0 *ssm.DescribeInstanceAssociationsStatusInput) (*request.Request, *ssm.DescribeInstanceAssociationsStatusOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ssm.DescribeInstanceAssociationsStatusOutput
	if rf, ok := ret.Get(1).(func(*ssm.DescribeInstanceAssociationsStatusInput) *ssm.DescribeInstanceAssociationsStatusOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ssm.DescribeInstanceAssociationsStatusOutput)
		}
	}

	return r0, r1
}

// DescribeInstanceAssociationsStatusWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) DescribeInstanceAssociationsStatusWithContext(_a0 aws.Context, _a1 *ssm.DescribeInstanceAssociationsStatusInput, _a2 ...request.Option) (*ssm.DescribeInstanceAssociationsStatusOutput, 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 *ssm.DescribeInstanceAssociationsStatusOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ssm.DescribeInstanceAssociationsStatusInput, ...request.Option) *ssm.DescribeInstanceAssociationsStatusOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.DescribeInstanceAssociationsStatusOutput)
		}
	}

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

	return r0, r1
}

// DescribeInstanceInformation provides a mock function with given fields: _a0
func (_m *SSMAPI) DescribeInstanceInformation(_a0 *ssm.DescribeInstanceInformationInput) (*ssm.DescribeInstanceInformationOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ssm.DescribeInstanceInformationOutput
	if rf, ok := ret.Get(0).(func(*ssm.DescribeInstanceInformationInput) *ssm.DescribeInstanceInformationOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.DescribeInstanceInformationOutput)
		}
	}

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

	return r0, r1
}

// DescribeInstanceInformationPages provides a mock function with given fields: _a0, _a1
func (_m *SSMAPI) DescribeInstanceInformationPages(_a0 *ssm.DescribeInstanceInformationInput, _a1 func(*ssm.DescribeInstanceInformationOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*ssm.DescribeInstanceInformationInput, func(*ssm.DescribeInstanceInformationOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeInstanceInformationPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *SSMAPI) DescribeInstanceInformationPagesWithContext(_a0 aws.Context, _a1 *ssm.DescribeInstanceInformationInput, _a2 func(*ssm.DescribeInstanceInformationOutput, 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(aws.Context, *ssm.DescribeInstanceInformationInput, func(*ssm.DescribeInstanceInformationOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeInstanceInformationRequest provides a mock function with given fields: _a0
func (_m *SSMAPI) DescribeInstanceInformationRequest(_a0 *ssm.DescribeInstanceInformationInput) (*request.Request, *ssm.DescribeInstanceInformationOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ssm.DescribeInstanceInformationOutput
	if rf, ok := ret.Get(1).(func(*ssm.DescribeInstanceInformationInput) *ssm.DescribeInstanceInformationOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ssm.DescribeInstanceInformationOutput)
		}
	}

	return r0, r1
}

// DescribeInstanceInformationWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) DescribeInstanceInformationWithContext(_a0 aws.Context, _a1 *ssm.DescribeInstanceInformationInput, _a2 ...request.Option) (*ssm.DescribeInstanceInformationOutput, 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 *ssm.DescribeInstanceInformationOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ssm.DescribeInstanceInformationInput, ...request.Option) *ssm.DescribeInstanceInformationOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.DescribeInstanceInformationOutput)
		}
	}

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

	return r0, r1
}

// DescribeInstancePatchStates provides a mock function with given fields: _a0
func (_m *SSMAPI) DescribeInstancePatchStates(_a0 *ssm.DescribeInstancePatchStatesInput) (*ssm.DescribeInstancePatchStatesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ssm.DescribeInstancePatchStatesOutput
	if rf, ok := ret.Get(0).(func(*ssm.DescribeInstancePatchStatesInput) *ssm.DescribeInstancePatchStatesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.DescribeInstancePatchStatesOutput)
		}
	}

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

	return r0, r1
}

// DescribeInstancePatchStatesForPatchGroup provides a mock function with given fields: _a0
func (_m *SSMAPI) DescribeInstancePatchStatesForPatchGroup(_a0 *ssm.DescribeInstancePatchStatesForPatchGroupInput) (*ssm.DescribeInstancePatchStatesForPatchGroupOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ssm.DescribeInstancePatchStatesForPatchGroupOutput
	if rf, ok := ret.Get(0).(func(*ssm.DescribeInstancePatchStatesForPatchGroupInput) *ssm.DescribeInstancePatchStatesForPatchGroupOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.DescribeInstancePatchStatesForPatchGroupOutput)
		}
	}

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

	return r0, r1
}

// DescribeInstancePatchStatesForPatchGroupRequest provides a mock function with given fields: _a0
func (_m *SSMAPI) DescribeInstancePatchStatesForPatchGroupRequest(_a0 *ssm.DescribeInstancePatchStatesForPatchGroupInput) (*request.Request, *ssm.DescribeInstancePatchStatesForPatchGroupOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ssm.DescribeInstancePatchStatesForPatchGroupOutput
	if rf, ok := ret.Get(1).(func(*ssm.DescribeInstancePatchStatesForPatchGroupInput) *ssm.DescribeInstancePatchStatesForPatchGroupOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ssm.DescribeInstancePatchStatesForPatchGroupOutput)
		}
	}

	return r0, r1
}

// DescribeInstancePatchStatesForPatchGroupWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) DescribeInstancePatchStatesForPatchGroupWithContext(_a0 aws.Context, _a1 *ssm.DescribeInstancePatchStatesForPatchGroupInput, _a2 ...request.Option) (*ssm.DescribeInstancePatchStatesForPatchGroupOutput, 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 *ssm.DescribeInstancePatchStatesForPatchGroupOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ssm.DescribeInstancePatchStatesForPatchGroupInput, ...request.Option) *ssm.DescribeInstancePatchStatesForPatchGroupOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.DescribeInstancePatchStatesForPatchGroupOutput)
		}
	}

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

	return r0, r1
}

// DescribeInstancePatchStatesRequest provides a mock function with given fields: _a0
func (_m *SSMAPI) DescribeInstancePatchStatesRequest(_a0 *ssm.DescribeInstancePatchStatesInput) (*request.Request, *ssm.DescribeInstancePatchStatesOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ssm.DescribeInstancePatchStatesOutput
	if rf, ok := ret.Get(1).(func(*ssm.DescribeInstancePatchStatesInput) *ssm.DescribeInstancePatchStatesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ssm.DescribeInstancePatchStatesOutput)
		}
	}

	return r0, r1
}

// DescribeInstancePatchStatesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) DescribeInstancePatchStatesWithContext(_a0 aws.Context, _a1 *ssm.DescribeInstancePatchStatesInput, _a2 ...request.Option) (*ssm.DescribeInstancePatchStatesOutput, 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 *ssm.DescribeInstancePatchStatesOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ssm.DescribeInstancePatchStatesInput, ...request.Option) *ssm.DescribeInstancePatchStatesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.DescribeInstancePatchStatesOutput)
		}
	}

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

	return r0, r1
}

// DescribeInstancePatches provides a mock function with given fields: _a0
func (_m *SSMAPI) DescribeInstancePatches(_a0 *ssm.DescribeInstancePatchesInput) (*ssm.DescribeInstancePatchesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ssm.DescribeInstancePatchesOutput
	if rf, ok := ret.Get(0).(func(*ssm.DescribeInstancePatchesInput) *ssm.DescribeInstancePatchesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.DescribeInstancePatchesOutput)
		}
	}

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

	return r0, r1
}

// DescribeInstancePatchesRequest provides a mock function with given fields: _a0
func (_m *SSMAPI) DescribeInstancePatchesRequest(_a0 *ssm.DescribeInstancePatchesInput) (*request.Request, *ssm.DescribeInstancePatchesOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ssm.DescribeInstancePatchesOutput
	if rf, ok := ret.Get(1).(func(*ssm.DescribeInstancePatchesInput) *ssm.DescribeInstancePatchesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ssm.DescribeInstancePatchesOutput)
		}
	}

	return r0, r1
}

// DescribeInstancePatchesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) DescribeInstancePatchesWithContext(_a0 aws.Context, _a1 *ssm.DescribeInstancePatchesInput, _a2 ...request.Option) (*ssm.DescribeInstancePatchesOutput, 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 *ssm.DescribeInstancePatchesOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ssm.DescribeInstancePatchesInput, ...request.Option) *ssm.DescribeInstancePatchesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.DescribeInstancePatchesOutput)
		}
	}

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

	return r0, r1
}

// DescribeInventoryDeletions provides a mock function with given fields: _a0
func (_m *SSMAPI) DescribeInventoryDeletions(_a0 *ssm.DescribeInventoryDeletionsInput) (*ssm.DescribeInventoryDeletionsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ssm.DescribeInventoryDeletionsOutput
	if rf, ok := ret.Get(0).(func(*ssm.DescribeInventoryDeletionsInput) *ssm.DescribeInventoryDeletionsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.DescribeInventoryDeletionsOutput)
		}
	}

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

	return r0, r1
}

// DescribeInventoryDeletionsRequest provides a mock function with given fields: _a0
func (_m *SSMAPI) DescribeInventoryDeletionsRequest(_a0 *ssm.DescribeInventoryDeletionsInput) (*request.Request, *ssm.DescribeInventoryDeletionsOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ssm.DescribeInventoryDeletionsOutput
	if rf, ok := ret.Get(1).(func(*ssm.DescribeInventoryDeletionsInput) *ssm.DescribeInventoryDeletionsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ssm.DescribeInventoryDeletionsOutput)
		}
	}

	return r0, r1
}

// DescribeInventoryDeletionsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) DescribeInventoryDeletionsWithContext(_a0 aws.Context, _a1 *ssm.DescribeInventoryDeletionsInput, _a2 ...request.Option) (*ssm.DescribeInventoryDeletionsOutput, 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 *ssm.DescribeInventoryDeletionsOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ssm.DescribeInventoryDeletionsInput, ...request.Option) *ssm.DescribeInventoryDeletionsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.DescribeInventoryDeletionsOutput)
		}
	}

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

	return r0, r1
}

// DescribeMaintenanceWindowExecutionTaskInvocations provides a mock function with given fields: _a0
func (_m *SSMAPI) DescribeMaintenanceWindowExecutionTaskInvocations(_a0 *ssm.DescribeMaintenanceWindowExecutionTaskInvocationsInput) (*ssm.DescribeMaintenanceWindowExecutionTaskInvocationsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ssm.DescribeMaintenanceWindowExecutionTaskInvocationsOutput
	if rf, ok := ret.Get(0).(func(*ssm.DescribeMaintenanceWindowExecutionTaskInvocationsInput) *ssm.DescribeMaintenanceWindowExecutionTaskInvocationsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.DescribeMaintenanceWindowExecutionTaskInvocationsOutput)
		}
	}

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

	return r0, r1
}

// DescribeMaintenanceWindowExecutionTaskInvocationsRequest provides a mock function with given fields: _a0
func (_m *SSMAPI) DescribeMaintenanceWindowExecutionTaskInvocationsRequest(_a0 *ssm.DescribeMaintenanceWindowExecutionTaskInvocationsInput) (*request.Request, *ssm.DescribeMaintenanceWindowExecutionTaskInvocationsOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ssm.DescribeMaintenanceWindowExecutionTaskInvocationsOutput
	if rf, ok := ret.Get(1).(func(*ssm.DescribeMaintenanceWindowExecutionTaskInvocationsInput) *ssm.DescribeMaintenanceWindowExecutionTaskInvocationsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ssm.DescribeMaintenanceWindowExecutionTaskInvocationsOutput)
		}
	}

	return r0, r1
}

// DescribeMaintenanceWindowExecutionTaskInvocationsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) DescribeMaintenanceWindowExecutionTaskInvocationsWithContext(_a0 aws.Context, _a1 *ssm.DescribeMaintenanceWindowExecutionTaskInvocationsInput, _a2 ...request.Option) (*ssm.DescribeMaintenanceWindowExecutionTaskInvocationsOutput, 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 *ssm.DescribeMaintenanceWindowExecutionTaskInvocationsOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ssm.DescribeMaintenanceWindowExecutionTaskInvocationsInput, ...request.Option) *ssm.DescribeMaintenanceWindowExecutionTaskInvocationsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.DescribeMaintenanceWindowExecutionTaskInvocationsOutput)
		}
	}

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

	return r0, r1
}

// DescribeMaintenanceWindowExecutionTasks provides a mock function with given fields: _a0
func (_m *SSMAPI) DescribeMaintenanceWindowExecutionTasks(_a0 *ssm.DescribeMaintenanceWindowExecutionTasksInput) (*ssm.DescribeMaintenanceWindowExecutionTasksOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ssm.DescribeMaintenanceWindowExecutionTasksOutput
	if rf, ok := ret.Get(0).(func(*ssm.DescribeMaintenanceWindowExecutionTasksInput) *ssm.DescribeMaintenanceWindowExecutionTasksOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.DescribeMaintenanceWindowExecutionTasksOutput)
		}
	}

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

	return r0, r1
}

// DescribeMaintenanceWindowExecutionTasksRequest provides a mock function with given fields: _a0
func (_m *SSMAPI) DescribeMaintenanceWindowExecutionTasksRequest(_a0 *ssm.DescribeMaintenanceWindowExecutionTasksInput) (*request.Request, *ssm.DescribeMaintenanceWindowExecutionTasksOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ssm.DescribeMaintenanceWindowExecutionTasksOutput
	if rf, ok := ret.Get(1).(func(*ssm.DescribeMaintenanceWindowExecutionTasksInput) *ssm.DescribeMaintenanceWindowExecutionTasksOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ssm.DescribeMaintenanceWindowExecutionTasksOutput)
		}
	}

	return r0, r1
}

// DescribeMaintenanceWindowExecutionTasksWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) DescribeMaintenanceWindowExecutionTasksWithContext(_a0 aws.Context, _a1 *ssm.DescribeMaintenanceWindowExecutionTasksInput, _a2 ...request.Option) (*ssm.DescribeMaintenanceWindowExecutionTasksOutput, 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 *ssm.DescribeMaintenanceWindowExecutionTasksOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ssm.DescribeMaintenanceWindowExecutionTasksInput, ...request.Option) *ssm.DescribeMaintenanceWindowExecutionTasksOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.DescribeMaintenanceWindowExecutionTasksOutput)
		}
	}

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

	return r0, r1
}

// DescribeMaintenanceWindowExecutions provides a mock function with given fields: _a0
func (_m *SSMAPI) DescribeMaintenanceWindowExecutions(_a0 *ssm.DescribeMaintenanceWindowExecutionsInput) (*ssm.DescribeMaintenanceWindowExecutionsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ssm.DescribeMaintenanceWindowExecutionsOutput
	if rf, ok := ret.Get(0).(func(*ssm.DescribeMaintenanceWindowExecutionsInput) *ssm.DescribeMaintenanceWindowExecutionsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.DescribeMaintenanceWindowExecutionsOutput)
		}
	}

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

	return r0, r1
}

// DescribeMaintenanceWindowExecutionsRequest provides a mock function with given fields: _a0
func (_m *SSMAPI) DescribeMaintenanceWindowExecutionsRequest(_a0 *ssm.DescribeMaintenanceWindowExecutionsInput) (*request.Request, *ssm.DescribeMaintenanceWindowExecutionsOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ssm.DescribeMaintenanceWindowExecutionsOutput
	if rf, ok := ret.Get(1).(func(*ssm.DescribeMaintenanceWindowExecutionsInput) *ssm.DescribeMaintenanceWindowExecutionsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ssm.DescribeMaintenanceWindowExecutionsOutput)
		}
	}

	return r0, r1
}

// DescribeMaintenanceWindowExecutionsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) DescribeMaintenanceWindowExecutionsWithContext(_a0 aws.Context, _a1 *ssm.DescribeMaintenanceWindowExecutionsInput, _a2 ...request.Option) (*ssm.DescribeMaintenanceWindowExecutionsOutput, 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 *ssm.DescribeMaintenanceWindowExecutionsOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ssm.DescribeMaintenanceWindowExecutionsInput, ...request.Option) *ssm.DescribeMaintenanceWindowExecutionsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.DescribeMaintenanceWindowExecutionsOutput)
		}
	}

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

	return r0, r1
}

// DescribeMaintenanceWindowTargets provides a mock function with given fields: _a0
func (_m *SSMAPI) DescribeMaintenanceWindowTargets(_a0 *ssm.DescribeMaintenanceWindowTargetsInput) (*ssm.DescribeMaintenanceWindowTargetsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ssm.DescribeMaintenanceWindowTargetsOutput
	if rf, ok := ret.Get(0).(func(*ssm.DescribeMaintenanceWindowTargetsInput) *ssm.DescribeMaintenanceWindowTargetsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.DescribeMaintenanceWindowTargetsOutput)
		}
	}

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

	return r0, r1
}

// DescribeMaintenanceWindowTargetsRequest provides a mock function with given fields: _a0
func (_m *SSMAPI) DescribeMaintenanceWindowTargetsRequest(_a0 *ssm.DescribeMaintenanceWindowTargetsInput) (*request.Request, *ssm.DescribeMaintenanceWindowTargetsOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ssm.DescribeMaintenanceWindowTargetsOutput
	if rf, ok := ret.Get(1).(func(*ssm.DescribeMaintenanceWindowTargetsInput) *ssm.DescribeMaintenanceWindowTargetsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ssm.DescribeMaintenanceWindowTargetsOutput)
		}
	}

	return r0, r1
}

// DescribeMaintenanceWindowTargetsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) DescribeMaintenanceWindowTargetsWithContext(_a0 aws.Context, _a1 *ssm.DescribeMaintenanceWindowTargetsInput, _a2 ...request.Option) (*ssm.DescribeMaintenanceWindowTargetsOutput, 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 *ssm.DescribeMaintenanceWindowTargetsOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ssm.DescribeMaintenanceWindowTargetsInput, ...request.Option) *ssm.DescribeMaintenanceWindowTargetsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.DescribeMaintenanceWindowTargetsOutput)
		}
	}

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

	return r0, r1
}

// DescribeMaintenanceWindowTasks provides a mock function with given fields: _a0
func (_m *SSMAPI) DescribeMaintenanceWindowTasks(_a0 *ssm.DescribeMaintenanceWindowTasksInput) (*ssm.DescribeMaintenanceWindowTasksOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ssm.DescribeMaintenanceWindowTasksOutput
	if rf, ok := ret.Get(0).(func(*ssm.DescribeMaintenanceWindowTasksInput) *ssm.DescribeMaintenanceWindowTasksOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.DescribeMaintenanceWindowTasksOutput)
		}
	}

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

	return r0, r1
}

// DescribeMaintenanceWindowTasksRequest provides a mock function with given fields: _a0
func (_m *SSMAPI) DescribeMaintenanceWindowTasksRequest(_a0 *ssm.DescribeMaintenanceWindowTasksInput) (*request.Request, *ssm.DescribeMaintenanceWindowTasksOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ssm.DescribeMaintenanceWindowTasksOutput
	if rf, ok := ret.Get(1).(func(*ssm.DescribeMaintenanceWindowTasksInput) *ssm.DescribeMaintenanceWindowTasksOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ssm.DescribeMaintenanceWindowTasksOutput)
		}
	}

	return r0, r1
}

// DescribeMaintenanceWindowTasksWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) DescribeMaintenanceWindowTasksWithContext(_a0 aws.Context, _a1 *ssm.DescribeMaintenanceWindowTasksInput, _a2 ...request.Option) (*ssm.DescribeMaintenanceWindowTasksOutput, 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 *ssm.DescribeMaintenanceWindowTasksOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ssm.DescribeMaintenanceWindowTasksInput, ...request.Option) *ssm.DescribeMaintenanceWindowTasksOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.DescribeMaintenanceWindowTasksOutput)
		}
	}

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

	return r0, r1
}

// DescribeMaintenanceWindows provides a mock function with given fields: _a0
func (_m *SSMAPI) DescribeMaintenanceWindows(_a0 *ssm.DescribeMaintenanceWindowsInput) (*ssm.DescribeMaintenanceWindowsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ssm.DescribeMaintenanceWindowsOutput
	if rf, ok := ret.Get(0).(func(*ssm.DescribeMaintenanceWindowsInput) *ssm.DescribeMaintenanceWindowsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.DescribeMaintenanceWindowsOutput)
		}
	}

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

	return r0, r1
}

// DescribeMaintenanceWindowsRequest provides a mock function with given fields: _a0
func (_m *SSMAPI) DescribeMaintenanceWindowsRequest(_a0 *ssm.DescribeMaintenanceWindowsInput) (*request.Request, *ssm.DescribeMaintenanceWindowsOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ssm.DescribeMaintenanceWindowsOutput
	if rf, ok := ret.Get(1).(func(*ssm.DescribeMaintenanceWindowsInput) *ssm.DescribeMaintenanceWindowsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ssm.DescribeMaintenanceWindowsOutput)
		}
	}

	return r0, r1
}

// DescribeMaintenanceWindowsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) DescribeMaintenanceWindowsWithContext(_a0 aws.Context, _a1 *ssm.DescribeMaintenanceWindowsInput, _a2 ...request.Option) (*ssm.DescribeMaintenanceWindowsOutput, 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 *ssm.DescribeMaintenanceWindowsOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ssm.DescribeMaintenanceWindowsInput, ...request.Option) *ssm.DescribeMaintenanceWindowsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.DescribeMaintenanceWindowsOutput)
		}
	}

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

	return r0, r1
}

// DescribeParameters provides a mock function with given fields: _a0
func (_m *SSMAPI) DescribeParameters(_a0 *ssm.DescribeParametersInput) (*ssm.DescribeParametersOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ssm.DescribeParametersOutput
	if rf, ok := ret.Get(0).(func(*ssm.DescribeParametersInput) *ssm.DescribeParametersOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.DescribeParametersOutput)
		}
	}

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

	return r0, r1
}

// DescribeParametersPages provides a mock function with given fields: _a0, _a1
func (_m *SSMAPI) DescribeParametersPages(_a0 *ssm.DescribeParametersInput, _a1 func(*ssm.DescribeParametersOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*ssm.DescribeParametersInput, func(*ssm.DescribeParametersOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeParametersPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *SSMAPI) DescribeParametersPagesWithContext(_a0 aws.Context, _a1 *ssm.DescribeParametersInput, _a2 func(*ssm.DescribeParametersOutput, 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(aws.Context, *ssm.DescribeParametersInput, func(*ssm.DescribeParametersOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeParametersRequest provides a mock function with given fields: _a0
func (_m *SSMAPI) DescribeParametersRequest(_a0 *ssm.DescribeParametersInput) (*request.Request, *ssm.DescribeParametersOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ssm.DescribeParametersOutput
	if rf, ok := ret.Get(1).(func(*ssm.DescribeParametersInput) *ssm.DescribeParametersOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ssm.DescribeParametersOutput)
		}
	}

	return r0, r1
}

// DescribeParametersWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) DescribeParametersWithContext(_a0 aws.Context, _a1 *ssm.DescribeParametersInput, _a2 ...request.Option) (*ssm.DescribeParametersOutput, 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 *ssm.DescribeParametersOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ssm.DescribeParametersInput, ...request.Option) *ssm.DescribeParametersOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.DescribeParametersOutput)
		}
	}

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

	return r0, r1
}

// DescribePatchBaselines provides a mock function with given fields: _a0
func (_m *SSMAPI) DescribePatchBaselines(_a0 *ssm.DescribePatchBaselinesInput) (*ssm.DescribePatchBaselinesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ssm.DescribePatchBaselinesOutput
	if rf, ok := ret.Get(0).(func(*ssm.DescribePatchBaselinesInput) *ssm.DescribePatchBaselinesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.DescribePatchBaselinesOutput)
		}
	}

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

	return r0, r1
}

// DescribePatchBaselinesRequest provides a mock function with given fields: _a0
func (_m *SSMAPI) DescribePatchBaselinesRequest(_a0 *ssm.DescribePatchBaselinesInput) (*request.Request, *ssm.DescribePatchBaselinesOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ssm.DescribePatchBaselinesOutput
	if rf, ok := ret.Get(1).(func(*ssm.DescribePatchBaselinesInput) *ssm.DescribePatchBaselinesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ssm.DescribePatchBaselinesOutput)
		}
	}

	return r0, r1
}

// DescribePatchBaselinesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) DescribePatchBaselinesWithContext(_a0 aws.Context, _a1 *ssm.DescribePatchBaselinesInput, _a2 ...request.Option) (*ssm.DescribePatchBaselinesOutput, 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 *ssm.DescribePatchBaselinesOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ssm.DescribePatchBaselinesInput, ...request.Option) *ssm.DescribePatchBaselinesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.DescribePatchBaselinesOutput)
		}
	}

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

	return r0, r1
}

// DescribePatchGroupState provides a mock function with given fields: _a0
func (_m *SSMAPI) DescribePatchGroupState(_a0 *ssm.DescribePatchGroupStateInput) (*ssm.DescribePatchGroupStateOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ssm.DescribePatchGroupStateOutput
	if rf, ok := ret.Get(0).(func(*ssm.DescribePatchGroupStateInput) *ssm.DescribePatchGroupStateOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.DescribePatchGroupStateOutput)
		}
	}

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

	return r0, r1
}

// DescribePatchGroupStateRequest provides a mock function with given fields: _a0
func (_m *SSMAPI) DescribePatchGroupStateRequest(_a0 *ssm.DescribePatchGroupStateInput) (*request.Request, *ssm.DescribePatchGroupStateOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ssm.DescribePatchGroupStateOutput
	if rf, ok := ret.Get(1).(func(*ssm.DescribePatchGroupStateInput) *ssm.DescribePatchGroupStateOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ssm.DescribePatchGroupStateOutput)
		}
	}

	return r0, r1
}

// DescribePatchGroupStateWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) DescribePatchGroupStateWithContext(_a0 aws.Context, _a1 *ssm.DescribePatchGroupStateInput, _a2 ...request.Option) (*ssm.DescribePatchGroupStateOutput, 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 *ssm.DescribePatchGroupStateOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ssm.DescribePatchGroupStateInput, ...request.Option) *ssm.DescribePatchGroupStateOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.DescribePatchGroupStateOutput)
		}
	}

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

	return r0, r1
}

// DescribePatchGroups provides a mock function with given fields: _a0
func (_m *SSMAPI) DescribePatchGroups(_a0 *ssm.DescribePatchGroupsInput) (*ssm.DescribePatchGroupsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ssm.DescribePatchGroupsOutput
	if rf, ok := ret.Get(0).(func(*ssm.DescribePatchGroupsInput) *ssm.DescribePatchGroupsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.DescribePatchGroupsOutput)
		}
	}

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

	return r0, r1
}

// DescribePatchGroupsRequest provides a mock function with given fields: _a0
func (_m *SSMAPI) DescribePatchGroupsRequest(_a0 *ssm.DescribePatchGroupsInput) (*request.Request, *ssm.DescribePatchGroupsOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ssm.DescribePatchGroupsOutput
	if rf, ok := ret.Get(1).(func(*ssm.DescribePatchGroupsInput) *ssm.DescribePatchGroupsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ssm.DescribePatchGroupsOutput)
		}
	}

	return r0, r1
}

// DescribePatchGroupsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) DescribePatchGroupsWithContext(_a0 aws.Context, _a1 *ssm.DescribePatchGroupsInput, _a2 ...request.Option) (*ssm.DescribePatchGroupsOutput, 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 *ssm.DescribePatchGroupsOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ssm.DescribePatchGroupsInput, ...request.Option) *ssm.DescribePatchGroupsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.DescribePatchGroupsOutput)
		}
	}

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

	return r0, r1
}

// GetAutomationExecution provides a mock function with given fields: _a0
func (_m *SSMAPI) GetAutomationExecution(_a0 *ssm.GetAutomationExecutionInput) (*ssm.GetAutomationExecutionOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ssm.GetAutomationExecutionOutput
	if rf, ok := ret.Get(0).(func(*ssm.GetAutomationExecutionInput) *ssm.GetAutomationExecutionOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.GetAutomationExecutionOutput)
		}
	}

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

	return r0, r1
}

// GetAutomationExecutionRequest provides a mock function with given fields: _a0
func (_m *SSMAPI) GetAutomationExecutionRequest(_a0 *ssm.GetAutomationExecutionInput) (*request.Request, *ssm.GetAutomationExecutionOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ssm.GetAutomationExecutionOutput
	if rf, ok := ret.Get(1).(func(*ssm.GetAutomationExecutionInput) *ssm.GetAutomationExecutionOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ssm.GetAutomationExecutionOutput)
		}
	}

	return r0, r1
}

// GetAutomationExecutionWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) GetAutomationExecutionWithContext(_a0 aws.Context, _a1 *ssm.GetAutomationExecutionInput, _a2 ...request.Option) (*ssm.GetAutomationExecutionOutput, 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 *ssm.GetAutomationExecutionOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ssm.GetAutomationExecutionInput, ...request.Option) *ssm.GetAutomationExecutionOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.GetAutomationExecutionOutput)
		}
	}

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

	return r0, r1
}

// GetCommandInvocation provides a mock function with given fields: _a0
func (_m *SSMAPI) GetCommandInvocation(_a0 *ssm.GetCommandInvocationInput) (*ssm.GetCommandInvocationOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ssm.GetCommandInvocationOutput
	if rf, ok := ret.Get(0).(func(*ssm.GetCommandInvocationInput) *ssm.GetCommandInvocationOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.GetCommandInvocationOutput)
		}
	}

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

	return r0, r1
}

// GetCommandInvocationRequest provides a mock function with given fields: _a0
func (_m *SSMAPI) GetCommandInvocationRequest(_a0 *ssm.GetCommandInvocationInput) (*request.Request, *ssm.GetCommandInvocationOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ssm.GetCommandInvocationOutput
	if rf, ok := ret.Get(1).(func(*ssm.GetCommandInvocationInput) *ssm.GetCommandInvocationOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ssm.GetCommandInvocationOutput)
		}
	}

	return r0, r1
}

// GetCommandInvocationWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) GetCommandInvocationWithContext(_a0 aws.Context, _a1 *ssm.GetCommandInvocationInput, _a2 ...request.Option) (*ssm.GetCommandInvocationOutput, 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 *ssm.GetCommandInvocationOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ssm.GetCommandInvocationInput, ...request.Option) *ssm.GetCommandInvocationOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.GetCommandInvocationOutput)
		}
	}

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

	return r0, r1
}

// GetDefaultPatchBaseline provides a mock function with given fields: _a0
func (_m *SSMAPI) GetDefaultPatchBaseline(_a0 *ssm.GetDefaultPatchBaselineInput) (*ssm.GetDefaultPatchBaselineOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ssm.GetDefaultPatchBaselineOutput
	if rf, ok := ret.Get(0).(func(*ssm.GetDefaultPatchBaselineInput) *ssm.GetDefaultPatchBaselineOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.GetDefaultPatchBaselineOutput)
		}
	}

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

	return r0, r1
}

// GetDefaultPatchBaselineRequest provides a mock function with given fields: _a0
func (_m *SSMAPI) GetDefaultPatchBaselineRequest(_a0 *ssm.GetDefaultPatchBaselineInput) (*request.Request, *ssm.GetDefaultPatchBaselineOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ssm.GetDefaultPatchBaselineOutput
	if rf, ok := ret.Get(1).(func(*ssm.GetDefaultPatchBaselineInput) *ssm.GetDefaultPatchBaselineOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ssm.GetDefaultPatchBaselineOutput)
		}
	}

	return r0, r1
}

// GetDefaultPatchBaselineWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) GetDefaultPatchBaselineWithContext(_a0 aws.Context, _a1 *ssm.GetDefaultPatchBaselineInput, _a2 ...request.Option) (*ssm.GetDefaultPatchBaselineOutput, 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 *ssm.GetDefaultPatchBaselineOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ssm.GetDefaultPatchBaselineInput, ...request.Option) *ssm.GetDefaultPatchBaselineOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.GetDefaultPatchBaselineOutput)
		}
	}

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

	return r0, r1
}

// GetDeployablePatchSnapshotForInstance provides a mock function with given fields: _a0
func (_m *SSMAPI) GetDeployablePatchSnapshotForInstance(_a0 *ssm.GetDeployablePatchSnapshotForInstanceInput) (*ssm.GetDeployablePatchSnapshotForInstanceOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ssm.GetDeployablePatchSnapshotForInstanceOutput
	if rf, ok := ret.Get(0).(func(*ssm.GetDeployablePatchSnapshotForInstanceInput) *ssm.GetDeployablePatchSnapshotForInstanceOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.GetDeployablePatchSnapshotForInstanceOutput)
		}
	}

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

	return r0, r1
}

// GetDeployablePatchSnapshotForInstanceRequest provides a mock function with given fields: _a0
func (_m *SSMAPI) GetDeployablePatchSnapshotForInstanceRequest(_a0 *ssm.GetDeployablePatchSnapshotForInstanceInput) (*request.Request, *ssm.GetDeployablePatchSnapshotForInstanceOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ssm.GetDeployablePatchSnapshotForInstanceOutput
	if rf, ok := ret.Get(1).(func(*ssm.GetDeployablePatchSnapshotForInstanceInput) *ssm.GetDeployablePatchSnapshotForInstanceOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ssm.GetDeployablePatchSnapshotForInstanceOutput)
		}
	}

	return r0, r1
}

// GetDeployablePatchSnapshotForInstanceWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) GetDeployablePatchSnapshotForInstanceWithContext(_a0 aws.Context, _a1 *ssm.GetDeployablePatchSnapshotForInstanceInput, _a2 ...request.Option) (*ssm.GetDeployablePatchSnapshotForInstanceOutput, 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 *ssm.GetDeployablePatchSnapshotForInstanceOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ssm.GetDeployablePatchSnapshotForInstanceInput, ...request.Option) *ssm.GetDeployablePatchSnapshotForInstanceOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.GetDeployablePatchSnapshotForInstanceOutput)
		}
	}

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

	return r0, r1
}

// GetDocument provides a mock function with given fields: _a0
func (_m *SSMAPI) GetDocument(_a0 *ssm.GetDocumentInput) (*ssm.GetDocumentOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ssm.GetDocumentOutput
	if rf, ok := ret.Get(0).(func(*ssm.GetDocumentInput) *ssm.GetDocumentOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.GetDocumentOutput)
		}
	}

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

	return r0, r1
}

// GetDocumentRequest provides a mock function with given fields: _a0
func (_m *SSMAPI) GetDocumentRequest(_a0 *ssm.GetDocumentInput) (*request.Request, *ssm.GetDocumentOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ssm.GetDocumentOutput
	if rf, ok := ret.Get(1).(func(*ssm.GetDocumentInput) *ssm.GetDocumentOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ssm.GetDocumentOutput)
		}
	}

	return r0, r1
}

// GetDocumentWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) GetDocumentWithContext(_a0 aws.Context, _a1 *ssm.GetDocumentInput, _a2 ...request.Option) (*ssm.GetDocumentOutput, 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 *ssm.GetDocumentOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ssm.GetDocumentInput, ...request.Option) *ssm.GetDocumentOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.GetDocumentOutput)
		}
	}

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

	return r0, r1
}

// GetInventory provides a mock function with given fields: _a0
func (_m *SSMAPI) GetInventory(_a0 *ssm.GetInventoryInput) (*ssm.GetInventoryOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ssm.GetInventoryOutput
	if rf, ok := ret.Get(0).(func(*ssm.GetInventoryInput) *ssm.GetInventoryOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.GetInventoryOutput)
		}
	}

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

	return r0, r1
}

// GetInventoryRequest provides a mock function with given fields: _a0
func (_m *SSMAPI) GetInventoryRequest(_a0 *ssm.GetInventoryInput) (*request.Request, *ssm.GetInventoryOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ssm.GetInventoryOutput
	if rf, ok := ret.Get(1).(func(*ssm.GetInventoryInput) *ssm.GetInventoryOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ssm.GetInventoryOutput)
		}
	}

	return r0, r1
}

// GetInventorySchema provides a mock function with given fields: _a0
func (_m *SSMAPI) GetInventorySchema(_a0 *ssm.GetInventorySchemaInput) (*ssm.GetInventorySchemaOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ssm.GetInventorySchemaOutput
	if rf, ok := ret.Get(0).(func(*ssm.GetInventorySchemaInput) *ssm.GetInventorySchemaOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.GetInventorySchemaOutput)
		}
	}

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

	return r0, r1
}

// GetInventorySchemaRequest provides a mock function with given fields: _a0
func (_m *SSMAPI) GetInventorySchemaRequest(_a0 *ssm.GetInventorySchemaInput) (*request.Request, *ssm.GetInventorySchemaOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ssm.GetInventorySchemaOutput
	if rf, ok := ret.Get(1).(func(*ssm.GetInventorySchemaInput) *ssm.GetInventorySchemaOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ssm.GetInventorySchemaOutput)
		}
	}

	return r0, r1
}

// GetInventorySchemaWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) GetInventorySchemaWithContext(_a0 aws.Context, _a1 *ssm.GetInventorySchemaInput, _a2 ...request.Option) (*ssm.GetInventorySchemaOutput, 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 *ssm.GetInventorySchemaOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ssm.GetInventorySchemaInput, ...request.Option) *ssm.GetInventorySchemaOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.GetInventorySchemaOutput)
		}
	}

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

	return r0, r1
}

// GetInventoryWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) GetInventoryWithContext(_a0 aws.Context, _a1 *ssm.GetInventoryInput, _a2 ...request.Option) (*ssm.GetInventoryOutput, 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 *ssm.GetInventoryOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ssm.GetInventoryInput, ...request.Option) *ssm.GetInventoryOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.GetInventoryOutput)
		}
	}

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

	return r0, r1
}

// GetMaintenanceWindow provides a mock function with given fields: _a0
func (_m *SSMAPI) GetMaintenanceWindow(_a0 *ssm.GetMaintenanceWindowInput) (*ssm.GetMaintenanceWindowOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ssm.GetMaintenanceWindowOutput
	if rf, ok := ret.Get(0).(func(*ssm.GetMaintenanceWindowInput) *ssm.GetMaintenanceWindowOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.GetMaintenanceWindowOutput)
		}
	}

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

	return r0, r1
}

// GetMaintenanceWindowExecution provides a mock function with given fields: _a0
func (_m *SSMAPI) GetMaintenanceWindowExecution(_a0 *ssm.GetMaintenanceWindowExecutionInput) (*ssm.GetMaintenanceWindowExecutionOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ssm.GetMaintenanceWindowExecutionOutput
	if rf, ok := ret.Get(0).(func(*ssm.GetMaintenanceWindowExecutionInput) *ssm.GetMaintenanceWindowExecutionOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.GetMaintenanceWindowExecutionOutput)
		}
	}

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

	return r0, r1
}

// GetMaintenanceWindowExecutionRequest provides a mock function with given fields: _a0
func (_m *SSMAPI) GetMaintenanceWindowExecutionRequest(_a0 *ssm.GetMaintenanceWindowExecutionInput) (*request.Request, *ssm.GetMaintenanceWindowExecutionOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ssm.GetMaintenanceWindowExecutionOutput
	if rf, ok := ret.Get(1).(func(*ssm.GetMaintenanceWindowExecutionInput) *ssm.GetMaintenanceWindowExecutionOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ssm.GetMaintenanceWindowExecutionOutput)
		}
	}

	return r0, r1
}

// GetMaintenanceWindowExecutionTask provides a mock function with given fields: _a0
func (_m *SSMAPI) GetMaintenanceWindowExecutionTask(_a0 *ssm.GetMaintenanceWindowExecutionTaskInput) (*ssm.GetMaintenanceWindowExecutionTaskOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ssm.GetMaintenanceWindowExecutionTaskOutput
	if rf, ok := ret.Get(0).(func(*ssm.GetMaintenanceWindowExecutionTaskInput) *ssm.GetMaintenanceWindowExecutionTaskOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.GetMaintenanceWindowExecutionTaskOutput)
		}
	}

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

	return r0, r1
}

// GetMaintenanceWindowExecutionTaskInvocation provides a mock function with given fields: _a0
func (_m *SSMAPI) GetMaintenanceWindowExecutionTaskInvocation(_a0 *ssm.GetMaintenanceWindowExecutionTaskInvocationInput) (*ssm.GetMaintenanceWindowExecutionTaskInvocationOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ssm.GetMaintenanceWindowExecutionTaskInvocationOutput
	if rf, ok := ret.Get(0).(func(*ssm.GetMaintenanceWindowExecutionTaskInvocationInput) *ssm.GetMaintenanceWindowExecutionTaskInvocationOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.GetMaintenanceWindowExecutionTaskInvocationOutput)
		}
	}

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

	return r0, r1
}

// GetMaintenanceWindowExecutionTaskInvocationRequest provides a mock function with given fields: _a0
func (_m *SSMAPI) GetMaintenanceWindowExecutionTaskInvocationRequest(_a0 *ssm.GetMaintenanceWindowExecutionTaskInvocationInput) (*request.Request, *ssm.GetMaintenanceWindowExecutionTaskInvocationOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ssm.GetMaintenanceWindowExecutionTaskInvocationOutput
	if rf, ok := ret.Get(1).(func(*ssm.GetMaintenanceWindowExecutionTaskInvocationInput) *ssm.GetMaintenanceWindowExecutionTaskInvocationOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ssm.GetMaintenanceWindowExecutionTaskInvocationOutput)
		}
	}

	return r0, r1
}

// GetMaintenanceWindowExecutionTaskInvocationWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) GetMaintenanceWindowExecutionTaskInvocationWithContext(_a0 aws.Context, _a1 *ssm.GetMaintenanceWindowExecutionTaskInvocationInput, _a2 ...request.Option) (*ssm.GetMaintenanceWindowExecutionTaskInvocationOutput, 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 *ssm.GetMaintenanceWindowExecutionTaskInvocationOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ssm.GetMaintenanceWindowExecutionTaskInvocationInput, ...request.Option) *ssm.GetMaintenanceWindowExecutionTaskInvocationOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.GetMaintenanceWindowExecutionTaskInvocationOutput)
		}
	}

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

	return r0, r1
}

// GetMaintenanceWindowExecutionTaskRequest provides a mock function with given fields: _a0
func (_m *SSMAPI) GetMaintenanceWindowExecutionTaskRequest(_a0 *ssm.GetMaintenanceWindowExecutionTaskInput) (*request.Request, *ssm.GetMaintenanceWindowExecutionTaskOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ssm.GetMaintenanceWindowExecutionTaskOutput
	if rf, ok := ret.Get(1).(func(*ssm.GetMaintenanceWindowExecutionTaskInput) *ssm.GetMaintenanceWindowExecutionTaskOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ssm.GetMaintenanceWindowExecutionTaskOutput)
		}
	}

	return r0, r1
}

// GetMaintenanceWindowExecutionTaskWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) GetMaintenanceWindowExecutionTaskWithContext(_a0 aws.Context, _a1 *ssm.GetMaintenanceWindowExecutionTaskInput, _a2 ...request.Option) (*ssm.GetMaintenanceWindowExecutionTaskOutput, 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 *ssm.GetMaintenanceWindowExecutionTaskOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ssm.GetMaintenanceWindowExecutionTaskInput, ...request.Option) *ssm.GetMaintenanceWindowExecutionTaskOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.GetMaintenanceWindowExecutionTaskOutput)
		}
	}

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

	return r0, r1
}

// GetMaintenanceWindowExecutionWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) GetMaintenanceWindowExecutionWithContext(_a0 aws.Context, _a1 *ssm.GetMaintenanceWindowExecutionInput, _a2 ...request.Option) (*ssm.GetMaintenanceWindowExecutionOutput, 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 *ssm.GetMaintenanceWindowExecutionOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ssm.GetMaintenanceWindowExecutionInput, ...request.Option) *ssm.GetMaintenanceWindowExecutionOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.GetMaintenanceWindowExecutionOutput)
		}
	}

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

	return r0, r1
}

// GetMaintenanceWindowRequest provides a mock function with given fields: _a0
func (_m *SSMAPI) GetMaintenanceWindowRequest(_a0 *ssm.GetMaintenanceWindowInput) (*request.Request, *ssm.GetMaintenanceWindowOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ssm.GetMaintenanceWindowOutput
	if rf, ok := ret.Get(1).(func(*ssm.GetMaintenanceWindowInput) *ssm.GetMaintenanceWindowOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ssm.GetMaintenanceWindowOutput)
		}
	}

	return r0, r1
}

// GetMaintenanceWindowTask provides a mock function with given fields: _a0
func (_m *SSMAPI) GetMaintenanceWindowTask(_a0 *ssm.GetMaintenanceWindowTaskInput) (*ssm.GetMaintenanceWindowTaskOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ssm.GetMaintenanceWindowTaskOutput
	if rf, ok := ret.Get(0).(func(*ssm.GetMaintenanceWindowTaskInput) *ssm.GetMaintenanceWindowTaskOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.GetMaintenanceWindowTaskOutput)
		}
	}

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

	return r0, r1
}

// GetMaintenanceWindowTaskRequest provides a mock function with given fields: _a0
func (_m *SSMAPI) GetMaintenanceWindowTaskRequest(_a0 *ssm.GetMaintenanceWindowTaskInput) (*request.Request, *ssm.GetMaintenanceWindowTaskOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ssm.GetMaintenanceWindowTaskOutput
	if rf, ok := ret.Get(1).(func(*ssm.GetMaintenanceWindowTaskInput) *ssm.GetMaintenanceWindowTaskOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ssm.GetMaintenanceWindowTaskOutput)
		}
	}

	return r0, r1
}

// GetMaintenanceWindowTaskWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) GetMaintenanceWindowTaskWithContext(_a0 aws.Context, _a1 *ssm.GetMaintenanceWindowTaskInput, _a2 ...request.Option) (*ssm.GetMaintenanceWindowTaskOutput, 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 *ssm.GetMaintenanceWindowTaskOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ssm.GetMaintenanceWindowTaskInput, ...request.Option) *ssm.GetMaintenanceWindowTaskOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.GetMaintenanceWindowTaskOutput)
		}
	}

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

	return r0, r1
}

// GetMaintenanceWindowWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) GetMaintenanceWindowWithContext(_a0 aws.Context, _a1 *ssm.GetMaintenanceWindowInput, _a2 ...request.Option) (*ssm.GetMaintenanceWindowOutput, 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 *ssm.GetMaintenanceWindowOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ssm.GetMaintenanceWindowInput, ...request.Option) *ssm.GetMaintenanceWindowOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.GetMaintenanceWindowOutput)
		}
	}

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

	return r0, r1
}

// GetParameter provides a mock function with given fields: _a0
func (_m *SSMAPI) GetParameter(_a0 *ssm.GetParameterInput) (*ssm.GetParameterOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ssm.GetParameterOutput
	if rf, ok := ret.Get(0).(func(*ssm.GetParameterInput) *ssm.GetParameterOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.GetParameterOutput)
		}
	}

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

	return r0, r1
}

// GetParameterHistory provides a mock function with given fields: _a0
func (_m *SSMAPI) GetParameterHistory(_a0 *ssm.GetParameterHistoryInput) (*ssm.GetParameterHistoryOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ssm.GetParameterHistoryOutput
	if rf, ok := ret.Get(0).(func(*ssm.GetParameterHistoryInput) *ssm.GetParameterHistoryOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.GetParameterHistoryOutput)
		}
	}

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

	return r0, r1
}

// GetParameterHistoryPages provides a mock function with given fields: _a0, _a1
func (_m *SSMAPI) GetParameterHistoryPages(_a0 *ssm.GetParameterHistoryInput, _a1 func(*ssm.GetParameterHistoryOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*ssm.GetParameterHistoryInput, func(*ssm.GetParameterHistoryOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// GetParameterHistoryPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *SSMAPI) GetParameterHistoryPagesWithContext(_a0 aws.Context, _a1 *ssm.GetParameterHistoryInput, _a2 func(*ssm.GetParameterHistoryOutput, 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(aws.Context, *ssm.GetParameterHistoryInput, func(*ssm.GetParameterHistoryOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// GetParameterHistoryRequest provides a mock function with given fields: _a0
func (_m *SSMAPI) GetParameterHistoryRequest(_a0 *ssm.GetParameterHistoryInput) (*request.Request, *ssm.GetParameterHistoryOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ssm.GetParameterHistoryOutput
	if rf, ok := ret.Get(1).(func(*ssm.GetParameterHistoryInput) *ssm.GetParameterHistoryOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ssm.GetParameterHistoryOutput)
		}
	}

	return r0, r1
}

// GetParameterHistoryWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) GetParameterHistoryWithContext(_a0 aws.Context, _a1 *ssm.GetParameterHistoryInput, _a2 ...request.Option) (*ssm.GetParameterHistoryOutput, 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 *ssm.GetParameterHistoryOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ssm.GetParameterHistoryInput, ...request.Option) *ssm.GetParameterHistoryOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.GetParameterHistoryOutput)
		}
	}

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

	return r0, r1
}

// GetParameterRequest provides a mock function with given fields: _a0
func (_m *SSMAPI) GetParameterRequest(_a0 *ssm.GetParameterInput) (*request.Request, *ssm.GetParameterOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ssm.GetParameterOutput
	if rf, ok := ret.Get(1).(func(*ssm.GetParameterInput) *ssm.GetParameterOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ssm.GetParameterOutput)
		}
	}

	return r0, r1
}

// GetParameterWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) GetParameterWithContext(_a0 aws.Context, _a1 *ssm.GetParameterInput, _a2 ...request.Option) (*ssm.GetParameterOutput, 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 *ssm.GetParameterOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ssm.GetParameterInput, ...request.Option) *ssm.GetParameterOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.GetParameterOutput)
		}
	}

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

	return r0, r1
}

// GetParameters provides a mock function with given fields: _a0
func (_m *SSMAPI) GetParameters(_a0 *ssm.GetParametersInput) (*ssm.GetParametersOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ssm.GetParametersOutput
	if rf, ok := ret.Get(0).(func(*ssm.GetParametersInput) *ssm.GetParametersOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.GetParametersOutput)
		}
	}

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

	return r0, r1
}

// GetParametersByPath provides a mock function with given fields: _a0
func (_m *SSMAPI) GetParametersByPath(_a0 *ssm.GetParametersByPathInput) (*ssm.GetParametersByPathOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ssm.GetParametersByPathOutput
	if rf, ok := ret.Get(0).(func(*ssm.GetParametersByPathInput) *ssm.GetParametersByPathOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.GetParametersByPathOutput)
		}
	}

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

	return r0, r1
}

// GetParametersByPathPages provides a mock function with given fields: _a0, _a1
func (_m *SSMAPI) GetParametersByPathPages(_a0 *ssm.GetParametersByPathInput, _a1 func(*ssm.GetParametersByPathOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*ssm.GetParametersByPathInput, func(*ssm.GetParametersByPathOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// GetParametersByPathPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *SSMAPI) GetParametersByPathPagesWithContext(_a0 aws.Context, _a1 *ssm.GetParametersByPathInput, _a2 func(*ssm.GetParametersByPathOutput, 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(aws.Context, *ssm.GetParametersByPathInput, func(*ssm.GetParametersByPathOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// GetParametersByPathRequest provides a mock function with given fields: _a0
func (_m *SSMAPI) GetParametersByPathRequest(_a0 *ssm.GetParametersByPathInput) (*request.Request, *ssm.GetParametersByPathOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ssm.GetParametersByPathOutput
	if rf, ok := ret.Get(1).(func(*ssm.GetParametersByPathInput) *ssm.GetParametersByPathOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ssm.GetParametersByPathOutput)
		}
	}

	return r0, r1
}

// GetParametersByPathWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) GetParametersByPathWithContext(_a0 aws.Context, _a1 *ssm.GetParametersByPathInput, _a2 ...request.Option) (*ssm.GetParametersByPathOutput, 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 *ssm.GetParametersByPathOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ssm.GetParametersByPathInput, ...request.Option) *ssm.GetParametersByPathOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.GetParametersByPathOutput)
		}
	}

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

	return r0, r1
}

// GetParametersRequest provides a mock function with given fields: _a0
func (_m *SSMAPI) GetParametersRequest(_a0 *ssm.GetParametersInput) (*request.Request, *ssm.GetParametersOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ssm.GetParametersOutput
	if rf, ok := ret.Get(1).(func(*ssm.GetParametersInput) *ssm.GetParametersOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ssm.GetParametersOutput)
		}
	}

	return r0, r1
}

// GetParametersWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) GetParametersWithContext(_a0 aws.Context, _a1 *ssm.GetParametersInput, _a2 ...request.Option) (*ssm.GetParametersOutput, 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 *ssm.GetParametersOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ssm.GetParametersInput, ...request.Option) *ssm.GetParametersOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.GetParametersOutput)
		}
	}

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

	return r0, r1
}

// GetPatchBaseline provides a mock function with given fields: _a0
func (_m *SSMAPI) GetPatchBaseline(_a0 *ssm.GetPatchBaselineInput) (*ssm.GetPatchBaselineOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ssm.GetPatchBaselineOutput
	if rf, ok := ret.Get(0).(func(*ssm.GetPatchBaselineInput) *ssm.GetPatchBaselineOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.GetPatchBaselineOutput)
		}
	}

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

	return r0, r1
}

// GetPatchBaselineForPatchGroup provides a mock function with given fields: _a0
func (_m *SSMAPI) GetPatchBaselineForPatchGroup(_a0 *ssm.GetPatchBaselineForPatchGroupInput) (*ssm.GetPatchBaselineForPatchGroupOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ssm.GetPatchBaselineForPatchGroupOutput
	if rf, ok := ret.Get(0).(func(*ssm.GetPatchBaselineForPatchGroupInput) *ssm.GetPatchBaselineForPatchGroupOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.GetPatchBaselineForPatchGroupOutput)
		}
	}

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

	return r0, r1
}

// GetPatchBaselineForPatchGroupRequest provides a mock function with given fields: _a0
func (_m *SSMAPI) GetPatchBaselineForPatchGroupRequest(_a0 *ssm.GetPatchBaselineForPatchGroupInput) (*request.Request, *ssm.GetPatchBaselineForPatchGroupOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ssm.GetPatchBaselineForPatchGroupOutput
	if rf, ok := ret.Get(1).(func(*ssm.GetPatchBaselineForPatchGroupInput) *ssm.GetPatchBaselineForPatchGroupOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ssm.GetPatchBaselineForPatchGroupOutput)
		}
	}

	return r0, r1
}

// GetPatchBaselineForPatchGroupWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) GetPatchBaselineForPatchGroupWithContext(_a0 aws.Context, _a1 *ssm.GetPatchBaselineForPatchGroupInput, _a2 ...request.Option) (*ssm.GetPatchBaselineForPatchGroupOutput, 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 *ssm.GetPatchBaselineForPatchGroupOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ssm.GetPatchBaselineForPatchGroupInput, ...request.Option) *ssm.GetPatchBaselineForPatchGroupOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.GetPatchBaselineForPatchGroupOutput)
		}
	}

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

	return r0, r1
}

// GetPatchBaselineRequest provides a mock function with given fields: _a0
func (_m *SSMAPI) GetPatchBaselineRequest(_a0 *ssm.GetPatchBaselineInput) (*request.Request, *ssm.GetPatchBaselineOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ssm.GetPatchBaselineOutput
	if rf, ok := ret.Get(1).(func(*ssm.GetPatchBaselineInput) *ssm.GetPatchBaselineOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ssm.GetPatchBaselineOutput)
		}
	}

	return r0, r1
}

// GetPatchBaselineWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) GetPatchBaselineWithContext(_a0 aws.Context, _a1 *ssm.GetPatchBaselineInput, _a2 ...request.Option) (*ssm.GetPatchBaselineOutput, 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 *ssm.GetPatchBaselineOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ssm.GetPatchBaselineInput, ...request.Option) *ssm.GetPatchBaselineOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.GetPatchBaselineOutput)
		}
	}

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

	return r0, r1
}

// ListAssociationVersions provides a mock function with given fields: _a0
func (_m *SSMAPI) ListAssociationVersions(_a0 *ssm.ListAssociationVersionsInput) (*ssm.ListAssociationVersionsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ssm.ListAssociationVersionsOutput
	if rf, ok := ret.Get(0).(func(*ssm.ListAssociationVersionsInput) *ssm.ListAssociationVersionsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.ListAssociationVersionsOutput)
		}
	}

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

	return r0, r1
}

// ListAssociationVersionsRequest provides a mock function with given fields: _a0
func (_m *SSMAPI) ListAssociationVersionsRequest(_a0 *ssm.ListAssociationVersionsInput) (*request.Request, *ssm.ListAssociationVersionsOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ssm.ListAssociationVersionsOutput
	if rf, ok := ret.Get(1).(func(*ssm.ListAssociationVersionsInput) *ssm.ListAssociationVersionsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ssm.ListAssociationVersionsOutput)
		}
	}

	return r0, r1
}

// ListAssociationVersionsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) ListAssociationVersionsWithContext(_a0 aws.Context, _a1 *ssm.ListAssociationVersionsInput, _a2 ...request.Option) (*ssm.ListAssociationVersionsOutput, 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 *ssm.ListAssociationVersionsOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ssm.ListAssociationVersionsInput, ...request.Option) *ssm.ListAssociationVersionsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.ListAssociationVersionsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(aws.Context, *ssm.ListAssociationVersionsInput, ...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 *SSMAPI) ListAssociations(_a0 *ssm.ListAssociationsInput) (*ssm.ListAssociationsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ssm.ListAssociationsOutput
	if rf, ok := ret.Get(0).(func(*ssm.ListAssociationsInput) *ssm.ListAssociationsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.ListAssociationsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ssm.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 *SSMAPI) ListAssociationsPages(_a0 *ssm.ListAssociationsInput, _a1 func(*ssm.ListAssociationsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*ssm.ListAssociationsInput, func(*ssm.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 *SSMAPI) ListAssociationsPagesWithContext(_a0 aws.Context, _a1 *ssm.ListAssociationsInput, _a2 func(*ssm.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(aws.Context, *ssm.ListAssociationsInput, func(*ssm.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 *SSMAPI) ListAssociationsRequest(_a0 *ssm.ListAssociationsInput) (*request.Request, *ssm.ListAssociationsOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ssm.ListAssociationsOutput
	if rf, ok := ret.Get(1).(func(*ssm.ListAssociationsInput) *ssm.ListAssociationsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ssm.ListAssociationsOutput)
		}
	}

	return r0, r1
}

// ListAssociationsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) ListAssociationsWithContext(_a0 aws.Context, _a1 *ssm.ListAssociationsInput, _a2 ...request.Option) (*ssm.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 *ssm.ListAssociationsOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ssm.ListAssociationsInput, ...request.Option) *ssm.ListAssociationsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.ListAssociationsOutput)
		}
	}

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

	return r0, r1
}

// ListCommandInvocations provides a mock function with given fields: _a0
func (_m *SSMAPI) ListCommandInvocations(_a0 *ssm.ListCommandInvocationsInput) (*ssm.ListCommandInvocationsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ssm.ListCommandInvocationsOutput
	if rf, ok := ret.Get(0).(func(*ssm.ListCommandInvocationsInput) *ssm.ListCommandInvocationsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.ListCommandInvocationsOutput)
		}
	}

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

	return r0, r1
}

// ListCommandInvocationsPages provides a mock function with given fields: _a0, _a1
func (_m *SSMAPI) ListCommandInvocationsPages(_a0 *ssm.ListCommandInvocationsInput, _a1 func(*ssm.ListCommandInvocationsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*ssm.ListCommandInvocationsInput, func(*ssm.ListCommandInvocationsOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListCommandInvocationsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *SSMAPI) ListCommandInvocationsPagesWithContext(_a0 aws.Context, _a1 *ssm.ListCommandInvocationsInput, _a2 func(*ssm.ListCommandInvocationsOutput, 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(aws.Context, *ssm.ListCommandInvocationsInput, func(*ssm.ListCommandInvocationsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListCommandInvocationsRequest provides a mock function with given fields: _a0
func (_m *SSMAPI) ListCommandInvocationsRequest(_a0 *ssm.ListCommandInvocationsInput) (*request.Request, *ssm.ListCommandInvocationsOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ssm.ListCommandInvocationsOutput
	if rf, ok := ret.Get(1).(func(*ssm.ListCommandInvocationsInput) *ssm.ListCommandInvocationsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ssm.ListCommandInvocationsOutput)
		}
	}

	return r0, r1
}

// ListCommandInvocationsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) ListCommandInvocationsWithContext(_a0 aws.Context, _a1 *ssm.ListCommandInvocationsInput, _a2 ...request.Option) (*ssm.ListCommandInvocationsOutput, 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 *ssm.ListCommandInvocationsOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ssm.ListCommandInvocationsInput, ...request.Option) *ssm.ListCommandInvocationsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.ListCommandInvocationsOutput)
		}
	}

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

	return r0, r1
}

// ListCommands provides a mock function with given fields: _a0
func (_m *SSMAPI) ListCommands(_a0 *ssm.ListCommandsInput) (*ssm.ListCommandsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ssm.ListCommandsOutput
	if rf, ok := ret.Get(0).(func(*ssm.ListCommandsInput) *ssm.ListCommandsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.ListCommandsOutput)
		}
	}

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

	return r0, r1
}

// ListCommandsPages provides a mock function with given fields: _a0, _a1
func (_m *SSMAPI) ListCommandsPages(_a0 *ssm.ListCommandsInput, _a1 func(*ssm.ListCommandsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*ssm.ListCommandsInput, func(*ssm.ListCommandsOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListCommandsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *SSMAPI) ListCommandsPagesWithContext(_a0 aws.Context, _a1 *ssm.ListCommandsInput, _a2 func(*ssm.ListCommandsOutput, 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(aws.Context, *ssm.ListCommandsInput, func(*ssm.ListCommandsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListCommandsRequest provides a mock function with given fields: _a0
func (_m *SSMAPI) ListCommandsRequest(_a0 *ssm.ListCommandsInput) (*request.Request, *ssm.ListCommandsOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ssm.ListCommandsOutput
	if rf, ok := ret.Get(1).(func(*ssm.ListCommandsInput) *ssm.ListCommandsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ssm.ListCommandsOutput)
		}
	}

	return r0, r1
}

// ListCommandsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) ListCommandsWithContext(_a0 aws.Context, _a1 *ssm.ListCommandsInput, _a2 ...request.Option) (*ssm.ListCommandsOutput, 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 *ssm.ListCommandsOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ssm.ListCommandsInput, ...request.Option) *ssm.ListCommandsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.ListCommandsOutput)
		}
	}

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

	return r0, r1
}

// ListComplianceItems provides a mock function with given fields: _a0
func (_m *SSMAPI) ListComplianceItems(_a0 *ssm.ListComplianceItemsInput) (*ssm.ListComplianceItemsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ssm.ListComplianceItemsOutput
	if rf, ok := ret.Get(0).(func(*ssm.ListComplianceItemsInput) *ssm.ListComplianceItemsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.ListComplianceItemsOutput)
		}
	}

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

	return r0, r1
}

// ListComplianceItemsRequest provides a mock function with given fields: _a0
func (_m *SSMAPI) ListComplianceItemsRequest(_a0 *ssm.ListComplianceItemsInput) (*request.Request, *ssm.ListComplianceItemsOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ssm.ListComplianceItemsOutput
	if rf, ok := ret.Get(1).(func(*ssm.ListComplianceItemsInput) *ssm.ListComplianceItemsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ssm.ListComplianceItemsOutput)
		}
	}

	return r0, r1
}

// ListComplianceItemsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) ListComplianceItemsWithContext(_a0 aws.Context, _a1 *ssm.ListComplianceItemsInput, _a2 ...request.Option) (*ssm.ListComplianceItemsOutput, 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 *ssm.ListComplianceItemsOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ssm.ListComplianceItemsInput, ...request.Option) *ssm.ListComplianceItemsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.ListComplianceItemsOutput)
		}
	}

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

	return r0, r1
}

// ListComplianceSummaries provides a mock function with given fields: _a0
func (_m *SSMAPI) ListComplianceSummaries(_a0 *ssm.ListComplianceSummariesInput) (*ssm.ListComplianceSummariesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ssm.ListComplianceSummariesOutput
	if rf, ok := ret.Get(0).(func(*ssm.ListComplianceSummariesInput) *ssm.ListComplianceSummariesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.ListComplianceSummariesOutput)
		}
	}

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

	return r0, r1
}

// ListComplianceSummariesRequest provides a mock function with given fields: _a0
func (_m *SSMAPI) ListComplianceSummariesRequest(_a0 *ssm.ListComplianceSummariesInput) (*request.Request, *ssm.ListComplianceSummariesOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ssm.ListComplianceSummariesOutput
	if rf, ok := ret.Get(1).(func(*ssm.ListComplianceSummariesInput) *ssm.ListComplianceSummariesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ssm.ListComplianceSummariesOutput)
		}
	}

	return r0, r1
}

// ListComplianceSummariesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) ListComplianceSummariesWithContext(_a0 aws.Context, _a1 *ssm.ListComplianceSummariesInput, _a2 ...request.Option) (*ssm.ListComplianceSummariesOutput, 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 *ssm.ListComplianceSummariesOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ssm.ListComplianceSummariesInput, ...request.Option) *ssm.ListComplianceSummariesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.ListComplianceSummariesOutput)
		}
	}

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

	return r0, r1
}

// ListDocumentVersions provides a mock function with given fields: _a0
func (_m *SSMAPI) ListDocumentVersions(_a0 *ssm.ListDocumentVersionsInput) (*ssm.ListDocumentVersionsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ssm.ListDocumentVersionsOutput
	if rf, ok := ret.Get(0).(func(*ssm.ListDocumentVersionsInput) *ssm.ListDocumentVersionsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.ListDocumentVersionsOutput)
		}
	}

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

	return r0, r1
}

// ListDocumentVersionsRequest provides a mock function with given fields: _a0
func (_m *SSMAPI) ListDocumentVersionsRequest(_a0 *ssm.ListDocumentVersionsInput) (*request.Request, *ssm.ListDocumentVersionsOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ssm.ListDocumentVersionsOutput
	if rf, ok := ret.Get(1).(func(*ssm.ListDocumentVersionsInput) *ssm.ListDocumentVersionsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ssm.ListDocumentVersionsOutput)
		}
	}

	return r0, r1
}

// ListDocumentVersionsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) ListDocumentVersionsWithContext(_a0 aws.Context, _a1 *ssm.ListDocumentVersionsInput, _a2 ...request.Option) (*ssm.ListDocumentVersionsOutput, 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 *ssm.ListDocumentVersionsOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ssm.ListDocumentVersionsInput, ...request.Option) *ssm.ListDocumentVersionsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.ListDocumentVersionsOutput)
		}
	}

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

	return r0, r1
}

// ListDocuments provides a mock function with given fields: _a0
func (_m *SSMAPI) ListDocuments(_a0 *ssm.ListDocumentsInput) (*ssm.ListDocumentsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ssm.ListDocumentsOutput
	if rf, ok := ret.Get(0).(func(*ssm.ListDocumentsInput) *ssm.ListDocumentsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.ListDocumentsOutput)
		}
	}

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

	return r0, r1
}

// ListDocumentsPages provides a mock function with given fields: _a0, _a1
func (_m *SSMAPI) ListDocumentsPages(_a0 *ssm.ListDocumentsInput, _a1 func(*ssm.ListDocumentsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*ssm.ListDocumentsInput, func(*ssm.ListDocumentsOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListDocumentsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *SSMAPI) ListDocumentsPagesWithContext(_a0 aws.Context, _a1 *ssm.ListDocumentsInput, _a2 func(*ssm.ListDocumentsOutput, 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(aws.Context, *ssm.ListDocumentsInput, func(*ssm.ListDocumentsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListDocumentsRequest provides a mock function with given fields: _a0
func (_m *SSMAPI) ListDocumentsRequest(_a0 *ssm.ListDocumentsInput) (*request.Request, *ssm.ListDocumentsOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ssm.ListDocumentsOutput
	if rf, ok := ret.Get(1).(func(*ssm.ListDocumentsInput) *ssm.ListDocumentsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ssm.ListDocumentsOutput)
		}
	}

	return r0, r1
}

// ListDocumentsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) ListDocumentsWithContext(_a0 aws.Context, _a1 *ssm.ListDocumentsInput, _a2 ...request.Option) (*ssm.ListDocumentsOutput, 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 *ssm.ListDocumentsOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ssm.ListDocumentsInput, ...request.Option) *ssm.ListDocumentsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.ListDocumentsOutput)
		}
	}

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

	return r0, r1
}

// ListInventoryEntries provides a mock function with given fields: _a0
func (_m *SSMAPI) ListInventoryEntries(_a0 *ssm.ListInventoryEntriesInput) (*ssm.ListInventoryEntriesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ssm.ListInventoryEntriesOutput
	if rf, ok := ret.Get(0).(func(*ssm.ListInventoryEntriesInput) *ssm.ListInventoryEntriesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.ListInventoryEntriesOutput)
		}
	}

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

	return r0, r1
}

// ListInventoryEntriesRequest provides a mock function with given fields: _a0
func (_m *SSMAPI) ListInventoryEntriesRequest(_a0 *ssm.ListInventoryEntriesInput) (*request.Request, *ssm.ListInventoryEntriesOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ssm.ListInventoryEntriesOutput
	if rf, ok := ret.Get(1).(func(*ssm.ListInventoryEntriesInput) *ssm.ListInventoryEntriesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ssm.ListInventoryEntriesOutput)
		}
	}

	return r0, r1
}

// ListInventoryEntriesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) ListInventoryEntriesWithContext(_a0 aws.Context, _a1 *ssm.ListInventoryEntriesInput, _a2 ...request.Option) (*ssm.ListInventoryEntriesOutput, 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 *ssm.ListInventoryEntriesOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ssm.ListInventoryEntriesInput, ...request.Option) *ssm.ListInventoryEntriesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.ListInventoryEntriesOutput)
		}
	}

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

	return r0, r1
}

// ListResourceComplianceSummaries provides a mock function with given fields: _a0
func (_m *SSMAPI) ListResourceComplianceSummaries(_a0 *ssm.ListResourceComplianceSummariesInput) (*ssm.ListResourceComplianceSummariesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ssm.ListResourceComplianceSummariesOutput
	if rf, ok := ret.Get(0).(func(*ssm.ListResourceComplianceSummariesInput) *ssm.ListResourceComplianceSummariesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.ListResourceComplianceSummariesOutput)
		}
	}

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

	return r0, r1
}

// ListResourceComplianceSummariesRequest provides a mock function with given fields: _a0
func (_m *SSMAPI) ListResourceComplianceSummariesRequest(_a0 *ssm.ListResourceComplianceSummariesInput) (*request.Request, *ssm.ListResourceComplianceSummariesOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ssm.ListResourceComplianceSummariesOutput
	if rf, ok := ret.Get(1).(func(*ssm.ListResourceComplianceSummariesInput) *ssm.ListResourceComplianceSummariesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ssm.ListResourceComplianceSummariesOutput)
		}
	}

	return r0, r1
}

// ListResourceComplianceSummariesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) ListResourceComplianceSummariesWithContext(_a0 aws.Context, _a1 *ssm.ListResourceComplianceSummariesInput, _a2 ...request.Option) (*ssm.ListResourceComplianceSummariesOutput, 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 *ssm.ListResourceComplianceSummariesOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ssm.ListResourceComplianceSummariesInput, ...request.Option) *ssm.ListResourceComplianceSummariesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.ListResourceComplianceSummariesOutput)
		}
	}

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

	return r0, r1
}

// ListResourceDataSync provides a mock function with given fields: _a0
func (_m *SSMAPI) ListResourceDataSync(_a0 *ssm.ListResourceDataSyncInput) (*ssm.ListResourceDataSyncOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ssm.ListResourceDataSyncOutput
	if rf, ok := ret.Get(0).(func(*ssm.ListResourceDataSyncInput) *ssm.ListResourceDataSyncOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.ListResourceDataSyncOutput)
		}
	}

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

	return r0, r1
}

// ListResourceDataSyncRequest provides a mock function with given fields: _a0
func (_m *SSMAPI) ListResourceDataSyncRequest(_a0 *ssm.ListResourceDataSyncInput) (*request.Request, *ssm.ListResourceDataSyncOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ssm.ListResourceDataSyncOutput
	if rf, ok := ret.Get(1).(func(*ssm.ListResourceDataSyncInput) *ssm.ListResourceDataSyncOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ssm.ListResourceDataSyncOutput)
		}
	}

	return r0, r1
}

// ListResourceDataSyncWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) ListResourceDataSyncWithContext(_a0 aws.Context, _a1 *ssm.ListResourceDataSyncInput, _a2 ...request.Option) (*ssm.ListResourceDataSyncOutput, 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 *ssm.ListResourceDataSyncOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ssm.ListResourceDataSyncInput, ...request.Option) *ssm.ListResourceDataSyncOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.ListResourceDataSyncOutput)
		}
	}

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

	return r0, r1
}

// ListTagsForResource provides a mock function with given fields: _a0
func (_m *SSMAPI) ListTagsForResource(_a0 *ssm.ListTagsForResourceInput) (*ssm.ListTagsForResourceOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ssm.ListTagsForResourceOutput
	if rf, ok := ret.Get(0).(func(*ssm.ListTagsForResourceInput) *ssm.ListTagsForResourceOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.ListTagsForResourceOutput)
		}
	}

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

	return r0, r1
}

// ListTagsForResourceRequest provides a mock function with given fields: _a0
func (_m *SSMAPI) ListTagsForResourceRequest(_a0 *ssm.ListTagsForResourceInput) (*request.Request, *ssm.ListTagsForResourceOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ssm.ListTagsForResourceOutput
	if rf, ok := ret.Get(1).(func(*ssm.ListTagsForResourceInput) *ssm.ListTagsForResourceOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ssm.ListTagsForResourceOutput)
		}
	}

	return r0, r1
}

// ListTagsForResourceWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) ListTagsForResourceWithContext(_a0 aws.Context, _a1 *ssm.ListTagsForResourceInput, _a2 ...request.Option) (*ssm.ListTagsForResourceOutput, 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 *ssm.ListTagsForResourceOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ssm.ListTagsForResourceInput, ...request.Option) *ssm.ListTagsForResourceOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.ListTagsForResourceOutput)
		}
	}

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

	return r0, r1
}

// ModifyDocumentPermission provides a mock function with given fields: _a0
func (_m *SSMAPI) ModifyDocumentPermission(_a0 *ssm.ModifyDocumentPermissionInput) (*ssm.ModifyDocumentPermissionOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ssm.ModifyDocumentPermissionOutput
	if rf, ok := ret.Get(0).(func(*ssm.ModifyDocumentPermissionInput) *ssm.ModifyDocumentPermissionOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.ModifyDocumentPermissionOutput)
		}
	}

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

	return r0, r1
}

// ModifyDocumentPermissionRequest provides a mock function with given fields: _a0
func (_m *SSMAPI) ModifyDocumentPermissionRequest(_a0 *ssm.ModifyDocumentPermissionInput) (*request.Request, *ssm.ModifyDocumentPermissionOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ssm.ModifyDocumentPermissionOutput
	if rf, ok := ret.Get(1).(func(*ssm.ModifyDocumentPermissionInput) *ssm.ModifyDocumentPermissionOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ssm.ModifyDocumentPermissionOutput)
		}
	}

	return r0, r1
}

// ModifyDocumentPermissionWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) ModifyDocumentPermissionWithContext(_a0 aws.Context, _a1 *ssm.ModifyDocumentPermissionInput, _a2 ...request.Option) (*ssm.ModifyDocumentPermissionOutput, 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 *ssm.ModifyDocumentPermissionOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ssm.ModifyDocumentPermissionInput, ...request.Option) *ssm.ModifyDocumentPermissionOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.ModifyDocumentPermissionOutput)
		}
	}

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

	return r0, r1
}

// PutComplianceItems provides a mock function with given fields: _a0
func (_m *SSMAPI) PutComplianceItems(_a0 *ssm.PutComplianceItemsInput) (*ssm.PutComplianceItemsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ssm.PutComplianceItemsOutput
	if rf, ok := ret.Get(0).(func(*ssm.PutComplianceItemsInput) *ssm.PutComplianceItemsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.PutComplianceItemsOutput)
		}
	}

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

	return r0, r1
}

// PutComplianceItemsRequest provides a mock function with given fields: _a0
func (_m *SSMAPI) PutComplianceItemsRequest(_a0 *ssm.PutComplianceItemsInput) (*request.Request, *ssm.PutComplianceItemsOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ssm.PutComplianceItemsOutput
	if rf, ok := ret.Get(1).(func(*ssm.PutComplianceItemsInput) *ssm.PutComplianceItemsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ssm.PutComplianceItemsOutput)
		}
	}

	return r0, r1
}

// PutComplianceItemsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) PutComplianceItemsWithContext(_a0 aws.Context, _a1 *ssm.PutComplianceItemsInput, _a2 ...request.Option) (*ssm.PutComplianceItemsOutput, 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 *ssm.PutComplianceItemsOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ssm.PutComplianceItemsInput, ...request.Option) *ssm.PutComplianceItemsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.PutComplianceItemsOutput)
		}
	}

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

	return r0, r1
}

// PutInventory provides a mock function with given fields: _a0
func (_m *SSMAPI) PutInventory(_a0 *ssm.PutInventoryInput) (*ssm.PutInventoryOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ssm.PutInventoryOutput
	if rf, ok := ret.Get(0).(func(*ssm.PutInventoryInput) *ssm.PutInventoryOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.PutInventoryOutput)
		}
	}

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

	return r0, r1
}

// PutInventoryRequest provides a mock function with given fields: _a0
func (_m *SSMAPI) PutInventoryRequest(_a0 *ssm.PutInventoryInput) (*request.Request, *ssm.PutInventoryOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ssm.PutInventoryOutput
	if rf, ok := ret.Get(1).(func(*ssm.PutInventoryInput) *ssm.PutInventoryOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ssm.PutInventoryOutput)
		}
	}

	return r0, r1
}

// PutInventoryWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) PutInventoryWithContext(_a0 aws.Context, _a1 *ssm.PutInventoryInput, _a2 ...request.Option) (*ssm.PutInventoryOutput, 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 *ssm.PutInventoryOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ssm.PutInventoryInput, ...request.Option) *ssm.PutInventoryOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.PutInventoryOutput)
		}
	}

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

	return r0, r1
}

// PutParameter provides a mock function with given fields: _a0
func (_m *SSMAPI) PutParameter(_a0 *ssm.PutParameterInput) (*ssm.PutParameterOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ssm.PutParameterOutput
	if rf, ok := ret.Get(0).(func(*ssm.PutParameterInput) *ssm.PutParameterOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.PutParameterOutput)
		}
	}

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

	return r0, r1
}

// PutParameterRequest provides a mock function with given fields: _a0
func (_m *SSMAPI) PutParameterRequest(_a0 *ssm.PutParameterInput) (*request.Request, *ssm.PutParameterOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ssm.PutParameterOutput
	if rf, ok := ret.Get(1).(func(*ssm.PutParameterInput) *ssm.PutParameterOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ssm.PutParameterOutput)
		}
	}

	return r0, r1
}

// PutParameterWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) PutParameterWithContext(_a0 aws.Context, _a1 *ssm.PutParameterInput, _a2 ...request.Option) (*ssm.PutParameterOutput, 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 *ssm.PutParameterOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ssm.PutParameterInput, ...request.Option) *ssm.PutParameterOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.PutParameterOutput)
		}
	}

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

	return r0, r1
}

// RegisterDefaultPatchBaseline provides a mock function with given fields: _a0
func (_m *SSMAPI) RegisterDefaultPatchBaseline(_a0 *ssm.RegisterDefaultPatchBaselineInput) (*ssm.RegisterDefaultPatchBaselineOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ssm.RegisterDefaultPatchBaselineOutput
	if rf, ok := ret.Get(0).(func(*ssm.RegisterDefaultPatchBaselineInput) *ssm.RegisterDefaultPatchBaselineOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.RegisterDefaultPatchBaselineOutput)
		}
	}

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

	return r0, r1
}

// RegisterDefaultPatchBaselineRequest provides a mock function with given fields: _a0
func (_m *SSMAPI) RegisterDefaultPatchBaselineRequest(_a0 *ssm.RegisterDefaultPatchBaselineInput) (*request.Request, *ssm.RegisterDefaultPatchBaselineOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ssm.RegisterDefaultPatchBaselineOutput
	if rf, ok := ret.Get(1).(func(*ssm.RegisterDefaultPatchBaselineInput) *ssm.RegisterDefaultPatchBaselineOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ssm.RegisterDefaultPatchBaselineOutput)
		}
	}

	return r0, r1
}

// RegisterDefaultPatchBaselineWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) RegisterDefaultPatchBaselineWithContext(_a0 aws.Context, _a1 *ssm.RegisterDefaultPatchBaselineInput, _a2 ...request.Option) (*ssm.RegisterDefaultPatchBaselineOutput, 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 *ssm.RegisterDefaultPatchBaselineOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ssm.RegisterDefaultPatchBaselineInput, ...request.Option) *ssm.RegisterDefaultPatchBaselineOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.RegisterDefaultPatchBaselineOutput)
		}
	}

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

	return r0, r1
}

// RegisterPatchBaselineForPatchGroup provides a mock function with given fields: _a0
func (_m *SSMAPI) RegisterPatchBaselineForPatchGroup(_a0 *ssm.RegisterPatchBaselineForPatchGroupInput) (*ssm.RegisterPatchBaselineForPatchGroupOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ssm.RegisterPatchBaselineForPatchGroupOutput
	if rf, ok := ret.Get(0).(func(*ssm.RegisterPatchBaselineForPatchGroupInput) *ssm.RegisterPatchBaselineForPatchGroupOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.RegisterPatchBaselineForPatchGroupOutput)
		}
	}

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

	return r0, r1
}

// RegisterPatchBaselineForPatchGroupRequest provides a mock function with given fields: _a0
func (_m *SSMAPI) RegisterPatchBaselineForPatchGroupRequest(_a0 *ssm.RegisterPatchBaselineForPatchGroupInput) (*request.Request, *ssm.RegisterPatchBaselineForPatchGroupOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ssm.RegisterPatchBaselineForPatchGroupOutput
	if rf, ok := ret.Get(1).(func(*ssm.RegisterPatchBaselineForPatchGroupInput) *ssm.RegisterPatchBaselineForPatchGroupOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ssm.RegisterPatchBaselineForPatchGroupOutput)
		}
	}

	return r0, r1
}

// RegisterPatchBaselineForPatchGroupWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) RegisterPatchBaselineForPatchGroupWithContext(_a0 aws.Context, _a1 *ssm.RegisterPatchBaselineForPatchGroupInput, _a2 ...request.Option) (*ssm.RegisterPatchBaselineForPatchGroupOutput, 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 *ssm.RegisterPatchBaselineForPatchGroupOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ssm.RegisterPatchBaselineForPatchGroupInput, ...request.Option) *ssm.RegisterPatchBaselineForPatchGroupOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.RegisterPatchBaselineForPatchGroupOutput)
		}
	}

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

	return r0, r1
}

// RegisterTargetWithMaintenanceWindow provides a mock function with given fields: _a0
func (_m *SSMAPI) RegisterTargetWithMaintenanceWindow(_a0 *ssm.RegisterTargetWithMaintenanceWindowInput) (*ssm.RegisterTargetWithMaintenanceWindowOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ssm.RegisterTargetWithMaintenanceWindowOutput
	if rf, ok := ret.Get(0).(func(*ssm.RegisterTargetWithMaintenanceWindowInput) *ssm.RegisterTargetWithMaintenanceWindowOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.RegisterTargetWithMaintenanceWindowOutput)
		}
	}

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

	return r0, r1
}

// RegisterTargetWithMaintenanceWindowRequest provides a mock function with given fields: _a0
func (_m *SSMAPI) RegisterTargetWithMaintenanceWindowRequest(_a0 *ssm.RegisterTargetWithMaintenanceWindowInput) (*request.Request, *ssm.RegisterTargetWithMaintenanceWindowOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ssm.RegisterTargetWithMaintenanceWindowOutput
	if rf, ok := ret.Get(1).(func(*ssm.RegisterTargetWithMaintenanceWindowInput) *ssm.RegisterTargetWithMaintenanceWindowOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ssm.RegisterTargetWithMaintenanceWindowOutput)
		}
	}

	return r0, r1
}

// RegisterTargetWithMaintenanceWindowWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) RegisterTargetWithMaintenanceWindowWithContext(_a0 aws.Context, _a1 *ssm.RegisterTargetWithMaintenanceWindowInput, _a2 ...request.Option) (*ssm.RegisterTargetWithMaintenanceWindowOutput, 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 *ssm.RegisterTargetWithMaintenanceWindowOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ssm.RegisterTargetWithMaintenanceWindowInput, ...request.Option) *ssm.RegisterTargetWithMaintenanceWindowOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.RegisterTargetWithMaintenanceWindowOutput)
		}
	}

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

	return r0, r1
}

// RegisterTaskWithMaintenanceWindow provides a mock function with given fields: _a0
func (_m *SSMAPI) RegisterTaskWithMaintenanceWindow(_a0 *ssm.RegisterTaskWithMaintenanceWindowInput) (*ssm.RegisterTaskWithMaintenanceWindowOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ssm.RegisterTaskWithMaintenanceWindowOutput
	if rf, ok := ret.Get(0).(func(*ssm.RegisterTaskWithMaintenanceWindowInput) *ssm.RegisterTaskWithMaintenanceWindowOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.RegisterTaskWithMaintenanceWindowOutput)
		}
	}

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

	return r0, r1
}

// RegisterTaskWithMaintenanceWindowRequest provides a mock function with given fields: _a0
func (_m *SSMAPI) RegisterTaskWithMaintenanceWindowRequest(_a0 *ssm.RegisterTaskWithMaintenanceWindowInput) (*request.Request, *ssm.RegisterTaskWithMaintenanceWindowOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ssm.RegisterTaskWithMaintenanceWindowOutput
	if rf, ok := ret.Get(1).(func(*ssm.RegisterTaskWithMaintenanceWindowInput) *ssm.RegisterTaskWithMaintenanceWindowOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ssm.RegisterTaskWithMaintenanceWindowOutput)
		}
	}

	return r0, r1
}

// RegisterTaskWithMaintenanceWindowWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) RegisterTaskWithMaintenanceWindowWithContext(_a0 aws.Context, _a1 *ssm.RegisterTaskWithMaintenanceWindowInput, _a2 ...request.Option) (*ssm.RegisterTaskWithMaintenanceWindowOutput, 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 *ssm.RegisterTaskWithMaintenanceWindowOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ssm.RegisterTaskWithMaintenanceWindowInput, ...request.Option) *ssm.RegisterTaskWithMaintenanceWindowOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.RegisterTaskWithMaintenanceWindowOutput)
		}
	}

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

	return r0, r1
}

// RemoveTagsFromResource provides a mock function with given fields: _a0
func (_m *SSMAPI) RemoveTagsFromResource(_a0 *ssm.RemoveTagsFromResourceInput) (*ssm.RemoveTagsFromResourceOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ssm.RemoveTagsFromResourceOutput
	if rf, ok := ret.Get(0).(func(*ssm.RemoveTagsFromResourceInput) *ssm.RemoveTagsFromResourceOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.RemoveTagsFromResourceOutput)
		}
	}

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

	return r0, r1
}

// RemoveTagsFromResourceRequest provides a mock function with given fields: _a0
func (_m *SSMAPI) RemoveTagsFromResourceRequest(_a0 *ssm.RemoveTagsFromResourceInput) (*request.Request, *ssm.RemoveTagsFromResourceOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ssm.RemoveTagsFromResourceOutput
	if rf, ok := ret.Get(1).(func(*ssm.RemoveTagsFromResourceInput) *ssm.RemoveTagsFromResourceOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ssm.RemoveTagsFromResourceOutput)
		}
	}

	return r0, r1
}

// RemoveTagsFromResourceWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) RemoveTagsFromResourceWithContext(_a0 aws.Context, _a1 *ssm.RemoveTagsFromResourceInput, _a2 ...request.Option) (*ssm.RemoveTagsFromResourceOutput, 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 *ssm.RemoveTagsFromResourceOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ssm.RemoveTagsFromResourceInput, ...request.Option) *ssm.RemoveTagsFromResourceOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.RemoveTagsFromResourceOutput)
		}
	}

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

	return r0, r1
}

// SendAutomationSignal provides a mock function with given fields: _a0
func (_m *SSMAPI) SendAutomationSignal(_a0 *ssm.SendAutomationSignalInput) (*ssm.SendAutomationSignalOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ssm.SendAutomationSignalOutput
	if rf, ok := ret.Get(0).(func(*ssm.SendAutomationSignalInput) *ssm.SendAutomationSignalOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.SendAutomationSignalOutput)
		}
	}

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

	return r0, r1
}

// SendAutomationSignalRequest provides a mock function with given fields: _a0
func (_m *SSMAPI) SendAutomationSignalRequest(_a0 *ssm.SendAutomationSignalInput) (*request.Request, *ssm.SendAutomationSignalOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ssm.SendAutomationSignalOutput
	if rf, ok := ret.Get(1).(func(*ssm.SendAutomationSignalInput) *ssm.SendAutomationSignalOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ssm.SendAutomationSignalOutput)
		}
	}

	return r0, r1
}

// SendAutomationSignalWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) SendAutomationSignalWithContext(_a0 aws.Context, _a1 *ssm.SendAutomationSignalInput, _a2 ...request.Option) (*ssm.SendAutomationSignalOutput, 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 *ssm.SendAutomationSignalOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ssm.SendAutomationSignalInput, ...request.Option) *ssm.SendAutomationSignalOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.SendAutomationSignalOutput)
		}
	}

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

	return r0, r1
}

// SendCommand provides a mock function with given fields: _a0
func (_m *SSMAPI) SendCommand(_a0 *ssm.SendCommandInput) (*ssm.SendCommandOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ssm.SendCommandOutput
	if rf, ok := ret.Get(0).(func(*ssm.SendCommandInput) *ssm.SendCommandOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.SendCommandOutput)
		}
	}

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

	return r0, r1
}

// SendCommandRequest provides a mock function with given fields: _a0
func (_m *SSMAPI) SendCommandRequest(_a0 *ssm.SendCommandInput) (*request.Request, *ssm.SendCommandOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ssm.SendCommandOutput
	if rf, ok := ret.Get(1).(func(*ssm.SendCommandInput) *ssm.SendCommandOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ssm.SendCommandOutput)
		}
	}

	return r0, r1
}

// SendCommandWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) SendCommandWithContext(_a0 aws.Context, _a1 *ssm.SendCommandInput, _a2 ...request.Option) (*ssm.SendCommandOutput, 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 *ssm.SendCommandOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ssm.SendCommandInput, ...request.Option) *ssm.SendCommandOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.SendCommandOutput)
		}
	}

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

	return r0, r1
}

// StartAutomationExecution provides a mock function with given fields: _a0
func (_m *SSMAPI) StartAutomationExecution(_a0 *ssm.StartAutomationExecutionInput) (*ssm.StartAutomationExecutionOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ssm.StartAutomationExecutionOutput
	if rf, ok := ret.Get(0).(func(*ssm.StartAutomationExecutionInput) *ssm.StartAutomationExecutionOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.StartAutomationExecutionOutput)
		}
	}

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

	return r0, r1
}

// StartAutomationExecutionRequest provides a mock function with given fields: _a0
func (_m *SSMAPI) StartAutomationExecutionRequest(_a0 *ssm.StartAutomationExecutionInput) (*request.Request, *ssm.StartAutomationExecutionOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ssm.StartAutomationExecutionOutput
	if rf, ok := ret.Get(1).(func(*ssm.StartAutomationExecutionInput) *ssm.StartAutomationExecutionOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ssm.StartAutomationExecutionOutput)
		}
	}

	return r0, r1
}

// StartAutomationExecutionWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) StartAutomationExecutionWithContext(_a0 aws.Context, _a1 *ssm.StartAutomationExecutionInput, _a2 ...request.Option) (*ssm.StartAutomationExecutionOutput, 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 *ssm.StartAutomationExecutionOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ssm.StartAutomationExecutionInput, ...request.Option) *ssm.StartAutomationExecutionOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.StartAutomationExecutionOutput)
		}
	}

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

	return r0, r1
}

// StopAutomationExecution provides a mock function with given fields: _a0
func (_m *SSMAPI) StopAutomationExecution(_a0 *ssm.StopAutomationExecutionInput) (*ssm.StopAutomationExecutionOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ssm.StopAutomationExecutionOutput
	if rf, ok := ret.Get(0).(func(*ssm.StopAutomationExecutionInput) *ssm.StopAutomationExecutionOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.StopAutomationExecutionOutput)
		}
	}

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

	return r0, r1
}

// StopAutomationExecutionRequest provides a mock function with given fields: _a0
func (_m *SSMAPI) StopAutomationExecutionRequest(_a0 *ssm.StopAutomationExecutionInput) (*request.Request, *ssm.StopAutomationExecutionOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ssm.StopAutomationExecutionOutput
	if rf, ok := ret.Get(1).(func(*ssm.StopAutomationExecutionInput) *ssm.StopAutomationExecutionOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ssm.StopAutomationExecutionOutput)
		}
	}

	return r0, r1
}

// StopAutomationExecutionWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) StopAutomationExecutionWithContext(_a0 aws.Context, _a1 *ssm.StopAutomationExecutionInput, _a2 ...request.Option) (*ssm.StopAutomationExecutionOutput, 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 *ssm.StopAutomationExecutionOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ssm.StopAutomationExecutionInput, ...request.Option) *ssm.StopAutomationExecutionOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.StopAutomationExecutionOutput)
		}
	}

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

	return r0, r1
}

// UpdateAssociation provides a mock function with given fields: _a0
func (_m *SSMAPI) UpdateAssociation(_a0 *ssm.UpdateAssociationInput) (*ssm.UpdateAssociationOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ssm.UpdateAssociationOutput
	if rf, ok := ret.Get(0).(func(*ssm.UpdateAssociationInput) *ssm.UpdateAssociationOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.UpdateAssociationOutput)
		}
	}

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

	return r0, r1
}

// UpdateAssociationRequest provides a mock function with given fields: _a0
func (_m *SSMAPI) UpdateAssociationRequest(_a0 *ssm.UpdateAssociationInput) (*request.Request, *ssm.UpdateAssociationOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ssm.UpdateAssociationOutput
	if rf, ok := ret.Get(1).(func(*ssm.UpdateAssociationInput) *ssm.UpdateAssociationOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ssm.UpdateAssociationOutput)
		}
	}

	return r0, r1
}

// UpdateAssociationStatus provides a mock function with given fields: _a0
func (_m *SSMAPI) UpdateAssociationStatus(_a0 *ssm.UpdateAssociationStatusInput) (*ssm.UpdateAssociationStatusOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ssm.UpdateAssociationStatusOutput
	if rf, ok := ret.Get(0).(func(*ssm.UpdateAssociationStatusInput) *ssm.UpdateAssociationStatusOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.UpdateAssociationStatusOutput)
		}
	}

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

	return r0, r1
}

// UpdateAssociationStatusRequest provides a mock function with given fields: _a0
func (_m *SSMAPI) UpdateAssociationStatusRequest(_a0 *ssm.UpdateAssociationStatusInput) (*request.Request, *ssm.UpdateAssociationStatusOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ssm.UpdateAssociationStatusOutput
	if rf, ok := ret.Get(1).(func(*ssm.UpdateAssociationStatusInput) *ssm.UpdateAssociationStatusOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ssm.UpdateAssociationStatusOutput)
		}
	}

	return r0, r1
}

// UpdateAssociationStatusWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) UpdateAssociationStatusWithContext(_a0 aws.Context, _a1 *ssm.UpdateAssociationStatusInput, _a2 ...request.Option) (*ssm.UpdateAssociationStatusOutput, 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 *ssm.UpdateAssociationStatusOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ssm.UpdateAssociationStatusInput, ...request.Option) *ssm.UpdateAssociationStatusOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.UpdateAssociationStatusOutput)
		}
	}

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

	return r0, r1
}

// UpdateAssociationWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) UpdateAssociationWithContext(_a0 aws.Context, _a1 *ssm.UpdateAssociationInput, _a2 ...request.Option) (*ssm.UpdateAssociationOutput, 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 *ssm.UpdateAssociationOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ssm.UpdateAssociationInput, ...request.Option) *ssm.UpdateAssociationOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.UpdateAssociationOutput)
		}
	}

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

	return r0, r1
}

// UpdateDocument provides a mock function with given fields: _a0
func (_m *SSMAPI) UpdateDocument(_a0 *ssm.UpdateDocumentInput) (*ssm.UpdateDocumentOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ssm.UpdateDocumentOutput
	if rf, ok := ret.Get(0).(func(*ssm.UpdateDocumentInput) *ssm.UpdateDocumentOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.UpdateDocumentOutput)
		}
	}

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

	return r0, r1
}

// UpdateDocumentDefaultVersion provides a mock function with given fields: _a0
func (_m *SSMAPI) UpdateDocumentDefaultVersion(_a0 *ssm.UpdateDocumentDefaultVersionInput) (*ssm.UpdateDocumentDefaultVersionOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ssm.UpdateDocumentDefaultVersionOutput
	if rf, ok := ret.Get(0).(func(*ssm.UpdateDocumentDefaultVersionInput) *ssm.UpdateDocumentDefaultVersionOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.UpdateDocumentDefaultVersionOutput)
		}
	}

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

	return r0, r1
}

// UpdateDocumentDefaultVersionRequest provides a mock function with given fields: _a0
func (_m *SSMAPI) UpdateDocumentDefaultVersionRequest(_a0 *ssm.UpdateDocumentDefaultVersionInput) (*request.Request, *ssm.UpdateDocumentDefaultVersionOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ssm.UpdateDocumentDefaultVersionOutput
	if rf, ok := ret.Get(1).(func(*ssm.UpdateDocumentDefaultVersionInput) *ssm.UpdateDocumentDefaultVersionOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ssm.UpdateDocumentDefaultVersionOutput)
		}
	}

	return r0, r1
}

// UpdateDocumentDefaultVersionWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) UpdateDocumentDefaultVersionWithContext(_a0 aws.Context, _a1 *ssm.UpdateDocumentDefaultVersionInput, _a2 ...request.Option) (*ssm.UpdateDocumentDefaultVersionOutput, 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 *ssm.UpdateDocumentDefaultVersionOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ssm.UpdateDocumentDefaultVersionInput, ...request.Option) *ssm.UpdateDocumentDefaultVersionOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.UpdateDocumentDefaultVersionOutput)
		}
	}

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

	return r0, r1
}

// UpdateDocumentRequest provides a mock function with given fields: _a0
func (_m *SSMAPI) UpdateDocumentRequest(_a0 *ssm.UpdateDocumentInput) (*request.Request, *ssm.UpdateDocumentOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ssm.UpdateDocumentOutput
	if rf, ok := ret.Get(1).(func(*ssm.UpdateDocumentInput) *ssm.UpdateDocumentOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ssm.UpdateDocumentOutput)
		}
	}

	return r0, r1
}

// UpdateDocumentWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) UpdateDocumentWithContext(_a0 aws.Context, _a1 *ssm.UpdateDocumentInput, _a2 ...request.Option) (*ssm.UpdateDocumentOutput, 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 *ssm.UpdateDocumentOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ssm.UpdateDocumentInput, ...request.Option) *ssm.UpdateDocumentOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.UpdateDocumentOutput)
		}
	}

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

	return r0, r1
}

// UpdateMaintenanceWindow provides a mock function with given fields: _a0
func (_m *SSMAPI) UpdateMaintenanceWindow(_a0 *ssm.UpdateMaintenanceWindowInput) (*ssm.UpdateMaintenanceWindowOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ssm.UpdateMaintenanceWindowOutput
	if rf, ok := ret.Get(0).(func(*ssm.UpdateMaintenanceWindowInput) *ssm.UpdateMaintenanceWindowOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.UpdateMaintenanceWindowOutput)
		}
	}

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

	return r0, r1
}

// UpdateMaintenanceWindowRequest provides a mock function with given fields: _a0
func (_m *SSMAPI) UpdateMaintenanceWindowRequest(_a0 *ssm.UpdateMaintenanceWindowInput) (*request.Request, *ssm.UpdateMaintenanceWindowOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ssm.UpdateMaintenanceWindowOutput
	if rf, ok := ret.Get(1).(func(*ssm.UpdateMaintenanceWindowInput) *ssm.UpdateMaintenanceWindowOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ssm.UpdateMaintenanceWindowOutput)
		}
	}

	return r0, r1
}

// UpdateMaintenanceWindowTarget provides a mock function with given fields: _a0
func (_m *SSMAPI) UpdateMaintenanceWindowTarget(_a0 *ssm.UpdateMaintenanceWindowTargetInput) (*ssm.UpdateMaintenanceWindowTargetOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ssm.UpdateMaintenanceWindowTargetOutput
	if rf, ok := ret.Get(0).(func(*ssm.UpdateMaintenanceWindowTargetInput) *ssm.UpdateMaintenanceWindowTargetOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.UpdateMaintenanceWindowTargetOutput)
		}
	}

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

	return r0, r1
}

// UpdateMaintenanceWindowTargetRequest provides a mock function with given fields: _a0
func (_m *SSMAPI) UpdateMaintenanceWindowTargetRequest(_a0 *ssm.UpdateMaintenanceWindowTargetInput) (*request.Request, *ssm.UpdateMaintenanceWindowTargetOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ssm.UpdateMaintenanceWindowTargetOutput
	if rf, ok := ret.Get(1).(func(*ssm.UpdateMaintenanceWindowTargetInput) *ssm.UpdateMaintenanceWindowTargetOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ssm.UpdateMaintenanceWindowTargetOutput)
		}
	}

	return r0, r1
}

// UpdateMaintenanceWindowTargetWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) UpdateMaintenanceWindowTargetWithContext(_a0 aws.Context, _a1 *ssm.UpdateMaintenanceWindowTargetInput, _a2 ...request.Option) (*ssm.UpdateMaintenanceWindowTargetOutput, 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 *ssm.UpdateMaintenanceWindowTargetOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ssm.UpdateMaintenanceWindowTargetInput, ...request.Option) *ssm.UpdateMaintenanceWindowTargetOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.UpdateMaintenanceWindowTargetOutput)
		}
	}

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

	return r0, r1
}

// UpdateMaintenanceWindowTask provides a mock function with given fields: _a0
func (_m *SSMAPI) UpdateMaintenanceWindowTask(_a0 *ssm.UpdateMaintenanceWindowTaskInput) (*ssm.UpdateMaintenanceWindowTaskOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ssm.UpdateMaintenanceWindowTaskOutput
	if rf, ok := ret.Get(0).(func(*ssm.UpdateMaintenanceWindowTaskInput) *ssm.UpdateMaintenanceWindowTaskOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.UpdateMaintenanceWindowTaskOutput)
		}
	}

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

	return r0, r1
}

// UpdateMaintenanceWindowTaskRequest provides a mock function with given fields: _a0
func (_m *SSMAPI) UpdateMaintenanceWindowTaskRequest(_a0 *ssm.UpdateMaintenanceWindowTaskInput) (*request.Request, *ssm.UpdateMaintenanceWindowTaskOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ssm.UpdateMaintenanceWindowTaskOutput
	if rf, ok := ret.Get(1).(func(*ssm.UpdateMaintenanceWindowTaskInput) *ssm.UpdateMaintenanceWindowTaskOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ssm.UpdateMaintenanceWindowTaskOutput)
		}
	}

	return r0, r1
}

// UpdateMaintenanceWindowTaskWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) UpdateMaintenanceWindowTaskWithContext(_a0 aws.Context, _a1 *ssm.UpdateMaintenanceWindowTaskInput, _a2 ...request.Option) (*ssm.UpdateMaintenanceWindowTaskOutput, 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 *ssm.UpdateMaintenanceWindowTaskOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ssm.UpdateMaintenanceWindowTaskInput, ...request.Option) *ssm.UpdateMaintenanceWindowTaskOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.UpdateMaintenanceWindowTaskOutput)
		}
	}

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

	return r0, r1
}

// UpdateMaintenanceWindowWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) UpdateMaintenanceWindowWithContext(_a0 aws.Context, _a1 *ssm.UpdateMaintenanceWindowInput, _a2 ...request.Option) (*ssm.UpdateMaintenanceWindowOutput, 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 *ssm.UpdateMaintenanceWindowOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ssm.UpdateMaintenanceWindowInput, ...request.Option) *ssm.UpdateMaintenanceWindowOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.UpdateMaintenanceWindowOutput)
		}
	}

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

	return r0, r1
}

// UpdateManagedInstanceRole provides a mock function with given fields: _a0
func (_m *SSMAPI) UpdateManagedInstanceRole(_a0 *ssm.UpdateManagedInstanceRoleInput) (*ssm.UpdateManagedInstanceRoleOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ssm.UpdateManagedInstanceRoleOutput
	if rf, ok := ret.Get(0).(func(*ssm.UpdateManagedInstanceRoleInput) *ssm.UpdateManagedInstanceRoleOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.UpdateManagedInstanceRoleOutput)
		}
	}

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

	return r0, r1
}

// UpdateManagedInstanceRoleRequest provides a mock function with given fields: _a0
func (_m *SSMAPI) UpdateManagedInstanceRoleRequest(_a0 *ssm.UpdateManagedInstanceRoleInput) (*request.Request, *ssm.UpdateManagedInstanceRoleOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ssm.UpdateManagedInstanceRoleOutput
	if rf, ok := ret.Get(1).(func(*ssm.UpdateManagedInstanceRoleInput) *ssm.UpdateManagedInstanceRoleOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ssm.UpdateManagedInstanceRoleOutput)
		}
	}

	return r0, r1
}

// UpdateManagedInstanceRoleWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) UpdateManagedInstanceRoleWithContext(_a0 aws.Context, _a1 *ssm.UpdateManagedInstanceRoleInput, _a2 ...request.Option) (*ssm.UpdateManagedInstanceRoleOutput, 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 *ssm.UpdateManagedInstanceRoleOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ssm.UpdateManagedInstanceRoleInput, ...request.Option) *ssm.UpdateManagedInstanceRoleOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.UpdateManagedInstanceRoleOutput)
		}
	}

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

	return r0, r1
}

// UpdatePatchBaseline provides a mock function with given fields: _a0
func (_m *SSMAPI) UpdatePatchBaseline(_a0 *ssm.UpdatePatchBaselineInput) (*ssm.UpdatePatchBaselineOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ssm.UpdatePatchBaselineOutput
	if rf, ok := ret.Get(0).(func(*ssm.UpdatePatchBaselineInput) *ssm.UpdatePatchBaselineOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.UpdatePatchBaselineOutput)
		}
	}

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

	return r0, r1
}

// UpdatePatchBaselineRequest provides a mock function with given fields: _a0
func (_m *SSMAPI) UpdatePatchBaselineRequest(_a0 *ssm.UpdatePatchBaselineInput) (*request.Request, *ssm.UpdatePatchBaselineOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ssm.UpdatePatchBaselineOutput
	if rf, ok := ret.Get(1).(func(*ssm.UpdatePatchBaselineInput) *ssm.UpdatePatchBaselineOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ssm.UpdatePatchBaselineOutput)
		}
	}

	return r0, r1
}

// UpdatePatchBaselineWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) UpdatePatchBaselineWithContext(_a0 aws.Context, _a1 *ssm.UpdatePatchBaselineInput, _a2 ...request.Option) (*ssm.UpdatePatchBaselineOutput, 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 *ssm.UpdatePatchBaselineOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ssm.UpdatePatchBaselineInput, ...request.Option) *ssm.UpdatePatchBaselineOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.UpdatePatchBaselineOutput)
		}
	}

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

	return r0, r1
}
