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

package mocks

import (
	context "context"

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

	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
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.AddTagsToResourceInput) (*ssm.AddTagsToResourceOutput, error)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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
	var r1 *ssm.AddTagsToResourceOutput
	if rf, ok := ret.Get(0).(func(*ssm.AddTagsToResourceInput) (*request.Request, *ssm.AddTagsToResourceOutput)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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 context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.AddTagsToResourceInput, ...request.Option) (*ssm.AddTagsToResourceOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.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)
		}
	}

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

	return r0, r1
}

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

	var r0 *ssm.AssociateOpsItemRelatedItemOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.AssociateOpsItemRelatedItemInput) (*ssm.AssociateOpsItemRelatedItemOutput, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(*ssm.AssociateOpsItemRelatedItemInput) *ssm.AssociateOpsItemRelatedItemOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.AssociateOpsItemRelatedItemOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// AssociateOpsItemRelatedItemWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) AssociateOpsItemRelatedItemWithContext(_a0 context.Context, _a1 *ssm.AssociateOpsItemRelatedItemInput, _a2 ...request.Option) (*ssm.AssociateOpsItemRelatedItemOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := 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.AssociateOpsItemRelatedItemOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.AssociateOpsItemRelatedItemInput, ...request.Option) (*ssm.AssociateOpsItemRelatedItemOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.AssociateOpsItemRelatedItemInput, ...request.Option) *ssm.AssociateOpsItemRelatedItemOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.AssociateOpsItemRelatedItemOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ssm.AssociateOpsItemRelatedItemInput, ...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
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.CancelCommandInput) (*ssm.CancelCommandOutput, error)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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
	var r1 *ssm.CancelCommandOutput
	if rf, ok := ret.Get(0).(func(*ssm.CancelCommandInput) (*request.Request, *ssm.CancelCommandOutput)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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 context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.CancelCommandInput, ...request.Option) (*ssm.CancelCommandOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.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)
		}
	}

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

	return r0, r1
}

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

	var r0 *ssm.CancelMaintenanceWindowExecutionOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.CancelMaintenanceWindowExecutionInput) (*ssm.CancelMaintenanceWindowExecutionOutput, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(*ssm.CancelMaintenanceWindowExecutionInput) *ssm.CancelMaintenanceWindowExecutionOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.CancelMaintenanceWindowExecutionOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// CancelMaintenanceWindowExecutionWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) CancelMaintenanceWindowExecutionWithContext(_a0 context.Context, _a1 *ssm.CancelMaintenanceWindowExecutionInput, _a2 ...request.Option) (*ssm.CancelMaintenanceWindowExecutionOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := 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.CancelMaintenanceWindowExecutionOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.CancelMaintenanceWindowExecutionInput, ...request.Option) (*ssm.CancelMaintenanceWindowExecutionOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.CancelMaintenanceWindowExecutionInput, ...request.Option) *ssm.CancelMaintenanceWindowExecutionOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.CancelMaintenanceWindowExecutionOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ssm.CancelMaintenanceWindowExecutionInput, ...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
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.CreateActivationInput) (*ssm.CreateActivationOutput, error)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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
	var r1 *ssm.CreateActivationOutput
	if rf, ok := ret.Get(0).(func(*ssm.CreateActivationInput) (*request.Request, *ssm.CreateActivationOutput)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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 context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.CreateActivationInput, ...request.Option) (*ssm.CreateActivationOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.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)
		}
	}

	if rf, ok := ret.Get(1).(func(context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.CreateAssociationInput) (*ssm.CreateAssociationOutput, error)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.CreateAssociationBatchInput) (*ssm.CreateAssociationBatchOutput, error)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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
	var r1 *ssm.CreateAssociationBatchOutput
	if rf, ok := ret.Get(0).(func(*ssm.CreateAssociationBatchInput) (*request.Request, *ssm.CreateAssociationBatchOutput)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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 context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.CreateAssociationBatchInput, ...request.Option) (*ssm.CreateAssociationBatchOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.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)
		}
	}

	if rf, ok := ret.Get(1).(func(context.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
	var r1 *ssm.CreateAssociationOutput
	if rf, ok := ret.Get(0).(func(*ssm.CreateAssociationInput) (*request.Request, *ssm.CreateAssociationOutput)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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 context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.CreateAssociationInput, ...request.Option) (*ssm.CreateAssociationOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.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)
		}
	}

	if rf, ok := ret.Get(1).(func(context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.CreateDocumentInput) (*ssm.CreateDocumentOutput, error)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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
	var r1 *ssm.CreateDocumentOutput
	if rf, ok := ret.Get(0).(func(*ssm.CreateDocumentInput) (*request.Request, *ssm.CreateDocumentOutput)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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 context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.CreateDocumentInput, ...request.Option) (*ssm.CreateDocumentOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.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)
		}
	}

	if rf, ok := ret.Get(1).(func(context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.CreateMaintenanceWindowInput) (*ssm.CreateMaintenanceWindowOutput, error)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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
	var r1 *ssm.CreateMaintenanceWindowOutput
	if rf, ok := ret.Get(0).(func(*ssm.CreateMaintenanceWindowInput) (*request.Request, *ssm.CreateMaintenanceWindowOutput)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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 context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.CreateMaintenanceWindowInput, ...request.Option) (*ssm.CreateMaintenanceWindowOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.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)
		}
	}

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

	return r0, r1
}

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

	var r0 *ssm.CreateOpsItemOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.CreateOpsItemInput) (*ssm.CreateOpsItemOutput, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(*ssm.CreateOpsItemInput) *ssm.CreateOpsItemOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.CreateOpsItemOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// CreateOpsItemWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) CreateOpsItemWithContext(_a0 context.Context, _a1 *ssm.CreateOpsItemInput, _a2 ...request.Option) (*ssm.CreateOpsItemOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := 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.CreateOpsItemOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.CreateOpsItemInput, ...request.Option) (*ssm.CreateOpsItemOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.CreateOpsItemInput, ...request.Option) *ssm.CreateOpsItemOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.CreateOpsItemOutput)
		}
	}

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

	return r0, r1
}

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

	var r0 *ssm.CreateOpsMetadataOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.CreateOpsMetadataInput) (*ssm.CreateOpsMetadataOutput, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(*ssm.CreateOpsMetadataInput) *ssm.CreateOpsMetadataOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.CreateOpsMetadataOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// CreateOpsMetadataWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) CreateOpsMetadataWithContext(_a0 context.Context, _a1 *ssm.CreateOpsMetadataInput, _a2 ...request.Option) (*ssm.CreateOpsMetadataOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := 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.CreateOpsMetadataOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.CreateOpsMetadataInput, ...request.Option) (*ssm.CreateOpsMetadataOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.CreateOpsMetadataInput, ...request.Option) *ssm.CreateOpsMetadataOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.CreateOpsMetadataOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ssm.CreateOpsMetadataInput, ...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
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.CreatePatchBaselineInput) (*ssm.CreatePatchBaselineOutput, error)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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
	var r1 *ssm.CreatePatchBaselineOutput
	if rf, ok := ret.Get(0).(func(*ssm.CreatePatchBaselineInput) (*request.Request, *ssm.CreatePatchBaselineOutput)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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 context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.CreatePatchBaselineInput, ...request.Option) (*ssm.CreatePatchBaselineOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.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)
		}
	}

	if rf, ok := ret.Get(1).(func(context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.CreateResourceDataSyncInput) (*ssm.CreateResourceDataSyncOutput, error)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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
	var r1 *ssm.CreateResourceDataSyncOutput
	if rf, ok := ret.Get(0).(func(*ssm.CreateResourceDataSyncInput) (*request.Request, *ssm.CreateResourceDataSyncOutput)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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 context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.CreateResourceDataSyncInput, ...request.Option) (*ssm.CreateResourceDataSyncOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.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)
		}
	}

	if rf, ok := ret.Get(1).(func(context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.DeleteActivationInput) (*ssm.DeleteActivationOutput, error)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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
	var r1 *ssm.DeleteActivationOutput
	if rf, ok := ret.Get(0).(func(*ssm.DeleteActivationInput) (*request.Request, *ssm.DeleteActivationOutput)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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 context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DeleteActivationInput, ...request.Option) (*ssm.DeleteActivationOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.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)
		}
	}

	if rf, ok := ret.Get(1).(func(context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.DeleteAssociationInput) (*ssm.DeleteAssociationOutput, error)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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
	var r1 *ssm.DeleteAssociationOutput
	if rf, ok := ret.Get(0).(func(*ssm.DeleteAssociationInput) (*request.Request, *ssm.DeleteAssociationOutput)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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 context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DeleteAssociationInput, ...request.Option) (*ssm.DeleteAssociationOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.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)
		}
	}

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

	return r0, r1
}

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

	var r0 *ssm.DeleteCommandsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.DeleteCommandsInput) (*ssm.DeleteCommandsOutput, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(*ssm.DeleteCommandsInput) *ssm.DeleteCommandsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.DeleteCommandsOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// DeleteCommandsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) DeleteCommandsWithContext(_a0 context.Context, _a1 *ssm.DeleteCommandsInput, _a2 ...request.Option) (*ssm.DeleteCommandsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := 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.DeleteCommandsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DeleteCommandsInput, ...request.Option) (*ssm.DeleteCommandsOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DeleteCommandsInput, ...request.Option) *ssm.DeleteCommandsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.DeleteCommandsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ssm.DeleteCommandsInput, ...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
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.DeleteDocumentInput) (*ssm.DeleteDocumentOutput, error)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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
	var r1 *ssm.DeleteDocumentOutput
	if rf, ok := ret.Get(0).(func(*ssm.DeleteDocumentInput) (*request.Request, *ssm.DeleteDocumentOutput)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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 context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DeleteDocumentInput, ...request.Option) (*ssm.DeleteDocumentOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.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)
		}
	}

	if rf, ok := ret.Get(1).(func(context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.DeleteInventoryInput) (*ssm.DeleteInventoryOutput, error)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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
	var r1 *ssm.DeleteInventoryOutput
	if rf, ok := ret.Get(0).(func(*ssm.DeleteInventoryInput) (*request.Request, *ssm.DeleteInventoryOutput)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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 context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DeleteInventoryInput, ...request.Option) (*ssm.DeleteInventoryOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.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)
		}
	}

	if rf, ok := ret.Get(1).(func(context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.DeleteMaintenanceWindowInput) (*ssm.DeleteMaintenanceWindowOutput, error)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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
	var r1 *ssm.DeleteMaintenanceWindowOutput
	if rf, ok := ret.Get(0).(func(*ssm.DeleteMaintenanceWindowInput) (*request.Request, *ssm.DeleteMaintenanceWindowOutput)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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 context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DeleteMaintenanceWindowInput, ...request.Option) (*ssm.DeleteMaintenanceWindowOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.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)
		}
	}

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

	return r0, r1
}

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

	var r0 *ssm.DeleteOpsMetadataOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.DeleteOpsMetadataInput) (*ssm.DeleteOpsMetadataOutput, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(*ssm.DeleteOpsMetadataInput) *ssm.DeleteOpsMetadataOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.DeleteOpsMetadataOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// DeleteOpsMetadataWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) DeleteOpsMetadataWithContext(_a0 context.Context, _a1 *ssm.DeleteOpsMetadataInput, _a2 ...request.Option) (*ssm.DeleteOpsMetadataOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := 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.DeleteOpsMetadataOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DeleteOpsMetadataInput, ...request.Option) (*ssm.DeleteOpsMetadataOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DeleteOpsMetadataInput, ...request.Option) *ssm.DeleteOpsMetadataOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.DeleteOpsMetadataOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ssm.DeleteOpsMetadataInput, ...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
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.DeleteParameterInput) (*ssm.DeleteParameterOutput, error)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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
	var r1 *ssm.DeleteParameterOutput
	if rf, ok := ret.Get(0).(func(*ssm.DeleteParameterInput) (*request.Request, *ssm.DeleteParameterOutput)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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 context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DeleteParameterInput, ...request.Option) (*ssm.DeleteParameterOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.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)
		}
	}

	if rf, ok := ret.Get(1).(func(context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.DeleteParametersInput) (*ssm.DeleteParametersOutput, error)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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
	var r1 *ssm.DeleteParametersOutput
	if rf, ok := ret.Get(0).(func(*ssm.DeleteParametersInput) (*request.Request, *ssm.DeleteParametersOutput)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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 context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DeleteParametersInput, ...request.Option) (*ssm.DeleteParametersOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.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)
		}
	}

	if rf, ok := ret.Get(1).(func(context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.DeletePatchBaselineInput) (*ssm.DeletePatchBaselineOutput, error)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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
	var r1 *ssm.DeletePatchBaselineOutput
	if rf, ok := ret.Get(0).(func(*ssm.DeletePatchBaselineInput) (*request.Request, *ssm.DeletePatchBaselineOutput)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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 context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DeletePatchBaselineInput, ...request.Option) (*ssm.DeletePatchBaselineOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.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)
		}
	}

	if rf, ok := ret.Get(1).(func(context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.DeleteResourceDataSyncInput) (*ssm.DeleteResourceDataSyncOutput, error)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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
	var r1 *ssm.DeleteResourceDataSyncOutput
	if rf, ok := ret.Get(0).(func(*ssm.DeleteResourceDataSyncInput) (*request.Request, *ssm.DeleteResourceDataSyncOutput)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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 context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DeleteResourceDataSyncInput, ...request.Option) (*ssm.DeleteResourceDataSyncOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.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)
		}
	}

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

	return r0, r1
}

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

	var r0 *ssm.DeleteResourcePolicyOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.DeleteResourcePolicyInput) (*ssm.DeleteResourcePolicyOutput, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(*ssm.DeleteResourcePolicyInput) *ssm.DeleteResourcePolicyOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.DeleteResourcePolicyOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// DeleteResourcePolicyWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) DeleteResourcePolicyWithContext(_a0 context.Context, _a1 *ssm.DeleteResourcePolicyInput, _a2 ...request.Option) (*ssm.DeleteResourcePolicyOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := 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.DeleteResourcePolicyOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DeleteResourcePolicyInput, ...request.Option) (*ssm.DeleteResourcePolicyOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DeleteResourcePolicyInput, ...request.Option) *ssm.DeleteResourcePolicyOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.DeleteResourcePolicyOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ssm.DeleteResourcePolicyInput, ...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
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.DeregisterManagedInstanceInput) (*ssm.DeregisterManagedInstanceOutput, error)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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
	var r1 *ssm.DeregisterManagedInstanceOutput
	if rf, ok := ret.Get(0).(func(*ssm.DeregisterManagedInstanceInput) (*request.Request, *ssm.DeregisterManagedInstanceOutput)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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 context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DeregisterManagedInstanceInput, ...request.Option) (*ssm.DeregisterManagedInstanceOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.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)
		}
	}

	if rf, ok := ret.Get(1).(func(context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.DeregisterPatchBaselineForPatchGroupInput) (*ssm.DeregisterPatchBaselineForPatchGroupOutput, error)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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
	var r1 *ssm.DeregisterPatchBaselineForPatchGroupOutput
	if rf, ok := ret.Get(0).(func(*ssm.DeregisterPatchBaselineForPatchGroupInput) (*request.Request, *ssm.DeregisterPatchBaselineForPatchGroupOutput)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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 context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DeregisterPatchBaselineForPatchGroupInput, ...request.Option) (*ssm.DeregisterPatchBaselineForPatchGroupOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.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)
		}
	}

	if rf, ok := ret.Get(1).(func(context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.DeregisterTargetFromMaintenanceWindowInput) (*ssm.DeregisterTargetFromMaintenanceWindowOutput, error)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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
	var r1 *ssm.DeregisterTargetFromMaintenanceWindowOutput
	if rf, ok := ret.Get(0).(func(*ssm.DeregisterTargetFromMaintenanceWindowInput) (*request.Request, *ssm.DeregisterTargetFromMaintenanceWindowOutput)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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 context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DeregisterTargetFromMaintenanceWindowInput, ...request.Option) (*ssm.DeregisterTargetFromMaintenanceWindowOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.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)
		}
	}

	if rf, ok := ret.Get(1).(func(context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.DeregisterTaskFromMaintenanceWindowInput) (*ssm.DeregisterTaskFromMaintenanceWindowOutput, error)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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
	var r1 *ssm.DeregisterTaskFromMaintenanceWindowOutput
	if rf, ok := ret.Get(0).(func(*ssm.DeregisterTaskFromMaintenanceWindowInput) (*request.Request, *ssm.DeregisterTaskFromMaintenanceWindowOutput)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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 context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DeregisterTaskFromMaintenanceWindowInput, ...request.Option) (*ssm.DeregisterTaskFromMaintenanceWindowOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.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)
		}
	}

	if rf, ok := ret.Get(1).(func(context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.DescribeActivationsInput) (*ssm.DescribeActivationsOutput, error)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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 context.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(context.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
	var r1 *ssm.DescribeActivationsOutput
	if rf, ok := ret.Get(0).(func(*ssm.DescribeActivationsInput) (*request.Request, *ssm.DescribeActivationsOutput)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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 context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeActivationsInput, ...request.Option) (*ssm.DescribeActivationsOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.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)
		}
	}

	if rf, ok := ret.Get(1).(func(context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.DescribeAssociationInput) (*ssm.DescribeAssociationOutput, error)); ok {
		return rf(_a0)
	}
	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)
		}
	}

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

	return r0, r1
}

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

	var r0 *ssm.DescribeAssociationExecutionTargetsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.DescribeAssociationExecutionTargetsInput) (*ssm.DescribeAssociationExecutionTargetsOutput, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(*ssm.DescribeAssociationExecutionTargetsInput) *ssm.DescribeAssociationExecutionTargetsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.DescribeAssociationExecutionTargetsOutput)
		}
	}

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

	return r0, r1
}

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

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

	return r0
}

// DescribeAssociationExecutionTargetsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *SSMAPI) DescribeAssociationExecutionTargetsPagesWithContext(_a0 context.Context, _a1 *ssm.DescribeAssociationExecutionTargetsInput, _a2 func(*ssm.DescribeAssociationExecutionTargetsOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeAssociationExecutionTargetsInput, func(*ssm.DescribeAssociationExecutionTargetsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

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

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

	return r0, r1
}

// DescribeAssociationExecutionTargetsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) DescribeAssociationExecutionTargetsWithContext(_a0 context.Context, _a1 *ssm.DescribeAssociationExecutionTargetsInput, _a2 ...request.Option) (*ssm.DescribeAssociationExecutionTargetsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := 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.DescribeAssociationExecutionTargetsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeAssociationExecutionTargetsInput, ...request.Option) (*ssm.DescribeAssociationExecutionTargetsOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeAssociationExecutionTargetsInput, ...request.Option) *ssm.DescribeAssociationExecutionTargetsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.DescribeAssociationExecutionTargetsOutput)
		}
	}

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

	return r0, r1
}

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

	var r0 *ssm.DescribeAssociationExecutionsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.DescribeAssociationExecutionsInput) (*ssm.DescribeAssociationExecutionsOutput, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(*ssm.DescribeAssociationExecutionsInput) *ssm.DescribeAssociationExecutionsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.DescribeAssociationExecutionsOutput)
		}
	}

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

	return r0, r1
}

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

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

	return r0
}

// DescribeAssociationExecutionsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *SSMAPI) DescribeAssociationExecutionsPagesWithContext(_a0 context.Context, _a1 *ssm.DescribeAssociationExecutionsInput, _a2 func(*ssm.DescribeAssociationExecutionsOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeAssociationExecutionsInput, func(*ssm.DescribeAssociationExecutionsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

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

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

	return r0, r1
}

// DescribeAssociationExecutionsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) DescribeAssociationExecutionsWithContext(_a0 context.Context, _a1 *ssm.DescribeAssociationExecutionsInput, _a2 ...request.Option) (*ssm.DescribeAssociationExecutionsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := 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.DescribeAssociationExecutionsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeAssociationExecutionsInput, ...request.Option) (*ssm.DescribeAssociationExecutionsOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeAssociationExecutionsInput, ...request.Option) *ssm.DescribeAssociationExecutionsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.DescribeAssociationExecutionsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ssm.DescribeAssociationExecutionsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} 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
	var r1 *ssm.DescribeAssociationOutput
	if rf, ok := ret.Get(0).(func(*ssm.DescribeAssociationInput) (*request.Request, *ssm.DescribeAssociationOutput)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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 context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeAssociationInput, ...request.Option) (*ssm.DescribeAssociationOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.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)
		}
	}

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

	return r0, r1
}

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

	var r0 *ssm.DescribeAutomationActionsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.DescribeAutomationActionsInput) (*ssm.DescribeAutomationActionsOutput, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(*ssm.DescribeAutomationActionsInput) *ssm.DescribeAutomationActionsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.DescribeAutomationActionsOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// DescribeAutomationActionsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) DescribeAutomationActionsWithContext(_a0 context.Context, _a1 *ssm.DescribeAutomationActionsInput, _a2 ...request.Option) (*ssm.DescribeAutomationActionsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := 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.DescribeAutomationActionsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeAutomationActionsInput, ...request.Option) (*ssm.DescribeAutomationActionsOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeAutomationActionsInput, ...request.Option) *ssm.DescribeAutomationActionsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.DescribeAutomationActionsOutput)
		}
	}

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

	return r0, r1
}

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

	var r0 *ssm.DescribeAutomationExecutionParametersOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.DescribeAutomationExecutionParametersInput) (*ssm.DescribeAutomationExecutionParametersOutput, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(*ssm.DescribeAutomationExecutionParametersInput) *ssm.DescribeAutomationExecutionParametersOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.DescribeAutomationExecutionParametersOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// DescribeAutomationExecutionParametersWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) DescribeAutomationExecutionParametersWithContext(_a0 context.Context, _a1 *ssm.DescribeAutomationExecutionParametersInput, _a2 ...request.Option) (*ssm.DescribeAutomationExecutionParametersOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := 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.DescribeAutomationExecutionParametersOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeAutomationExecutionParametersInput, ...request.Option) (*ssm.DescribeAutomationExecutionParametersOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeAutomationExecutionParametersInput, ...request.Option) *ssm.DescribeAutomationExecutionParametersOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.DescribeAutomationExecutionParametersOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ssm.DescribeAutomationExecutionParametersInput, ...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
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.DescribeAutomationExecutionsInput) (*ssm.DescribeAutomationExecutionsOutput, error)); ok {
		return rf(_a0)
	}
	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)
		}
	}

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

	return r0, r1
}

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

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

	return r0
}

// DescribeAutomationExecutionsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *SSMAPI) DescribeAutomationExecutionsPagesWithContext(_a0 context.Context, _a1 *ssm.DescribeAutomationExecutionsInput, _a2 func(*ssm.DescribeAutomationExecutionsOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeAutomationExecutionsInput, func(*ssm.DescribeAutomationExecutionsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// 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
	var r1 *ssm.DescribeAutomationExecutionsOutput
	if rf, ok := ret.Get(0).(func(*ssm.DescribeAutomationExecutionsInput) (*request.Request, *ssm.DescribeAutomationExecutionsOutput)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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 context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeAutomationExecutionsInput, ...request.Option) (*ssm.DescribeAutomationExecutionsOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.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)
		}
	}

	if rf, ok := ret.Get(1).(func(context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.DescribeAutomationStepExecutionsInput) (*ssm.DescribeAutomationStepExecutionsOutput, error)); ok {
		return rf(_a0)
	}
	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)
		}
	}

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

	return r0, r1
}

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

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

	return r0
}

// DescribeAutomationStepExecutionsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *SSMAPI) DescribeAutomationStepExecutionsPagesWithContext(_a0 context.Context, _a1 *ssm.DescribeAutomationStepExecutionsInput, _a2 func(*ssm.DescribeAutomationStepExecutionsOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeAutomationStepExecutionsInput, func(*ssm.DescribeAutomationStepExecutionsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// 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
	var r1 *ssm.DescribeAutomationStepExecutionsOutput
	if rf, ok := ret.Get(0).(func(*ssm.DescribeAutomationStepExecutionsInput) (*request.Request, *ssm.DescribeAutomationStepExecutionsOutput)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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 context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeAutomationStepExecutionsInput, ...request.Option) (*ssm.DescribeAutomationStepExecutionsOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.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)
		}
	}

	if rf, ok := ret.Get(1).(func(context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.DescribeAvailablePatchesInput) (*ssm.DescribeAvailablePatchesOutput, error)); ok {
		return rf(_a0)
	}
	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)
		}
	}

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

	return r0, r1
}

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

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

	return r0
}

// DescribeAvailablePatchesPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *SSMAPI) DescribeAvailablePatchesPagesWithContext(_a0 context.Context, _a1 *ssm.DescribeAvailablePatchesInput, _a2 func(*ssm.DescribeAvailablePatchesOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeAvailablePatchesInput, func(*ssm.DescribeAvailablePatchesOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// 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
	var r1 *ssm.DescribeAvailablePatchesOutput
	if rf, ok := ret.Get(0).(func(*ssm.DescribeAvailablePatchesInput) (*request.Request, *ssm.DescribeAvailablePatchesOutput)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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 context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeAvailablePatchesInput, ...request.Option) (*ssm.DescribeAvailablePatchesOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.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)
		}
	}

	if rf, ok := ret.Get(1).(func(context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.DescribeDocumentInput) (*ssm.DescribeDocumentOutput, error)); ok {
		return rf(_a0)
	}
	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)
		}
	}

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

	return r0, r1
}

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

	var r0 *ssm.DescribeDocumentInternalOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.DescribeDocumentInternalInput) (*ssm.DescribeDocumentInternalOutput, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(*ssm.DescribeDocumentInternalInput) *ssm.DescribeDocumentInternalOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.DescribeDocumentInternalOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// DescribeDocumentInternalWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) DescribeDocumentInternalWithContext(_a0 context.Context, _a1 *ssm.DescribeDocumentInternalInput, _a2 ...request.Option) (*ssm.DescribeDocumentInternalOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := 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.DescribeDocumentInternalOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeDocumentInternalInput, ...request.Option) (*ssm.DescribeDocumentInternalOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeDocumentInternalInput, ...request.Option) *ssm.DescribeDocumentInternalOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.DescribeDocumentInternalOutput)
		}
	}

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

	return r0, r1
}

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

	var r0 *ssm.DescribeDocumentParametersOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.DescribeDocumentParametersInput) (*ssm.DescribeDocumentParametersOutput, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(*ssm.DescribeDocumentParametersInput) *ssm.DescribeDocumentParametersOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.DescribeDocumentParametersOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// DescribeDocumentParametersWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) DescribeDocumentParametersWithContext(_a0 context.Context, _a1 *ssm.DescribeDocumentParametersInput, _a2 ...request.Option) (*ssm.DescribeDocumentParametersOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := 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.DescribeDocumentParametersOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeDocumentParametersInput, ...request.Option) (*ssm.DescribeDocumentParametersOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeDocumentParametersInput, ...request.Option) *ssm.DescribeDocumentParametersOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.DescribeDocumentParametersOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ssm.DescribeDocumentParametersInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} 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
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.DescribeDocumentPermissionInput) (*ssm.DescribeDocumentPermissionOutput, error)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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
	var r1 *ssm.DescribeDocumentPermissionOutput
	if rf, ok := ret.Get(0).(func(*ssm.DescribeDocumentPermissionInput) (*request.Request, *ssm.DescribeDocumentPermissionOutput)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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 context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeDocumentPermissionInput, ...request.Option) (*ssm.DescribeDocumentPermissionOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.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)
		}
	}

	if rf, ok := ret.Get(1).(func(context.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
	var r1 *ssm.DescribeDocumentOutput
	if rf, ok := ret.Get(0).(func(*ssm.DescribeDocumentInput) (*request.Request, *ssm.DescribeDocumentOutput)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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
}

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

	var r0 *ssm.DescribeDocumentSchemaOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.DescribeDocumentSchemaInput) (*ssm.DescribeDocumentSchemaOutput, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(*ssm.DescribeDocumentSchemaInput) *ssm.DescribeDocumentSchemaOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.DescribeDocumentSchemaOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// DescribeDocumentSchemaWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) DescribeDocumentSchemaWithContext(_a0 context.Context, _a1 *ssm.DescribeDocumentSchemaInput, _a2 ...request.Option) (*ssm.DescribeDocumentSchemaOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := 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.DescribeDocumentSchemaOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeDocumentSchemaInput, ...request.Option) (*ssm.DescribeDocumentSchemaOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeDocumentSchemaInput, ...request.Option) *ssm.DescribeDocumentSchemaOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.DescribeDocumentSchemaOutput)
		}
	}

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

	return r0, r1
}

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

	var r0 *ssm.DescribeDocumentStepSchemaOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.DescribeDocumentStepSchemaInput) (*ssm.DescribeDocumentStepSchemaOutput, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(*ssm.DescribeDocumentStepSchemaInput) *ssm.DescribeDocumentStepSchemaOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.DescribeDocumentStepSchemaOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// DescribeDocumentStepSchemaWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) DescribeDocumentStepSchemaWithContext(_a0 context.Context, _a1 *ssm.DescribeDocumentStepSchemaInput, _a2 ...request.Option) (*ssm.DescribeDocumentStepSchemaOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := 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.DescribeDocumentStepSchemaOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeDocumentStepSchemaInput, ...request.Option) (*ssm.DescribeDocumentStepSchemaOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeDocumentStepSchemaInput, ...request.Option) *ssm.DescribeDocumentStepSchemaOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.DescribeDocumentStepSchemaOutput)
		}
	}

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

	return r0, r1
}

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

	var r0 *ssm.DescribeDocumentStepsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.DescribeDocumentStepsInput) (*ssm.DescribeDocumentStepsOutput, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(*ssm.DescribeDocumentStepsInput) *ssm.DescribeDocumentStepsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.DescribeDocumentStepsOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// DescribeDocumentStepsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) DescribeDocumentStepsWithContext(_a0 context.Context, _a1 *ssm.DescribeDocumentStepsInput, _a2 ...request.Option) (*ssm.DescribeDocumentStepsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := 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.DescribeDocumentStepsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeDocumentStepsInput, ...request.Option) (*ssm.DescribeDocumentStepsOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeDocumentStepsInput, ...request.Option) *ssm.DescribeDocumentStepsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.DescribeDocumentStepsOutput)
		}
	}

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

	return r0, r1
}

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

	if rf, ok := ret.Get(1).(func(context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.DescribeEffectiveInstanceAssociationsInput) (*ssm.DescribeEffectiveInstanceAssociationsOutput, error)); ok {
		return rf(_a0)
	}
	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)
		}
	}

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

	return r0, r1
}

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

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

	return r0
}

// DescribeEffectiveInstanceAssociationsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *SSMAPI) DescribeEffectiveInstanceAssociationsPagesWithContext(_a0 context.Context, _a1 *ssm.DescribeEffectiveInstanceAssociationsInput, _a2 func(*ssm.DescribeEffectiveInstanceAssociationsOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeEffectiveInstanceAssociationsInput, func(*ssm.DescribeEffectiveInstanceAssociationsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// 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
	var r1 *ssm.DescribeEffectiveInstanceAssociationsOutput
	if rf, ok := ret.Get(0).(func(*ssm.DescribeEffectiveInstanceAssociationsInput) (*request.Request, *ssm.DescribeEffectiveInstanceAssociationsOutput)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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 context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeEffectiveInstanceAssociationsInput, ...request.Option) (*ssm.DescribeEffectiveInstanceAssociationsOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.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)
		}
	}

	if rf, ok := ret.Get(1).(func(context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.DescribeEffectivePatchesForPatchBaselineInput) (*ssm.DescribeEffectivePatchesForPatchBaselineOutput, error)); ok {
		return rf(_a0)
	}
	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)
		}
	}

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

	return r0, r1
}

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

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

	return r0
}

// DescribeEffectivePatchesForPatchBaselinePagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *SSMAPI) DescribeEffectivePatchesForPatchBaselinePagesWithContext(_a0 context.Context, _a1 *ssm.DescribeEffectivePatchesForPatchBaselineInput, _a2 func(*ssm.DescribeEffectivePatchesForPatchBaselineOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeEffectivePatchesForPatchBaselineInput, func(*ssm.DescribeEffectivePatchesForPatchBaselineOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// 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
	var r1 *ssm.DescribeEffectivePatchesForPatchBaselineOutput
	if rf, ok := ret.Get(0).(func(*ssm.DescribeEffectivePatchesForPatchBaselineInput) (*request.Request, *ssm.DescribeEffectivePatchesForPatchBaselineOutput)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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 context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeEffectivePatchesForPatchBaselineInput, ...request.Option) (*ssm.DescribeEffectivePatchesForPatchBaselineOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.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)
		}
	}

	if rf, ok := ret.Get(1).(func(context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.DescribeInstanceAssociationsStatusInput) (*ssm.DescribeInstanceAssociationsStatusOutput, error)); ok {
		return rf(_a0)
	}
	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)
		}
	}

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

	return r0, r1
}

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

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

	return r0
}

// DescribeInstanceAssociationsStatusPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *SSMAPI) DescribeInstanceAssociationsStatusPagesWithContext(_a0 context.Context, _a1 *ssm.DescribeInstanceAssociationsStatusInput, _a2 func(*ssm.DescribeInstanceAssociationsStatusOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeInstanceAssociationsStatusInput, func(*ssm.DescribeInstanceAssociationsStatusOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// 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
	var r1 *ssm.DescribeInstanceAssociationsStatusOutput
	if rf, ok := ret.Get(0).(func(*ssm.DescribeInstanceAssociationsStatusInput) (*request.Request, *ssm.DescribeInstanceAssociationsStatusOutput)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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 context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeInstanceAssociationsStatusInput, ...request.Option) (*ssm.DescribeInstanceAssociationsStatusOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.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)
		}
	}

	if rf, ok := ret.Get(1).(func(context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.DescribeInstanceInformationInput) (*ssm.DescribeInstanceInformationOutput, error)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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 context.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(context.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
	var r1 *ssm.DescribeInstanceInformationOutput
	if rf, ok := ret.Get(0).(func(*ssm.DescribeInstanceInformationInput) (*request.Request, *ssm.DescribeInstanceInformationOutput)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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 context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeInstanceInformationInput, ...request.Option) (*ssm.DescribeInstanceInformationOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.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)
		}
	}

	if rf, ok := ret.Get(1).(func(context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.DescribeInstancePatchStatesInput) (*ssm.DescribeInstancePatchStatesOutput, error)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.DescribeInstancePatchStatesForPatchGroupInput) (*ssm.DescribeInstancePatchStatesForPatchGroupOutput, error)); ok {
		return rf(_a0)
	}
	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)
		}
	}

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

	return r0, r1
}

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

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

	return r0
}

// DescribeInstancePatchStatesForPatchGroupPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *SSMAPI) DescribeInstancePatchStatesForPatchGroupPagesWithContext(_a0 context.Context, _a1 *ssm.DescribeInstancePatchStatesForPatchGroupInput, _a2 func(*ssm.DescribeInstancePatchStatesForPatchGroupOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeInstancePatchStatesForPatchGroupInput, func(*ssm.DescribeInstancePatchStatesForPatchGroupOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// 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
	var r1 *ssm.DescribeInstancePatchStatesForPatchGroupOutput
	if rf, ok := ret.Get(0).(func(*ssm.DescribeInstancePatchStatesForPatchGroupInput) (*request.Request, *ssm.DescribeInstancePatchStatesForPatchGroupOutput)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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 context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeInstancePatchStatesForPatchGroupInput, ...request.Option) (*ssm.DescribeInstancePatchStatesForPatchGroupOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.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)
		}
	}

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

	return r0, r1
}

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

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

	return r0
}

// DescribeInstancePatchStatesPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *SSMAPI) DescribeInstancePatchStatesPagesWithContext(_a0 context.Context, _a1 *ssm.DescribeInstancePatchStatesInput, _a2 func(*ssm.DescribeInstancePatchStatesOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeInstancePatchStatesInput, func(*ssm.DescribeInstancePatchStatesOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// 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
	var r1 *ssm.DescribeInstancePatchStatesOutput
	if rf, ok := ret.Get(0).(func(*ssm.DescribeInstancePatchStatesInput) (*request.Request, *ssm.DescribeInstancePatchStatesOutput)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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 context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeInstancePatchStatesInput, ...request.Option) (*ssm.DescribeInstancePatchStatesOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.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)
		}
	}

	if rf, ok := ret.Get(1).(func(context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.DescribeInstancePatchesInput) (*ssm.DescribeInstancePatchesOutput, error)); ok {
		return rf(_a0)
	}
	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)
		}
	}

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

	return r0, r1
}

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

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

	return r0
}

// DescribeInstancePatchesPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *SSMAPI) DescribeInstancePatchesPagesWithContext(_a0 context.Context, _a1 *ssm.DescribeInstancePatchesInput, _a2 func(*ssm.DescribeInstancePatchesOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeInstancePatchesInput, func(*ssm.DescribeInstancePatchesOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// 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
	var r1 *ssm.DescribeInstancePatchesOutput
	if rf, ok := ret.Get(0).(func(*ssm.DescribeInstancePatchesInput) (*request.Request, *ssm.DescribeInstancePatchesOutput)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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 context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeInstancePatchesInput, ...request.Option) (*ssm.DescribeInstancePatchesOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.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)
		}
	}

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

	return r0, r1
}

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

	var r0 *ssm.DescribeInstancePropertiesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.DescribeInstancePropertiesInput) (*ssm.DescribeInstancePropertiesOutput, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(*ssm.DescribeInstancePropertiesInput) *ssm.DescribeInstancePropertiesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.DescribeInstancePropertiesOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// DescribeInstancePropertiesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) DescribeInstancePropertiesWithContext(_a0 context.Context, _a1 *ssm.DescribeInstancePropertiesInput, _a2 ...request.Option) (*ssm.DescribeInstancePropertiesOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := 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.DescribeInstancePropertiesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeInstancePropertiesInput, ...request.Option) (*ssm.DescribeInstancePropertiesOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeInstancePropertiesInput, ...request.Option) *ssm.DescribeInstancePropertiesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.DescribeInstancePropertiesOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ssm.DescribeInstancePropertiesInput, ...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
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.DescribeInventoryDeletionsInput) (*ssm.DescribeInventoryDeletionsOutput, error)); ok {
		return rf(_a0)
	}
	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)
		}
	}

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

	return r0, r1
}

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

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

	return r0
}

// DescribeInventoryDeletionsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *SSMAPI) DescribeInventoryDeletionsPagesWithContext(_a0 context.Context, _a1 *ssm.DescribeInventoryDeletionsInput, _a2 func(*ssm.DescribeInventoryDeletionsOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeInventoryDeletionsInput, func(*ssm.DescribeInventoryDeletionsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// 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
	var r1 *ssm.DescribeInventoryDeletionsOutput
	if rf, ok := ret.Get(0).(func(*ssm.DescribeInventoryDeletionsInput) (*request.Request, *ssm.DescribeInventoryDeletionsOutput)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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 context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeInventoryDeletionsInput, ...request.Option) (*ssm.DescribeInventoryDeletionsOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.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)
		}
	}

	if rf, ok := ret.Get(1).(func(context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.DescribeMaintenanceWindowExecutionTaskInvocationsInput) (*ssm.DescribeMaintenanceWindowExecutionTaskInvocationsOutput, error)); ok {
		return rf(_a0)
	}
	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)
		}
	}

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

	return r0, r1
}

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

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

	return r0
}

// DescribeMaintenanceWindowExecutionTaskInvocationsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *SSMAPI) DescribeMaintenanceWindowExecutionTaskInvocationsPagesWithContext(_a0 context.Context, _a1 *ssm.DescribeMaintenanceWindowExecutionTaskInvocationsInput, _a2 func(*ssm.DescribeMaintenanceWindowExecutionTaskInvocationsOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeMaintenanceWindowExecutionTaskInvocationsInput, func(*ssm.DescribeMaintenanceWindowExecutionTaskInvocationsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// 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
	var r1 *ssm.DescribeMaintenanceWindowExecutionTaskInvocationsOutput
	if rf, ok := ret.Get(0).(func(*ssm.DescribeMaintenanceWindowExecutionTaskInvocationsInput) (*request.Request, *ssm.DescribeMaintenanceWindowExecutionTaskInvocationsOutput)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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 context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeMaintenanceWindowExecutionTaskInvocationsInput, ...request.Option) (*ssm.DescribeMaintenanceWindowExecutionTaskInvocationsOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.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)
		}
	}

	if rf, ok := ret.Get(1).(func(context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.DescribeMaintenanceWindowExecutionTasksInput) (*ssm.DescribeMaintenanceWindowExecutionTasksOutput, error)); ok {
		return rf(_a0)
	}
	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)
		}
	}

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

	return r0, r1
}

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

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

	return r0
}

// DescribeMaintenanceWindowExecutionTasksPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *SSMAPI) DescribeMaintenanceWindowExecutionTasksPagesWithContext(_a0 context.Context, _a1 *ssm.DescribeMaintenanceWindowExecutionTasksInput, _a2 func(*ssm.DescribeMaintenanceWindowExecutionTasksOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeMaintenanceWindowExecutionTasksInput, func(*ssm.DescribeMaintenanceWindowExecutionTasksOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// 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
	var r1 *ssm.DescribeMaintenanceWindowExecutionTasksOutput
	if rf, ok := ret.Get(0).(func(*ssm.DescribeMaintenanceWindowExecutionTasksInput) (*request.Request, *ssm.DescribeMaintenanceWindowExecutionTasksOutput)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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 context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeMaintenanceWindowExecutionTasksInput, ...request.Option) (*ssm.DescribeMaintenanceWindowExecutionTasksOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.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)
		}
	}

	if rf, ok := ret.Get(1).(func(context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.DescribeMaintenanceWindowExecutionsInput) (*ssm.DescribeMaintenanceWindowExecutionsOutput, error)); ok {
		return rf(_a0)
	}
	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)
		}
	}

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

	return r0, r1
}

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

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

	return r0
}

// DescribeMaintenanceWindowExecutionsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *SSMAPI) DescribeMaintenanceWindowExecutionsPagesWithContext(_a0 context.Context, _a1 *ssm.DescribeMaintenanceWindowExecutionsInput, _a2 func(*ssm.DescribeMaintenanceWindowExecutionsOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeMaintenanceWindowExecutionsInput, func(*ssm.DescribeMaintenanceWindowExecutionsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// 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
	var r1 *ssm.DescribeMaintenanceWindowExecutionsOutput
	if rf, ok := ret.Get(0).(func(*ssm.DescribeMaintenanceWindowExecutionsInput) (*request.Request, *ssm.DescribeMaintenanceWindowExecutionsOutput)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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 context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeMaintenanceWindowExecutionsInput, ...request.Option) (*ssm.DescribeMaintenanceWindowExecutionsOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.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)
		}
	}

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

	return r0, r1
}

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

	var r0 *ssm.DescribeMaintenanceWindowScheduleOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.DescribeMaintenanceWindowScheduleInput) (*ssm.DescribeMaintenanceWindowScheduleOutput, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(*ssm.DescribeMaintenanceWindowScheduleInput) *ssm.DescribeMaintenanceWindowScheduleOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.DescribeMaintenanceWindowScheduleOutput)
		}
	}

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

	return r0, r1
}

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

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

	return r0
}

// DescribeMaintenanceWindowSchedulePagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *SSMAPI) DescribeMaintenanceWindowSchedulePagesWithContext(_a0 context.Context, _a1 *ssm.DescribeMaintenanceWindowScheduleInput, _a2 func(*ssm.DescribeMaintenanceWindowScheduleOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeMaintenanceWindowScheduleInput, func(*ssm.DescribeMaintenanceWindowScheduleOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

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

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

	return r0, r1
}

// DescribeMaintenanceWindowScheduleWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) DescribeMaintenanceWindowScheduleWithContext(_a0 context.Context, _a1 *ssm.DescribeMaintenanceWindowScheduleInput, _a2 ...request.Option) (*ssm.DescribeMaintenanceWindowScheduleOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := 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.DescribeMaintenanceWindowScheduleOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeMaintenanceWindowScheduleInput, ...request.Option) (*ssm.DescribeMaintenanceWindowScheduleOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeMaintenanceWindowScheduleInput, ...request.Option) *ssm.DescribeMaintenanceWindowScheduleOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.DescribeMaintenanceWindowScheduleOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ssm.DescribeMaintenanceWindowScheduleInput, ...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
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.DescribeMaintenanceWindowTargetsInput) (*ssm.DescribeMaintenanceWindowTargetsOutput, error)); ok {
		return rf(_a0)
	}
	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)
		}
	}

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

	return r0, r1
}

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

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

	return r0
}

// DescribeMaintenanceWindowTargetsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *SSMAPI) DescribeMaintenanceWindowTargetsPagesWithContext(_a0 context.Context, _a1 *ssm.DescribeMaintenanceWindowTargetsInput, _a2 func(*ssm.DescribeMaintenanceWindowTargetsOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeMaintenanceWindowTargetsInput, func(*ssm.DescribeMaintenanceWindowTargetsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// 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
	var r1 *ssm.DescribeMaintenanceWindowTargetsOutput
	if rf, ok := ret.Get(0).(func(*ssm.DescribeMaintenanceWindowTargetsInput) (*request.Request, *ssm.DescribeMaintenanceWindowTargetsOutput)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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 context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeMaintenanceWindowTargetsInput, ...request.Option) (*ssm.DescribeMaintenanceWindowTargetsOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.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)
		}
	}

	if rf, ok := ret.Get(1).(func(context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.DescribeMaintenanceWindowTasksInput) (*ssm.DescribeMaintenanceWindowTasksOutput, error)); ok {
		return rf(_a0)
	}
	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)
		}
	}

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

	return r0, r1
}

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

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

	return r0
}

// DescribeMaintenanceWindowTasksPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *SSMAPI) DescribeMaintenanceWindowTasksPagesWithContext(_a0 context.Context, _a1 *ssm.DescribeMaintenanceWindowTasksInput, _a2 func(*ssm.DescribeMaintenanceWindowTasksOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeMaintenanceWindowTasksInput, func(*ssm.DescribeMaintenanceWindowTasksOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// 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
	var r1 *ssm.DescribeMaintenanceWindowTasksOutput
	if rf, ok := ret.Get(0).(func(*ssm.DescribeMaintenanceWindowTasksInput) (*request.Request, *ssm.DescribeMaintenanceWindowTasksOutput)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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 context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeMaintenanceWindowTasksInput, ...request.Option) (*ssm.DescribeMaintenanceWindowTasksOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.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)
		}
	}

	if rf, ok := ret.Get(1).(func(context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.DescribeMaintenanceWindowsInput) (*ssm.DescribeMaintenanceWindowsOutput, error)); ok {
		return rf(_a0)
	}
	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)
		}
	}

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

	return r0, r1
}

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

	var r0 *ssm.DescribeMaintenanceWindowsForTargetOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.DescribeMaintenanceWindowsForTargetInput) (*ssm.DescribeMaintenanceWindowsForTargetOutput, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(*ssm.DescribeMaintenanceWindowsForTargetInput) *ssm.DescribeMaintenanceWindowsForTargetOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.DescribeMaintenanceWindowsForTargetOutput)
		}
	}

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

	return r0, r1
}

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

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

	return r0
}

// DescribeMaintenanceWindowsForTargetPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *SSMAPI) DescribeMaintenanceWindowsForTargetPagesWithContext(_a0 context.Context, _a1 *ssm.DescribeMaintenanceWindowsForTargetInput, _a2 func(*ssm.DescribeMaintenanceWindowsForTargetOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeMaintenanceWindowsForTargetInput, func(*ssm.DescribeMaintenanceWindowsForTargetOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

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

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

	return r0, r1
}

// DescribeMaintenanceWindowsForTargetWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) DescribeMaintenanceWindowsForTargetWithContext(_a0 context.Context, _a1 *ssm.DescribeMaintenanceWindowsForTargetInput, _a2 ...request.Option) (*ssm.DescribeMaintenanceWindowsForTargetOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := 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.DescribeMaintenanceWindowsForTargetOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeMaintenanceWindowsForTargetInput, ...request.Option) (*ssm.DescribeMaintenanceWindowsForTargetOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeMaintenanceWindowsForTargetInput, ...request.Option) *ssm.DescribeMaintenanceWindowsForTargetOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.DescribeMaintenanceWindowsForTargetOutput)
		}
	}

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

	return r0, r1
}

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

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

	return r0
}

// DescribeMaintenanceWindowsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *SSMAPI) DescribeMaintenanceWindowsPagesWithContext(_a0 context.Context, _a1 *ssm.DescribeMaintenanceWindowsInput, _a2 func(*ssm.DescribeMaintenanceWindowsOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeMaintenanceWindowsInput, func(*ssm.DescribeMaintenanceWindowsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// 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
	var r1 *ssm.DescribeMaintenanceWindowsOutput
	if rf, ok := ret.Get(0).(func(*ssm.DescribeMaintenanceWindowsInput) (*request.Request, *ssm.DescribeMaintenanceWindowsOutput)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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 context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeMaintenanceWindowsInput, ...request.Option) (*ssm.DescribeMaintenanceWindowsOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.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)
		}
	}

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

	return r0, r1
}

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

	var r0 *ssm.DescribeOpsItemsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.DescribeOpsItemsInput) (*ssm.DescribeOpsItemsOutput, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(*ssm.DescribeOpsItemsInput) *ssm.DescribeOpsItemsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.DescribeOpsItemsOutput)
		}
	}

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

	return r0, r1
}

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

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

	return r0
}

// DescribeOpsItemsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *SSMAPI) DescribeOpsItemsPagesWithContext(_a0 context.Context, _a1 *ssm.DescribeOpsItemsInput, _a2 func(*ssm.DescribeOpsItemsOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeOpsItemsInput, func(*ssm.DescribeOpsItemsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

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

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

	return r0, r1
}

// DescribeOpsItemsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) DescribeOpsItemsWithContext(_a0 context.Context, _a1 *ssm.DescribeOpsItemsInput, _a2 ...request.Option) (*ssm.DescribeOpsItemsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := 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.DescribeOpsItemsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeOpsItemsInput, ...request.Option) (*ssm.DescribeOpsItemsOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeOpsItemsInput, ...request.Option) *ssm.DescribeOpsItemsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.DescribeOpsItemsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ssm.DescribeOpsItemsInput, ...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
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.DescribeParametersInput) (*ssm.DescribeParametersOutput, error)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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 context.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(context.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
	var r1 *ssm.DescribeParametersOutput
	if rf, ok := ret.Get(0).(func(*ssm.DescribeParametersInput) (*request.Request, *ssm.DescribeParametersOutput)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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 context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeParametersInput, ...request.Option) (*ssm.DescribeParametersOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.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)
		}
	}

	if rf, ok := ret.Get(1).(func(context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.DescribePatchBaselinesInput) (*ssm.DescribePatchBaselinesOutput, error)); ok {
		return rf(_a0)
	}
	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)
		}
	}

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

	return r0, r1
}

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

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

	return r0
}

// DescribePatchBaselinesPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *SSMAPI) DescribePatchBaselinesPagesWithContext(_a0 context.Context, _a1 *ssm.DescribePatchBaselinesInput, _a2 func(*ssm.DescribePatchBaselinesOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribePatchBaselinesInput, func(*ssm.DescribePatchBaselinesOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// 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
	var r1 *ssm.DescribePatchBaselinesOutput
	if rf, ok := ret.Get(0).(func(*ssm.DescribePatchBaselinesInput) (*request.Request, *ssm.DescribePatchBaselinesOutput)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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 context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribePatchBaselinesInput, ...request.Option) (*ssm.DescribePatchBaselinesOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.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)
		}
	}

	if rf, ok := ret.Get(1).(func(context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.DescribePatchGroupStateInput) (*ssm.DescribePatchGroupStateOutput, error)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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
	var r1 *ssm.DescribePatchGroupStateOutput
	if rf, ok := ret.Get(0).(func(*ssm.DescribePatchGroupStateInput) (*request.Request, *ssm.DescribePatchGroupStateOutput)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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 context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribePatchGroupStateInput, ...request.Option) (*ssm.DescribePatchGroupStateOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.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)
		}
	}

	if rf, ok := ret.Get(1).(func(context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.DescribePatchGroupsInput) (*ssm.DescribePatchGroupsOutput, error)); ok {
		return rf(_a0)
	}
	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)
		}
	}

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

	return r0, r1
}

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

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

	return r0
}

// DescribePatchGroupsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *SSMAPI) DescribePatchGroupsPagesWithContext(_a0 context.Context, _a1 *ssm.DescribePatchGroupsInput, _a2 func(*ssm.DescribePatchGroupsOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribePatchGroupsInput, func(*ssm.DescribePatchGroupsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// 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
	var r1 *ssm.DescribePatchGroupsOutput
	if rf, ok := ret.Get(0).(func(*ssm.DescribePatchGroupsInput) (*request.Request, *ssm.DescribePatchGroupsOutput)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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 context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribePatchGroupsInput, ...request.Option) (*ssm.DescribePatchGroupsOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.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)
		}
	}

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

	return r0, r1
}

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

	var r0 *ssm.DescribePatchPropertiesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.DescribePatchPropertiesInput) (*ssm.DescribePatchPropertiesOutput, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(*ssm.DescribePatchPropertiesInput) *ssm.DescribePatchPropertiesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.DescribePatchPropertiesOutput)
		}
	}

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

	return r0, r1
}

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

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

	return r0
}

// DescribePatchPropertiesPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *SSMAPI) DescribePatchPropertiesPagesWithContext(_a0 context.Context, _a1 *ssm.DescribePatchPropertiesInput, _a2 func(*ssm.DescribePatchPropertiesOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribePatchPropertiesInput, func(*ssm.DescribePatchPropertiesOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

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

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

	return r0, r1
}

// DescribePatchPropertiesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) DescribePatchPropertiesWithContext(_a0 context.Context, _a1 *ssm.DescribePatchPropertiesInput, _a2 ...request.Option) (*ssm.DescribePatchPropertiesOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := 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.DescribePatchPropertiesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribePatchPropertiesInput, ...request.Option) (*ssm.DescribePatchPropertiesOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribePatchPropertiesInput, ...request.Option) *ssm.DescribePatchPropertiesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.DescribePatchPropertiesOutput)
		}
	}

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

	return r0, r1
}

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

	var r0 *ssm.DescribeSessionsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.DescribeSessionsInput) (*ssm.DescribeSessionsOutput, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(*ssm.DescribeSessionsInput) *ssm.DescribeSessionsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.DescribeSessionsOutput)
		}
	}

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

	return r0, r1
}

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

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

	return r0
}

// DescribeSessionsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *SSMAPI) DescribeSessionsPagesWithContext(_a0 context.Context, _a1 *ssm.DescribeSessionsInput, _a2 func(*ssm.DescribeSessionsOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeSessionsInput, func(*ssm.DescribeSessionsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

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

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

	return r0, r1
}

// DescribeSessionsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) DescribeSessionsWithContext(_a0 context.Context, _a1 *ssm.DescribeSessionsInput, _a2 ...request.Option) (*ssm.DescribeSessionsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := 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.DescribeSessionsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeSessionsInput, ...request.Option) (*ssm.DescribeSessionsOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeSessionsInput, ...request.Option) *ssm.DescribeSessionsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.DescribeSessionsOutput)
		}
	}

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

	return r0, r1
}

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

	var r0 *ssm.DisassociateOpsItemRelatedItemOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.DisassociateOpsItemRelatedItemInput) (*ssm.DisassociateOpsItemRelatedItemOutput, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(*ssm.DisassociateOpsItemRelatedItemInput) *ssm.DisassociateOpsItemRelatedItemOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.DisassociateOpsItemRelatedItemOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// DisassociateOpsItemRelatedItemWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) DisassociateOpsItemRelatedItemWithContext(_a0 context.Context, _a1 *ssm.DisassociateOpsItemRelatedItemInput, _a2 ...request.Option) (*ssm.DisassociateOpsItemRelatedItemOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := 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.DisassociateOpsItemRelatedItemOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DisassociateOpsItemRelatedItemInput, ...request.Option) (*ssm.DisassociateOpsItemRelatedItemOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DisassociateOpsItemRelatedItemInput, ...request.Option) *ssm.DisassociateOpsItemRelatedItemOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.DisassociateOpsItemRelatedItemOutput)
		}
	}

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

	return r0, r1
}

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

	var r0 *ssm.ExecuteApiOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.ExecuteApiInput) (*ssm.ExecuteApiOutput, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(*ssm.ExecuteApiInput) *ssm.ExecuteApiOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.ExecuteApiOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// ExecuteApiWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) ExecuteApiWithContext(_a0 context.Context, _a1 *ssm.ExecuteApiInput, _a2 ...request.Option) (*ssm.ExecuteApiOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := 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.ExecuteApiOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.ExecuteApiInput, ...request.Option) (*ssm.ExecuteApiOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.ExecuteApiInput, ...request.Option) *ssm.ExecuteApiOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.ExecuteApiOutput)
		}
	}

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

	return r0, r1
}

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

	var r0 *ssm.GetAutomationActionOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.GetAutomationActionInput) (*ssm.GetAutomationActionOutput, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(*ssm.GetAutomationActionInput) *ssm.GetAutomationActionOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.GetAutomationActionOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// GetAutomationActionWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) GetAutomationActionWithContext(_a0 context.Context, _a1 *ssm.GetAutomationActionInput, _a2 ...request.Option) (*ssm.GetAutomationActionOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := 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.GetAutomationActionOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.GetAutomationActionInput, ...request.Option) (*ssm.GetAutomationActionOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.GetAutomationActionInput, ...request.Option) *ssm.GetAutomationActionOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.GetAutomationActionOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ssm.GetAutomationActionInput, ...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
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.GetAutomationExecutionInput) (*ssm.GetAutomationExecutionOutput, error)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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
	var r1 *ssm.GetAutomationExecutionOutput
	if rf, ok := ret.Get(0).(func(*ssm.GetAutomationExecutionInput) (*request.Request, *ssm.GetAutomationExecutionOutput)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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 context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.GetAutomationExecutionInput, ...request.Option) (*ssm.GetAutomationExecutionOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.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)
		}
	}

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

	return r0, r1
}

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

	var r0 *ssm.GetCalendarOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.GetCalendarInput) (*ssm.GetCalendarOutput, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(*ssm.GetCalendarInput) *ssm.GetCalendarOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.GetCalendarOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

	var r0 *ssm.GetCalendarStateOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.GetCalendarStateInput) (*ssm.GetCalendarStateOutput, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(*ssm.GetCalendarStateInput) *ssm.GetCalendarStateOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.GetCalendarStateOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// GetCalendarStateWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) GetCalendarStateWithContext(_a0 context.Context, _a1 *ssm.GetCalendarStateInput, _a2 ...request.Option) (*ssm.GetCalendarStateOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := 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.GetCalendarStateOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.GetCalendarStateInput, ...request.Option) (*ssm.GetCalendarStateOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.GetCalendarStateInput, ...request.Option) *ssm.GetCalendarStateOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.GetCalendarStateOutput)
		}
	}

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

	return r0, r1
}

// GetCalendarWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) GetCalendarWithContext(_a0 context.Context, _a1 *ssm.GetCalendarInput, _a2 ...request.Option) (*ssm.GetCalendarOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := 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.GetCalendarOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.GetCalendarInput, ...request.Option) (*ssm.GetCalendarOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.GetCalendarInput, ...request.Option) *ssm.GetCalendarOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.GetCalendarOutput)
		}
	}

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

	return r0, r1
}

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

	var r0 *ssm.GetCommandInteractiveTokenOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.GetCommandInteractiveTokenInput) (*ssm.GetCommandInteractiveTokenOutput, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(*ssm.GetCommandInteractiveTokenInput) *ssm.GetCommandInteractiveTokenOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.GetCommandInteractiveTokenOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// GetCommandInteractiveTokenWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) GetCommandInteractiveTokenWithContext(_a0 context.Context, _a1 *ssm.GetCommandInteractiveTokenInput, _a2 ...request.Option) (*ssm.GetCommandInteractiveTokenOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := 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.GetCommandInteractiveTokenOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.GetCommandInteractiveTokenInput, ...request.Option) (*ssm.GetCommandInteractiveTokenOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.GetCommandInteractiveTokenInput, ...request.Option) *ssm.GetCommandInteractiveTokenOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.GetCommandInteractiveTokenOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ssm.GetCommandInteractiveTokenInput, ...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
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.GetCommandInvocationInput) (*ssm.GetCommandInvocationOutput, error)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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
	var r1 *ssm.GetCommandInvocationOutput
	if rf, ok := ret.Get(0).(func(*ssm.GetCommandInvocationInput) (*request.Request, *ssm.GetCommandInvocationOutput)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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 context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.GetCommandInvocationInput, ...request.Option) (*ssm.GetCommandInvocationOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.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)
		}
	}

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

	return r0, r1
}

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

	var r0 *ssm.GetConnectionStatusOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.GetConnectionStatusInput) (*ssm.GetConnectionStatusOutput, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(*ssm.GetConnectionStatusInput) *ssm.GetConnectionStatusOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.GetConnectionStatusOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// GetConnectionStatusWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) GetConnectionStatusWithContext(_a0 context.Context, _a1 *ssm.GetConnectionStatusInput, _a2 ...request.Option) (*ssm.GetConnectionStatusOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := 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.GetConnectionStatusOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.GetConnectionStatusInput, ...request.Option) (*ssm.GetConnectionStatusOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.GetConnectionStatusInput, ...request.Option) *ssm.GetConnectionStatusOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.GetConnectionStatusOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ssm.GetConnectionStatusInput, ...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
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.GetDefaultPatchBaselineInput) (*ssm.GetDefaultPatchBaselineOutput, error)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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
	var r1 *ssm.GetDefaultPatchBaselineOutput
	if rf, ok := ret.Get(0).(func(*ssm.GetDefaultPatchBaselineInput) (*request.Request, *ssm.GetDefaultPatchBaselineOutput)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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 context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.GetDefaultPatchBaselineInput, ...request.Option) (*ssm.GetDefaultPatchBaselineOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.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)
		}
	}

	if rf, ok := ret.Get(1).(func(context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.GetDeployablePatchSnapshotForInstanceInput) (*ssm.GetDeployablePatchSnapshotForInstanceOutput, error)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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
	var r1 *ssm.GetDeployablePatchSnapshotForInstanceOutput
	if rf, ok := ret.Get(0).(func(*ssm.GetDeployablePatchSnapshotForInstanceInput) (*request.Request, *ssm.GetDeployablePatchSnapshotForInstanceOutput)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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 context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.GetDeployablePatchSnapshotForInstanceInput, ...request.Option) (*ssm.GetDeployablePatchSnapshotForInstanceOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.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)
		}
	}

	if rf, ok := ret.Get(1).(func(context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.GetDocumentInput) (*ssm.GetDocumentOutput, error)); ok {
		return rf(_a0)
	}
	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)
		}
	}

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

	return r0, r1
}

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

	var r0 *ssm.GetDocumentInternalOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.GetDocumentInternalInput) (*ssm.GetDocumentInternalOutput, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(*ssm.GetDocumentInternalInput) *ssm.GetDocumentInternalOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.GetDocumentInternalOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// GetDocumentInternalWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) GetDocumentInternalWithContext(_a0 context.Context, _a1 *ssm.GetDocumentInternalInput, _a2 ...request.Option) (*ssm.GetDocumentInternalOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := 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.GetDocumentInternalOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.GetDocumentInternalInput, ...request.Option) (*ssm.GetDocumentInternalOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.GetDocumentInternalInput, ...request.Option) *ssm.GetDocumentInternalOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.GetDocumentInternalOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ssm.GetDocumentInternalInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} 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
	var r1 *ssm.GetDocumentOutput
	if rf, ok := ret.Get(0).(func(*ssm.GetDocumentInput) (*request.Request, *ssm.GetDocumentOutput)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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 context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.GetDocumentInput, ...request.Option) (*ssm.GetDocumentOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.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)
		}
	}

	if rf, ok := ret.Get(1).(func(context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.GetInventoryInput) (*ssm.GetInventoryOutput, error)); ok {
		return rf(_a0)
	}
	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)
		}
	}

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

	return r0, r1
}

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

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

	return r0
}

// GetInventoryPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *SSMAPI) GetInventoryPagesWithContext(_a0 context.Context, _a1 *ssm.GetInventoryInput, _a2 func(*ssm.GetInventoryOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.GetInventoryInput, func(*ssm.GetInventoryOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// 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
	var r1 *ssm.GetInventoryOutput
	if rf, ok := ret.Get(0).(func(*ssm.GetInventoryInput) (*request.Request, *ssm.GetInventoryOutput)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.GetInventorySchemaInput) (*ssm.GetInventorySchemaOutput, error)); ok {
		return rf(_a0)
	}
	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)
		}
	}

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

	return r0, r1
}

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

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

	return r0
}

// GetInventorySchemaPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *SSMAPI) GetInventorySchemaPagesWithContext(_a0 context.Context, _a1 *ssm.GetInventorySchemaInput, _a2 func(*ssm.GetInventorySchemaOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.GetInventorySchemaInput, func(*ssm.GetInventorySchemaOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// 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
	var r1 *ssm.GetInventorySchemaOutput
	if rf, ok := ret.Get(0).(func(*ssm.GetInventorySchemaInput) (*request.Request, *ssm.GetInventorySchemaOutput)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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 context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.GetInventorySchemaInput, ...request.Option) (*ssm.GetInventorySchemaOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.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)
		}
	}

	if rf, ok := ret.Get(1).(func(context.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 context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.GetInventoryInput, ...request.Option) (*ssm.GetInventoryOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.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)
		}
	}

	if rf, ok := ret.Get(1).(func(context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.GetMaintenanceWindowInput) (*ssm.GetMaintenanceWindowOutput, error)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.GetMaintenanceWindowExecutionInput) (*ssm.GetMaintenanceWindowExecutionOutput, error)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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
	var r1 *ssm.GetMaintenanceWindowExecutionOutput
	if rf, ok := ret.Get(0).(func(*ssm.GetMaintenanceWindowExecutionInput) (*request.Request, *ssm.GetMaintenanceWindowExecutionOutput)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.GetMaintenanceWindowExecutionTaskInput) (*ssm.GetMaintenanceWindowExecutionTaskOutput, error)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.GetMaintenanceWindowExecutionTaskInvocationInput) (*ssm.GetMaintenanceWindowExecutionTaskInvocationOutput, error)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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
	var r1 *ssm.GetMaintenanceWindowExecutionTaskInvocationOutput
	if rf, ok := ret.Get(0).(func(*ssm.GetMaintenanceWindowExecutionTaskInvocationInput) (*request.Request, *ssm.GetMaintenanceWindowExecutionTaskInvocationOutput)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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 context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.GetMaintenanceWindowExecutionTaskInvocationInput, ...request.Option) (*ssm.GetMaintenanceWindowExecutionTaskInvocationOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.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)
		}
	}

	if rf, ok := ret.Get(1).(func(context.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
	var r1 *ssm.GetMaintenanceWindowExecutionTaskOutput
	if rf, ok := ret.Get(0).(func(*ssm.GetMaintenanceWindowExecutionTaskInput) (*request.Request, *ssm.GetMaintenanceWindowExecutionTaskOutput)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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 context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.GetMaintenanceWindowExecutionTaskInput, ...request.Option) (*ssm.GetMaintenanceWindowExecutionTaskOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.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)
		}
	}

	if rf, ok := ret.Get(1).(func(context.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 context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.GetMaintenanceWindowExecutionInput, ...request.Option) (*ssm.GetMaintenanceWindowExecutionOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.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)
		}
	}

	if rf, ok := ret.Get(1).(func(context.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
	var r1 *ssm.GetMaintenanceWindowOutput
	if rf, ok := ret.Get(0).(func(*ssm.GetMaintenanceWindowInput) (*request.Request, *ssm.GetMaintenanceWindowOutput)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.GetMaintenanceWindowTaskInput) (*ssm.GetMaintenanceWindowTaskOutput, error)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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
	var r1 *ssm.GetMaintenanceWindowTaskOutput
	if rf, ok := ret.Get(0).(func(*ssm.GetMaintenanceWindowTaskInput) (*request.Request, *ssm.GetMaintenanceWindowTaskOutput)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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 context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.GetMaintenanceWindowTaskInput, ...request.Option) (*ssm.GetMaintenanceWindowTaskOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.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)
		}
	}

	if rf, ok := ret.Get(1).(func(context.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 context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.GetMaintenanceWindowInput, ...request.Option) (*ssm.GetMaintenanceWindowOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.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)
		}
	}

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

	return r0, r1
}

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

	var r0 *ssm.GetManifestOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.GetManifestInput) (*ssm.GetManifestOutput, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(*ssm.GetManifestInput) *ssm.GetManifestOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.GetManifestOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// GetManifestWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) GetManifestWithContext(_a0 context.Context, _a1 *ssm.GetManifestInput, _a2 ...request.Option) (*ssm.GetManifestOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := 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.GetManifestOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.GetManifestInput, ...request.Option) (*ssm.GetManifestOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.GetManifestInput, ...request.Option) *ssm.GetManifestOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.GetManifestOutput)
		}
	}

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

	return r0, r1
}

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

	var r0 *ssm.GetOpsItemOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.GetOpsItemInput) (*ssm.GetOpsItemOutput, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(*ssm.GetOpsItemInput) *ssm.GetOpsItemOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.GetOpsItemOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// GetOpsItemWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) GetOpsItemWithContext(_a0 context.Context, _a1 *ssm.GetOpsItemInput, _a2 ...request.Option) (*ssm.GetOpsItemOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := 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.GetOpsItemOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.GetOpsItemInput, ...request.Option) (*ssm.GetOpsItemOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.GetOpsItemInput, ...request.Option) *ssm.GetOpsItemOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.GetOpsItemOutput)
		}
	}

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

	return r0, r1
}

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

	var r0 *ssm.GetOpsMetadataOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.GetOpsMetadataInput) (*ssm.GetOpsMetadataOutput, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(*ssm.GetOpsMetadataInput) *ssm.GetOpsMetadataOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.GetOpsMetadataOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// GetOpsMetadataWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) GetOpsMetadataWithContext(_a0 context.Context, _a1 *ssm.GetOpsMetadataInput, _a2 ...request.Option) (*ssm.GetOpsMetadataOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := 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.GetOpsMetadataOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.GetOpsMetadataInput, ...request.Option) (*ssm.GetOpsMetadataOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.GetOpsMetadataInput, ...request.Option) *ssm.GetOpsMetadataOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.GetOpsMetadataOutput)
		}
	}

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

	return r0, r1
}

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

	var r0 *ssm.GetOpsSummaryOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.GetOpsSummaryInput) (*ssm.GetOpsSummaryOutput, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(*ssm.GetOpsSummaryInput) *ssm.GetOpsSummaryOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.GetOpsSummaryOutput)
		}
	}

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

	return r0, r1
}

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

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

	return r0
}

// GetOpsSummaryPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *SSMAPI) GetOpsSummaryPagesWithContext(_a0 context.Context, _a1 *ssm.GetOpsSummaryInput, _a2 func(*ssm.GetOpsSummaryOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.GetOpsSummaryInput, func(*ssm.GetOpsSummaryOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

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

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

	return r0, r1
}

// GetOpsSummaryWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) GetOpsSummaryWithContext(_a0 context.Context, _a1 *ssm.GetOpsSummaryInput, _a2 ...request.Option) (*ssm.GetOpsSummaryOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := 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.GetOpsSummaryOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.GetOpsSummaryInput, ...request.Option) (*ssm.GetOpsSummaryOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.GetOpsSummaryInput, ...request.Option) *ssm.GetOpsSummaryOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.GetOpsSummaryOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ssm.GetOpsSummaryInput, ...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
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.GetParameterInput) (*ssm.GetParameterOutput, error)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.GetParameterHistoryInput) (*ssm.GetParameterHistoryOutput, error)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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 context.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(context.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
	var r1 *ssm.GetParameterHistoryOutput
	if rf, ok := ret.Get(0).(func(*ssm.GetParameterHistoryInput) (*request.Request, *ssm.GetParameterHistoryOutput)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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 context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.GetParameterHistoryInput, ...request.Option) (*ssm.GetParameterHistoryOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.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)
		}
	}

	if rf, ok := ret.Get(1).(func(context.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
	var r1 *ssm.GetParameterOutput
	if rf, ok := ret.Get(0).(func(*ssm.GetParameterInput) (*request.Request, *ssm.GetParameterOutput)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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 context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.GetParameterInput, ...request.Option) (*ssm.GetParameterOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.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)
		}
	}

	if rf, ok := ret.Get(1).(func(context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.GetParametersInput) (*ssm.GetParametersOutput, error)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.GetParametersByPathInput) (*ssm.GetParametersByPathOutput, error)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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 context.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(context.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
	var r1 *ssm.GetParametersByPathOutput
	if rf, ok := ret.Get(0).(func(*ssm.GetParametersByPathInput) (*request.Request, *ssm.GetParametersByPathOutput)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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 context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.GetParametersByPathInput, ...request.Option) (*ssm.GetParametersByPathOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.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)
		}
	}

	if rf, ok := ret.Get(1).(func(context.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
	var r1 *ssm.GetParametersOutput
	if rf, ok := ret.Get(0).(func(*ssm.GetParametersInput) (*request.Request, *ssm.GetParametersOutput)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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 context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.GetParametersInput, ...request.Option) (*ssm.GetParametersOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.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)
		}
	}

	if rf, ok := ret.Get(1).(func(context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.GetPatchBaselineInput) (*ssm.GetPatchBaselineOutput, error)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.GetPatchBaselineForPatchGroupInput) (*ssm.GetPatchBaselineForPatchGroupOutput, error)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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
	var r1 *ssm.GetPatchBaselineForPatchGroupOutput
	if rf, ok := ret.Get(0).(func(*ssm.GetPatchBaselineForPatchGroupInput) (*request.Request, *ssm.GetPatchBaselineForPatchGroupOutput)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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 context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.GetPatchBaselineForPatchGroupInput, ...request.Option) (*ssm.GetPatchBaselineForPatchGroupOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.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)
		}
	}

	if rf, ok := ret.Get(1).(func(context.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
	var r1 *ssm.GetPatchBaselineOutput
	if rf, ok := ret.Get(0).(func(*ssm.GetPatchBaselineInput) (*request.Request, *ssm.GetPatchBaselineOutput)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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 context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.GetPatchBaselineInput, ...request.Option) (*ssm.GetPatchBaselineOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.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)
		}
	}

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

	return r0, r1
}

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

	var r0 *ssm.GetResourcePoliciesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.GetResourcePoliciesInput) (*ssm.GetResourcePoliciesOutput, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(*ssm.GetResourcePoliciesInput) *ssm.GetResourcePoliciesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.GetResourcePoliciesOutput)
		}
	}

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

	return r0, r1
}

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

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

	return r0
}

// GetResourcePoliciesPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *SSMAPI) GetResourcePoliciesPagesWithContext(_a0 context.Context, _a1 *ssm.GetResourcePoliciesInput, _a2 func(*ssm.GetResourcePoliciesOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.GetResourcePoliciesInput, func(*ssm.GetResourcePoliciesOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

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

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

	return r0, r1
}

// GetResourcePoliciesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) GetResourcePoliciesWithContext(_a0 context.Context, _a1 *ssm.GetResourcePoliciesInput, _a2 ...request.Option) (*ssm.GetResourcePoliciesOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := 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.GetResourcePoliciesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.GetResourcePoliciesInput, ...request.Option) (*ssm.GetResourcePoliciesOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.GetResourcePoliciesInput, ...request.Option) *ssm.GetResourcePoliciesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.GetResourcePoliciesOutput)
		}
	}

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

	return r0, r1
}

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

	var r0 *ssm.GetResourcePolicyInternalOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.GetResourcePolicyInternalInput) (*ssm.GetResourcePolicyInternalOutput, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(*ssm.GetResourcePolicyInternalInput) *ssm.GetResourcePolicyInternalOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.GetResourcePolicyInternalOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// GetResourcePolicyInternalWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) GetResourcePolicyInternalWithContext(_a0 context.Context, _a1 *ssm.GetResourcePolicyInternalInput, _a2 ...request.Option) (*ssm.GetResourcePolicyInternalOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := 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.GetResourcePolicyInternalOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.GetResourcePolicyInternalInput, ...request.Option) (*ssm.GetResourcePolicyInternalOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.GetResourcePolicyInternalInput, ...request.Option) *ssm.GetResourcePolicyInternalOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.GetResourcePolicyInternalOutput)
		}
	}

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

	return r0, r1
}

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

	var r0 *ssm.GetServiceSettingOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.GetServiceSettingInput) (*ssm.GetServiceSettingOutput, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(*ssm.GetServiceSettingInput) *ssm.GetServiceSettingOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.GetServiceSettingOutput)
		}
	}

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

	return r0, r1
}

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

	var r0 *ssm.GetServiceSettingInternalOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.GetServiceSettingInternalInput) (*ssm.GetServiceSettingInternalOutput, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(*ssm.GetServiceSettingInternalInput) *ssm.GetServiceSettingInternalOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.GetServiceSettingInternalOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// GetServiceSettingInternalWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) GetServiceSettingInternalWithContext(_a0 context.Context, _a1 *ssm.GetServiceSettingInternalInput, _a2 ...request.Option) (*ssm.GetServiceSettingInternalOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := 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.GetServiceSettingInternalOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.GetServiceSettingInternalInput, ...request.Option) (*ssm.GetServiceSettingInternalOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.GetServiceSettingInternalInput, ...request.Option) *ssm.GetServiceSettingInternalOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.GetServiceSettingInternalOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// GetServiceSettingWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) GetServiceSettingWithContext(_a0 context.Context, _a1 *ssm.GetServiceSettingInput, _a2 ...request.Option) (*ssm.GetServiceSettingOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := 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.GetServiceSettingOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.GetServiceSettingInput, ...request.Option) (*ssm.GetServiceSettingOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.GetServiceSettingInput, ...request.Option) *ssm.GetServiceSettingOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.GetServiceSettingOutput)
		}
	}

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

	return r0, r1
}

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

	var r0 *ssm.LabelParameterVersionOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.LabelParameterVersionInput) (*ssm.LabelParameterVersionOutput, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(*ssm.LabelParameterVersionInput) *ssm.LabelParameterVersionOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.LabelParameterVersionOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// LabelParameterVersionWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) LabelParameterVersionWithContext(_a0 context.Context, _a1 *ssm.LabelParameterVersionInput, _a2 ...request.Option) (*ssm.LabelParameterVersionOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := 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.LabelParameterVersionOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.LabelParameterVersionInput, ...request.Option) (*ssm.LabelParameterVersionOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.LabelParameterVersionInput, ...request.Option) *ssm.LabelParameterVersionOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.LabelParameterVersionOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ssm.LabelParameterVersionInput, ...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
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.ListAssociationVersionsInput) (*ssm.ListAssociationVersionsOutput, error)); ok {
		return rf(_a0)
	}
	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)
		}
	}

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

	return r0, r1
}

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

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

	return r0
}

// ListAssociationVersionsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *SSMAPI) ListAssociationVersionsPagesWithContext(_a0 context.Context, _a1 *ssm.ListAssociationVersionsInput, _a2 func(*ssm.ListAssociationVersionsOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.ListAssociationVersionsInput, func(*ssm.ListAssociationVersionsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// 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
	var r1 *ssm.ListAssociationVersionsOutput
	if rf, ok := ret.Get(0).(func(*ssm.ListAssociationVersionsInput) (*request.Request, *ssm.ListAssociationVersionsOutput)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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 context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.ListAssociationVersionsInput, ...request.Option) (*ssm.ListAssociationVersionsOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.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)
		}
	}

	if rf, ok := ret.Get(1).(func(context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.ListAssociationsInput) (*ssm.ListAssociationsOutput, error)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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 context.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(context.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
	var r1 *ssm.ListAssociationsOutput
	if rf, ok := ret.Get(0).(func(*ssm.ListAssociationsInput) (*request.Request, *ssm.ListAssociationsOutput)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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 context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.ListAssociationsInput, ...request.Option) (*ssm.ListAssociationsOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.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)
		}
	}

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

	return r0, r1
}

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

	var r0 *ssm.ListCalendarEventsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.ListCalendarEventsInput) (*ssm.ListCalendarEventsOutput, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(*ssm.ListCalendarEventsInput) *ssm.ListCalendarEventsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.ListCalendarEventsOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// ListCalendarEventsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) ListCalendarEventsWithContext(_a0 context.Context, _a1 *ssm.ListCalendarEventsInput, _a2 ...request.Option) (*ssm.ListCalendarEventsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := 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.ListCalendarEventsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.ListCalendarEventsInput, ...request.Option) (*ssm.ListCalendarEventsOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.ListCalendarEventsInput, ...request.Option) *ssm.ListCalendarEventsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.ListCalendarEventsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ssm.ListCalendarEventsInput, ...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
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.ListCommandInvocationsInput) (*ssm.ListCommandInvocationsOutput, error)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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 context.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(context.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
	var r1 *ssm.ListCommandInvocationsOutput
	if rf, ok := ret.Get(0).(func(*ssm.ListCommandInvocationsInput) (*request.Request, *ssm.ListCommandInvocationsOutput)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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 context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.ListCommandInvocationsInput, ...request.Option) (*ssm.ListCommandInvocationsOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.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)
		}
	}

	if rf, ok := ret.Get(1).(func(context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.ListCommandsInput) (*ssm.ListCommandsOutput, error)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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 context.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(context.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
	var r1 *ssm.ListCommandsOutput
	if rf, ok := ret.Get(0).(func(*ssm.ListCommandsInput) (*request.Request, *ssm.ListCommandsOutput)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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 context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.ListCommandsInput, ...request.Option) (*ssm.ListCommandsOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.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)
		}
	}

	if rf, ok := ret.Get(1).(func(context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.ListComplianceItemsInput) (*ssm.ListComplianceItemsOutput, error)); ok {
		return rf(_a0)
	}
	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)
		}
	}

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

	return r0, r1
}

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

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

	return r0
}

// ListComplianceItemsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *SSMAPI) ListComplianceItemsPagesWithContext(_a0 context.Context, _a1 *ssm.ListComplianceItemsInput, _a2 func(*ssm.ListComplianceItemsOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.ListComplianceItemsInput, func(*ssm.ListComplianceItemsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// 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
	var r1 *ssm.ListComplianceItemsOutput
	if rf, ok := ret.Get(0).(func(*ssm.ListComplianceItemsInput) (*request.Request, *ssm.ListComplianceItemsOutput)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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 context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.ListComplianceItemsInput, ...request.Option) (*ssm.ListComplianceItemsOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.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)
		}
	}

	if rf, ok := ret.Get(1).(func(context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.ListComplianceSummariesInput) (*ssm.ListComplianceSummariesOutput, error)); ok {
		return rf(_a0)
	}
	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)
		}
	}

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

	return r0, r1
}

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

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

	return r0
}

// ListComplianceSummariesPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *SSMAPI) ListComplianceSummariesPagesWithContext(_a0 context.Context, _a1 *ssm.ListComplianceSummariesInput, _a2 func(*ssm.ListComplianceSummariesOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.ListComplianceSummariesInput, func(*ssm.ListComplianceSummariesOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// 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
	var r1 *ssm.ListComplianceSummariesOutput
	if rf, ok := ret.Get(0).(func(*ssm.ListComplianceSummariesInput) (*request.Request, *ssm.ListComplianceSummariesOutput)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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 context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.ListComplianceSummariesInput, ...request.Option) (*ssm.ListComplianceSummariesOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.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)
		}
	}

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

	return r0, r1
}

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

	var r0 *ssm.ListConsumerAccountsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.ListConsumerAccountsInput) (*ssm.ListConsumerAccountsOutput, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(*ssm.ListConsumerAccountsInput) *ssm.ListConsumerAccountsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.ListConsumerAccountsOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// ListConsumerAccountsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) ListConsumerAccountsWithContext(_a0 context.Context, _a1 *ssm.ListConsumerAccountsInput, _a2 ...request.Option) (*ssm.ListConsumerAccountsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := 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.ListConsumerAccountsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.ListConsumerAccountsInput, ...request.Option) (*ssm.ListConsumerAccountsOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.ListConsumerAccountsInput, ...request.Option) *ssm.ListConsumerAccountsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.ListConsumerAccountsOutput)
		}
	}

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

	return r0, r1
}

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

	var r0 *ssm.ListDocumentMetadataHistoryOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.ListDocumentMetadataHistoryInput) (*ssm.ListDocumentMetadataHistoryOutput, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(*ssm.ListDocumentMetadataHistoryInput) *ssm.ListDocumentMetadataHistoryOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.ListDocumentMetadataHistoryOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// ListDocumentMetadataHistoryWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) ListDocumentMetadataHistoryWithContext(_a0 context.Context, _a1 *ssm.ListDocumentMetadataHistoryInput, _a2 ...request.Option) (*ssm.ListDocumentMetadataHistoryOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := 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.ListDocumentMetadataHistoryOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.ListDocumentMetadataHistoryInput, ...request.Option) (*ssm.ListDocumentMetadataHistoryOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.ListDocumentMetadataHistoryInput, ...request.Option) *ssm.ListDocumentMetadataHistoryOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.ListDocumentMetadataHistoryOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ssm.ListDocumentMetadataHistoryInput, ...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
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.ListDocumentVersionsInput) (*ssm.ListDocumentVersionsOutput, error)); ok {
		return rf(_a0)
	}
	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)
		}
	}

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

	return r0, r1
}

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

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

	return r0
}

// ListDocumentVersionsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *SSMAPI) ListDocumentVersionsPagesWithContext(_a0 context.Context, _a1 *ssm.ListDocumentVersionsInput, _a2 func(*ssm.ListDocumentVersionsOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.ListDocumentVersionsInput, func(*ssm.ListDocumentVersionsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// 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
	var r1 *ssm.ListDocumentVersionsOutput
	if rf, ok := ret.Get(0).(func(*ssm.ListDocumentVersionsInput) (*request.Request, *ssm.ListDocumentVersionsOutput)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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 context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.ListDocumentVersionsInput, ...request.Option) (*ssm.ListDocumentVersionsOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.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)
		}
	}

	if rf, ok := ret.Get(1).(func(context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.ListDocumentsInput) (*ssm.ListDocumentsOutput, error)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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 context.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(context.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
	var r1 *ssm.ListDocumentsOutput
	if rf, ok := ret.Get(0).(func(*ssm.ListDocumentsInput) (*request.Request, *ssm.ListDocumentsOutput)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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 context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.ListDocumentsInput, ...request.Option) (*ssm.ListDocumentsOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.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)
		}
	}

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

	return r0, r1
}

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

	var r0 *ssm.ListInstanceAssociationsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.ListInstanceAssociationsInput) (*ssm.ListInstanceAssociationsOutput, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(*ssm.ListInstanceAssociationsInput) *ssm.ListInstanceAssociationsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.ListInstanceAssociationsOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// ListInstanceAssociationsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) ListInstanceAssociationsWithContext(_a0 context.Context, _a1 *ssm.ListInstanceAssociationsInput, _a2 ...request.Option) (*ssm.ListInstanceAssociationsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := 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.ListInstanceAssociationsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.ListInstanceAssociationsInput, ...request.Option) (*ssm.ListInstanceAssociationsOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.ListInstanceAssociationsInput, ...request.Option) *ssm.ListInstanceAssociationsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.ListInstanceAssociationsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ssm.ListInstanceAssociationsInput, ...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
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.ListInventoryEntriesInput) (*ssm.ListInventoryEntriesOutput, error)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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
	var r1 *ssm.ListInventoryEntriesOutput
	if rf, ok := ret.Get(0).(func(*ssm.ListInventoryEntriesInput) (*request.Request, *ssm.ListInventoryEntriesOutput)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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 context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.ListInventoryEntriesInput, ...request.Option) (*ssm.ListInventoryEntriesOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.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)
		}
	}

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

	return r0, r1
}

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

	var r0 *ssm.ListOpsItemEventsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.ListOpsItemEventsInput) (*ssm.ListOpsItemEventsOutput, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(*ssm.ListOpsItemEventsInput) *ssm.ListOpsItemEventsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.ListOpsItemEventsOutput)
		}
	}

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

	return r0, r1
}

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

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

	return r0
}

// ListOpsItemEventsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *SSMAPI) ListOpsItemEventsPagesWithContext(_a0 context.Context, _a1 *ssm.ListOpsItemEventsInput, _a2 func(*ssm.ListOpsItemEventsOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.ListOpsItemEventsInput, func(*ssm.ListOpsItemEventsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

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

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

	return r0, r1
}

// ListOpsItemEventsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) ListOpsItemEventsWithContext(_a0 context.Context, _a1 *ssm.ListOpsItemEventsInput, _a2 ...request.Option) (*ssm.ListOpsItemEventsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := 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.ListOpsItemEventsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.ListOpsItemEventsInput, ...request.Option) (*ssm.ListOpsItemEventsOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.ListOpsItemEventsInput, ...request.Option) *ssm.ListOpsItemEventsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.ListOpsItemEventsOutput)
		}
	}

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

	return r0, r1
}

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

	var r0 *ssm.ListOpsItemRelatedItemsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.ListOpsItemRelatedItemsInput) (*ssm.ListOpsItemRelatedItemsOutput, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(*ssm.ListOpsItemRelatedItemsInput) *ssm.ListOpsItemRelatedItemsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.ListOpsItemRelatedItemsOutput)
		}
	}

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

	return r0, r1
}

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

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

	return r0
}

// ListOpsItemRelatedItemsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *SSMAPI) ListOpsItemRelatedItemsPagesWithContext(_a0 context.Context, _a1 *ssm.ListOpsItemRelatedItemsInput, _a2 func(*ssm.ListOpsItemRelatedItemsOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.ListOpsItemRelatedItemsInput, func(*ssm.ListOpsItemRelatedItemsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

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

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

	return r0, r1
}

// ListOpsItemRelatedItemsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) ListOpsItemRelatedItemsWithContext(_a0 context.Context, _a1 *ssm.ListOpsItemRelatedItemsInput, _a2 ...request.Option) (*ssm.ListOpsItemRelatedItemsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := 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.ListOpsItemRelatedItemsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.ListOpsItemRelatedItemsInput, ...request.Option) (*ssm.ListOpsItemRelatedItemsOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.ListOpsItemRelatedItemsInput, ...request.Option) *ssm.ListOpsItemRelatedItemsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.ListOpsItemRelatedItemsOutput)
		}
	}

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

	return r0, r1
}

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

	var r0 *ssm.ListOpsMetadataOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.ListOpsMetadataInput) (*ssm.ListOpsMetadataOutput, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(*ssm.ListOpsMetadataInput) *ssm.ListOpsMetadataOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.ListOpsMetadataOutput)
		}
	}

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

	return r0, r1
}

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

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

	return r0
}

// ListOpsMetadataPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *SSMAPI) ListOpsMetadataPagesWithContext(_a0 context.Context, _a1 *ssm.ListOpsMetadataInput, _a2 func(*ssm.ListOpsMetadataOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.ListOpsMetadataInput, func(*ssm.ListOpsMetadataOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

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

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

	return r0, r1
}

// ListOpsMetadataWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) ListOpsMetadataWithContext(_a0 context.Context, _a1 *ssm.ListOpsMetadataInput, _a2 ...request.Option) (*ssm.ListOpsMetadataOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := 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.ListOpsMetadataOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.ListOpsMetadataInput, ...request.Option) (*ssm.ListOpsMetadataOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.ListOpsMetadataInput, ...request.Option) *ssm.ListOpsMetadataOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.ListOpsMetadataOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ssm.ListOpsMetadataInput, ...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
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.ListResourceComplianceSummariesInput) (*ssm.ListResourceComplianceSummariesOutput, error)); ok {
		return rf(_a0)
	}
	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)
		}
	}

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

	return r0, r1
}

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

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

	return r0
}

// ListResourceComplianceSummariesPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *SSMAPI) ListResourceComplianceSummariesPagesWithContext(_a0 context.Context, _a1 *ssm.ListResourceComplianceSummariesInput, _a2 func(*ssm.ListResourceComplianceSummariesOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.ListResourceComplianceSummariesInput, func(*ssm.ListResourceComplianceSummariesOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// 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
	var r1 *ssm.ListResourceComplianceSummariesOutput
	if rf, ok := ret.Get(0).(func(*ssm.ListResourceComplianceSummariesInput) (*request.Request, *ssm.ListResourceComplianceSummariesOutput)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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 context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.ListResourceComplianceSummariesInput, ...request.Option) (*ssm.ListResourceComplianceSummariesOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.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)
		}
	}

	if rf, ok := ret.Get(1).(func(context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.ListResourceDataSyncInput) (*ssm.ListResourceDataSyncOutput, error)); ok {
		return rf(_a0)
	}
	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)
		}
	}

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

	return r0, r1
}

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

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

	return r0
}

// ListResourceDataSyncPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *SSMAPI) ListResourceDataSyncPagesWithContext(_a0 context.Context, _a1 *ssm.ListResourceDataSyncInput, _a2 func(*ssm.ListResourceDataSyncOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.ListResourceDataSyncInput, func(*ssm.ListResourceDataSyncOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// 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
	var r1 *ssm.ListResourceDataSyncOutput
	if rf, ok := ret.Get(0).(func(*ssm.ListResourceDataSyncInput) (*request.Request, *ssm.ListResourceDataSyncOutput)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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 context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.ListResourceDataSyncInput, ...request.Option) (*ssm.ListResourceDataSyncOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.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)
		}
	}

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

	return r0, r1
}

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

	var r0 *ssm.ListResourcesSupportPolicyOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.ListResourcesSupportPolicyInput) (*ssm.ListResourcesSupportPolicyOutput, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(*ssm.ListResourcesSupportPolicyInput) *ssm.ListResourcesSupportPolicyOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.ListResourcesSupportPolicyOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// ListResourcesSupportPolicyWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) ListResourcesSupportPolicyWithContext(_a0 context.Context, _a1 *ssm.ListResourcesSupportPolicyInput, _a2 ...request.Option) (*ssm.ListResourcesSupportPolicyOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := 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.ListResourcesSupportPolicyOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.ListResourcesSupportPolicyInput, ...request.Option) (*ssm.ListResourcesSupportPolicyOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.ListResourcesSupportPolicyInput, ...request.Option) *ssm.ListResourcesSupportPolicyOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.ListResourcesSupportPolicyOutput)
		}
	}

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

	return r0, r1
}

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

	var r0 *ssm.ListServiceSettingsInternalOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.ListServiceSettingsInternalInput) (*ssm.ListServiceSettingsInternalOutput, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(*ssm.ListServiceSettingsInternalInput) *ssm.ListServiceSettingsInternalOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.ListServiceSettingsInternalOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// ListServiceSettingsInternalWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) ListServiceSettingsInternalWithContext(_a0 context.Context, _a1 *ssm.ListServiceSettingsInternalInput, _a2 ...request.Option) (*ssm.ListServiceSettingsInternalOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := 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.ListServiceSettingsInternalOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.ListServiceSettingsInternalInput, ...request.Option) (*ssm.ListServiceSettingsInternalOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.ListServiceSettingsInternalInput, ...request.Option) *ssm.ListServiceSettingsInternalOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.ListServiceSettingsInternalOutput)
		}
	}

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

	return r0, r1
}

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

	var r0 *ssm.ListSharedResourcesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.ListSharedResourcesInput) (*ssm.ListSharedResourcesOutput, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(*ssm.ListSharedResourcesInput) *ssm.ListSharedResourcesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.ListSharedResourcesOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// ListSharedResourcesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) ListSharedResourcesWithContext(_a0 context.Context, _a1 *ssm.ListSharedResourcesInput, _a2 ...request.Option) (*ssm.ListSharedResourcesOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := 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.ListSharedResourcesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.ListSharedResourcesInput, ...request.Option) (*ssm.ListSharedResourcesOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.ListSharedResourcesInput, ...request.Option) *ssm.ListSharedResourcesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.ListSharedResourcesOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ssm.ListSharedResourcesInput, ...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
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.ListTagsForResourceInput) (*ssm.ListTagsForResourceOutput, error)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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
	var r1 *ssm.ListTagsForResourceOutput
	if rf, ok := ret.Get(0).(func(*ssm.ListTagsForResourceInput) (*request.Request, *ssm.ListTagsForResourceOutput)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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 context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.ListTagsForResourceInput, ...request.Option) (*ssm.ListTagsForResourceOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.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)
		}
	}

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

	return r0, r1
}

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

	var r0 *ssm.LockServiceLinkedRoleOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.LockServiceLinkedRoleInput) (*ssm.LockServiceLinkedRoleOutput, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(*ssm.LockServiceLinkedRoleInput) *ssm.LockServiceLinkedRoleOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.LockServiceLinkedRoleOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// LockServiceLinkedRoleWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) LockServiceLinkedRoleWithContext(_a0 context.Context, _a1 *ssm.LockServiceLinkedRoleInput, _a2 ...request.Option) (*ssm.LockServiceLinkedRoleOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := 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.LockServiceLinkedRoleOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.LockServiceLinkedRoleInput, ...request.Option) (*ssm.LockServiceLinkedRoleOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.LockServiceLinkedRoleInput, ...request.Option) *ssm.LockServiceLinkedRoleOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.LockServiceLinkedRoleOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ssm.LockServiceLinkedRoleInput, ...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
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.ModifyDocumentPermissionInput) (*ssm.ModifyDocumentPermissionOutput, error)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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
	var r1 *ssm.ModifyDocumentPermissionOutput
	if rf, ok := ret.Get(0).(func(*ssm.ModifyDocumentPermissionInput) (*request.Request, *ssm.ModifyDocumentPermissionOutput)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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 context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.ModifyDocumentPermissionInput, ...request.Option) (*ssm.ModifyDocumentPermissionOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.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)
		}
	}

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

	return r0, r1
}

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

	var r0 *ssm.PutCalendarOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.PutCalendarInput) (*ssm.PutCalendarOutput, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(*ssm.PutCalendarInput) *ssm.PutCalendarOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.PutCalendarOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// PutCalendarWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) PutCalendarWithContext(_a0 context.Context, _a1 *ssm.PutCalendarInput, _a2 ...request.Option) (*ssm.PutCalendarOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := 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.PutCalendarOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.PutCalendarInput, ...request.Option) (*ssm.PutCalendarOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.PutCalendarInput, ...request.Option) *ssm.PutCalendarOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.PutCalendarOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ssm.PutCalendarInput, ...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
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.PutComplianceItemsInput) (*ssm.PutComplianceItemsOutput, error)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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
	var r1 *ssm.PutComplianceItemsOutput
	if rf, ok := ret.Get(0).(func(*ssm.PutComplianceItemsInput) (*request.Request, *ssm.PutComplianceItemsOutput)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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 context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.PutComplianceItemsInput, ...request.Option) (*ssm.PutComplianceItemsOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.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)
		}
	}

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

	return r0, r1
}

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

	var r0 *ssm.PutConfigurePackageResultOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.PutConfigurePackageResultInput) (*ssm.PutConfigurePackageResultOutput, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(*ssm.PutConfigurePackageResultInput) *ssm.PutConfigurePackageResultOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.PutConfigurePackageResultOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// PutConfigurePackageResultWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) PutConfigurePackageResultWithContext(_a0 context.Context, _a1 *ssm.PutConfigurePackageResultInput, _a2 ...request.Option) (*ssm.PutConfigurePackageResultOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := 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.PutConfigurePackageResultOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.PutConfigurePackageResultInput, ...request.Option) (*ssm.PutConfigurePackageResultOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.PutConfigurePackageResultInput, ...request.Option) *ssm.PutConfigurePackageResultOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.PutConfigurePackageResultOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ssm.PutConfigurePackageResultInput, ...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
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.PutInventoryInput) (*ssm.PutInventoryOutput, error)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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
	var r1 *ssm.PutInventoryOutput
	if rf, ok := ret.Get(0).(func(*ssm.PutInventoryInput) (*request.Request, *ssm.PutInventoryOutput)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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 context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.PutInventoryInput, ...request.Option) (*ssm.PutInventoryOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.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)
		}
	}

	if rf, ok := ret.Get(1).(func(context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.PutParameterInput) (*ssm.PutParameterOutput, error)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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
	var r1 *ssm.PutParameterOutput
	if rf, ok := ret.Get(0).(func(*ssm.PutParameterInput) (*request.Request, *ssm.PutParameterOutput)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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 context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.PutParameterInput, ...request.Option) (*ssm.PutParameterOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.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)
		}
	}

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

	return r0, r1
}

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

	var r0 *ssm.PutResourcePolicyOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.PutResourcePolicyInput) (*ssm.PutResourcePolicyOutput, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(*ssm.PutResourcePolicyInput) *ssm.PutResourcePolicyOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.PutResourcePolicyOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// PutResourcePolicyWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) PutResourcePolicyWithContext(_a0 context.Context, _a1 *ssm.PutResourcePolicyInput, _a2 ...request.Option) (*ssm.PutResourcePolicyOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := 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.PutResourcePolicyOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.PutResourcePolicyInput, ...request.Option) (*ssm.PutResourcePolicyOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.PutResourcePolicyInput, ...request.Option) *ssm.PutResourcePolicyOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.PutResourcePolicyOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ssm.PutResourcePolicyInput, ...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
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.RegisterDefaultPatchBaselineInput) (*ssm.RegisterDefaultPatchBaselineOutput, error)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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
	var r1 *ssm.RegisterDefaultPatchBaselineOutput
	if rf, ok := ret.Get(0).(func(*ssm.RegisterDefaultPatchBaselineInput) (*request.Request, *ssm.RegisterDefaultPatchBaselineOutput)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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 context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.RegisterDefaultPatchBaselineInput, ...request.Option) (*ssm.RegisterDefaultPatchBaselineOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.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)
		}
	}

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

	return r0, r1
}

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

	var r0 *ssm.RegisterManagedInstanceOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.RegisterManagedInstanceInput) (*ssm.RegisterManagedInstanceOutput, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(*ssm.RegisterManagedInstanceInput) *ssm.RegisterManagedInstanceOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.RegisterManagedInstanceOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// RegisterManagedInstanceWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) RegisterManagedInstanceWithContext(_a0 context.Context, _a1 *ssm.RegisterManagedInstanceInput, _a2 ...request.Option) (*ssm.RegisterManagedInstanceOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := 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.RegisterManagedInstanceOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.RegisterManagedInstanceInput, ...request.Option) (*ssm.RegisterManagedInstanceOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.RegisterManagedInstanceInput, ...request.Option) *ssm.RegisterManagedInstanceOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.RegisterManagedInstanceOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ssm.RegisterManagedInstanceInput, ...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
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.RegisterPatchBaselineForPatchGroupInput) (*ssm.RegisterPatchBaselineForPatchGroupOutput, error)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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
	var r1 *ssm.RegisterPatchBaselineForPatchGroupOutput
	if rf, ok := ret.Get(0).(func(*ssm.RegisterPatchBaselineForPatchGroupInput) (*request.Request, *ssm.RegisterPatchBaselineForPatchGroupOutput)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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 context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.RegisterPatchBaselineForPatchGroupInput, ...request.Option) (*ssm.RegisterPatchBaselineForPatchGroupOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.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)
		}
	}

	if rf, ok := ret.Get(1).(func(context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.RegisterTargetWithMaintenanceWindowInput) (*ssm.RegisterTargetWithMaintenanceWindowOutput, error)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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
	var r1 *ssm.RegisterTargetWithMaintenanceWindowOutput
	if rf, ok := ret.Get(0).(func(*ssm.RegisterTargetWithMaintenanceWindowInput) (*request.Request, *ssm.RegisterTargetWithMaintenanceWindowOutput)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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 context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.RegisterTargetWithMaintenanceWindowInput, ...request.Option) (*ssm.RegisterTargetWithMaintenanceWindowOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.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)
		}
	}

	if rf, ok := ret.Get(1).(func(context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.RegisterTaskWithMaintenanceWindowInput) (*ssm.RegisterTaskWithMaintenanceWindowOutput, error)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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
	var r1 *ssm.RegisterTaskWithMaintenanceWindowOutput
	if rf, ok := ret.Get(0).(func(*ssm.RegisterTaskWithMaintenanceWindowInput) (*request.Request, *ssm.RegisterTaskWithMaintenanceWindowOutput)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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 context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.RegisterTaskWithMaintenanceWindowInput, ...request.Option) (*ssm.RegisterTaskWithMaintenanceWindowOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.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)
		}
	}

	if rf, ok := ret.Get(1).(func(context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.RemoveTagsFromResourceInput) (*ssm.RemoveTagsFromResourceOutput, error)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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
	var r1 *ssm.RemoveTagsFromResourceOutput
	if rf, ok := ret.Get(0).(func(*ssm.RemoveTagsFromResourceInput) (*request.Request, *ssm.RemoveTagsFromResourceOutput)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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 context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.RemoveTagsFromResourceInput, ...request.Option) (*ssm.RemoveTagsFromResourceOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.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)
		}
	}

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

	return r0, r1
}

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

	var r0 *ssm.RequestManagedInstanceRoleTokenOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.RequestManagedInstanceRoleTokenInput) (*ssm.RequestManagedInstanceRoleTokenOutput, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(*ssm.RequestManagedInstanceRoleTokenInput) *ssm.RequestManagedInstanceRoleTokenOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.RequestManagedInstanceRoleTokenOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// RequestManagedInstanceRoleTokenWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) RequestManagedInstanceRoleTokenWithContext(_a0 context.Context, _a1 *ssm.RequestManagedInstanceRoleTokenInput, _a2 ...request.Option) (*ssm.RequestManagedInstanceRoleTokenOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := 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.RequestManagedInstanceRoleTokenOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.RequestManagedInstanceRoleTokenInput, ...request.Option) (*ssm.RequestManagedInstanceRoleTokenOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.RequestManagedInstanceRoleTokenInput, ...request.Option) *ssm.RequestManagedInstanceRoleTokenOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.RequestManagedInstanceRoleTokenOutput)
		}
	}

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

	return r0, r1
}

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

	var r0 *ssm.ResetServiceSettingOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.ResetServiceSettingInput) (*ssm.ResetServiceSettingOutput, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(*ssm.ResetServiceSettingInput) *ssm.ResetServiceSettingOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.ResetServiceSettingOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// ResetServiceSettingWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) ResetServiceSettingWithContext(_a0 context.Context, _a1 *ssm.ResetServiceSettingInput, _a2 ...request.Option) (*ssm.ResetServiceSettingOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := 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.ResetServiceSettingOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.ResetServiceSettingInput, ...request.Option) (*ssm.ResetServiceSettingOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.ResetServiceSettingInput, ...request.Option) *ssm.ResetServiceSettingOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.ResetServiceSettingOutput)
		}
	}

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

	return r0, r1
}

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

	var r0 *ssm.ResumeSessionOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.ResumeSessionInput) (*ssm.ResumeSessionOutput, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(*ssm.ResumeSessionInput) *ssm.ResumeSessionOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.ResumeSessionOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// ResumeSessionWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) ResumeSessionWithContext(_a0 context.Context, _a1 *ssm.ResumeSessionInput, _a2 ...request.Option) (*ssm.ResumeSessionOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := 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.ResumeSessionOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.ResumeSessionInput, ...request.Option) (*ssm.ResumeSessionOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.ResumeSessionInput, ...request.Option) *ssm.ResumeSessionOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.ResumeSessionOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ssm.ResumeSessionInput, ...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
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.SendAutomationSignalInput) (*ssm.SendAutomationSignalOutput, error)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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
	var r1 *ssm.SendAutomationSignalOutput
	if rf, ok := ret.Get(0).(func(*ssm.SendAutomationSignalInput) (*request.Request, *ssm.SendAutomationSignalOutput)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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 context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.SendAutomationSignalInput, ...request.Option) (*ssm.SendAutomationSignalOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.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)
		}
	}

	if rf, ok := ret.Get(1).(func(context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.SendCommandInput) (*ssm.SendCommandOutput, error)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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
	var r1 *ssm.SendCommandOutput
	if rf, ok := ret.Get(0).(func(*ssm.SendCommandInput) (*request.Request, *ssm.SendCommandOutput)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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 context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.SendCommandInput, ...request.Option) (*ssm.SendCommandOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.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)
		}
	}

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

	return r0, r1
}

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

	var r0 *ssm.StartAssociationsOnceOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.StartAssociationsOnceInput) (*ssm.StartAssociationsOnceOutput, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(*ssm.StartAssociationsOnceInput) *ssm.StartAssociationsOnceOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.StartAssociationsOnceOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// StartAssociationsOnceWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) StartAssociationsOnceWithContext(_a0 context.Context, _a1 *ssm.StartAssociationsOnceInput, _a2 ...request.Option) (*ssm.StartAssociationsOnceOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := 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.StartAssociationsOnceOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.StartAssociationsOnceInput, ...request.Option) (*ssm.StartAssociationsOnceOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.StartAssociationsOnceInput, ...request.Option) *ssm.StartAssociationsOnceOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.StartAssociationsOnceOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ssm.StartAssociationsOnceInput, ...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
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.StartAutomationExecutionInput) (*ssm.StartAutomationExecutionOutput, error)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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
	var r1 *ssm.StartAutomationExecutionOutput
	if rf, ok := ret.Get(0).(func(*ssm.StartAutomationExecutionInput) (*request.Request, *ssm.StartAutomationExecutionOutput)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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 context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.StartAutomationExecutionInput, ...request.Option) (*ssm.StartAutomationExecutionOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.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)
		}
	}

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

	return r0, r1
}

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

	var r0 *ssm.StartChangeRequestExecutionOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.StartChangeRequestExecutionInput) (*ssm.StartChangeRequestExecutionOutput, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(*ssm.StartChangeRequestExecutionInput) *ssm.StartChangeRequestExecutionOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.StartChangeRequestExecutionOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// StartChangeRequestExecutionWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) StartChangeRequestExecutionWithContext(_a0 context.Context, _a1 *ssm.StartChangeRequestExecutionInput, _a2 ...request.Option) (*ssm.StartChangeRequestExecutionOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := 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.StartChangeRequestExecutionOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.StartChangeRequestExecutionInput, ...request.Option) (*ssm.StartChangeRequestExecutionOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.StartChangeRequestExecutionInput, ...request.Option) *ssm.StartChangeRequestExecutionOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.StartChangeRequestExecutionOutput)
		}
	}

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

	return r0, r1
}

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

	var r0 *ssm.StartSessionOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.StartSessionInput) (*ssm.StartSessionOutput, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(*ssm.StartSessionInput) *ssm.StartSessionOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.StartSessionOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// StartSessionWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) StartSessionWithContext(_a0 context.Context, _a1 *ssm.StartSessionInput, _a2 ...request.Option) (*ssm.StartSessionOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := 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.StartSessionOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.StartSessionInput, ...request.Option) (*ssm.StartSessionOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.StartSessionInput, ...request.Option) *ssm.StartSessionOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.StartSessionOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ssm.StartSessionInput, ...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
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.StopAutomationExecutionInput) (*ssm.StopAutomationExecutionOutput, error)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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
	var r1 *ssm.StopAutomationExecutionOutput
	if rf, ok := ret.Get(0).(func(*ssm.StopAutomationExecutionInput) (*request.Request, *ssm.StopAutomationExecutionOutput)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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 context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.StopAutomationExecutionInput, ...request.Option) (*ssm.StopAutomationExecutionOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.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)
		}
	}

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

	return r0, r1
}

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

	var r0 *ssm.TerminateSessionOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.TerminateSessionInput) (*ssm.TerminateSessionOutput, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(*ssm.TerminateSessionInput) *ssm.TerminateSessionOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.TerminateSessionOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// TerminateSessionWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) TerminateSessionWithContext(_a0 context.Context, _a1 *ssm.TerminateSessionInput, _a2 ...request.Option) (*ssm.TerminateSessionOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := 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.TerminateSessionOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.TerminateSessionInput, ...request.Option) (*ssm.TerminateSessionOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.TerminateSessionInput, ...request.Option) *ssm.TerminateSessionOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.TerminateSessionOutput)
		}
	}

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

	return r0, r1
}

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

	var r0 *ssm.UnlabelParameterVersionOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.UnlabelParameterVersionInput) (*ssm.UnlabelParameterVersionOutput, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(*ssm.UnlabelParameterVersionInput) *ssm.UnlabelParameterVersionOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.UnlabelParameterVersionOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// UnlabelParameterVersionWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) UnlabelParameterVersionWithContext(_a0 context.Context, _a1 *ssm.UnlabelParameterVersionInput, _a2 ...request.Option) (*ssm.UnlabelParameterVersionOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := 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.UnlabelParameterVersionOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.UnlabelParameterVersionInput, ...request.Option) (*ssm.UnlabelParameterVersionOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.UnlabelParameterVersionInput, ...request.Option) *ssm.UnlabelParameterVersionOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.UnlabelParameterVersionOutput)
		}
	}

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

	return r0, r1
}

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

	var r0 *ssm.UnlockServiceLinkedRoleOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.UnlockServiceLinkedRoleInput) (*ssm.UnlockServiceLinkedRoleOutput, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(*ssm.UnlockServiceLinkedRoleInput) *ssm.UnlockServiceLinkedRoleOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.UnlockServiceLinkedRoleOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// UnlockServiceLinkedRoleWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) UnlockServiceLinkedRoleWithContext(_a0 context.Context, _a1 *ssm.UnlockServiceLinkedRoleInput, _a2 ...request.Option) (*ssm.UnlockServiceLinkedRoleOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := 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.UnlockServiceLinkedRoleOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.UnlockServiceLinkedRoleInput, ...request.Option) (*ssm.UnlockServiceLinkedRoleOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.UnlockServiceLinkedRoleInput, ...request.Option) *ssm.UnlockServiceLinkedRoleOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.UnlockServiceLinkedRoleOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ssm.UnlockServiceLinkedRoleInput, ...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
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.UpdateAssociationInput) (*ssm.UpdateAssociationOutput, error)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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
	var r1 *ssm.UpdateAssociationOutput
	if rf, ok := ret.Get(0).(func(*ssm.UpdateAssociationInput) (*request.Request, *ssm.UpdateAssociationOutput)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.UpdateAssociationStatusInput) (*ssm.UpdateAssociationStatusOutput, error)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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
	var r1 *ssm.UpdateAssociationStatusOutput
	if rf, ok := ret.Get(0).(func(*ssm.UpdateAssociationStatusInput) (*request.Request, *ssm.UpdateAssociationStatusOutput)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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 context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.UpdateAssociationStatusInput, ...request.Option) (*ssm.UpdateAssociationStatusOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.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)
		}
	}

	if rf, ok := ret.Get(1).(func(context.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 context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.UpdateAssociationInput, ...request.Option) (*ssm.UpdateAssociationOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.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)
		}
	}

	if rf, ok := ret.Get(1).(func(context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.UpdateDocumentInput) (*ssm.UpdateDocumentOutput, error)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.UpdateDocumentDefaultVersionInput) (*ssm.UpdateDocumentDefaultVersionOutput, error)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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
	var r1 *ssm.UpdateDocumentDefaultVersionOutput
	if rf, ok := ret.Get(0).(func(*ssm.UpdateDocumentDefaultVersionInput) (*request.Request, *ssm.UpdateDocumentDefaultVersionOutput)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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 context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.UpdateDocumentDefaultVersionInput, ...request.Option) (*ssm.UpdateDocumentDefaultVersionOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.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)
		}
	}

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

	return r0, r1
}

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

	var r0 *ssm.UpdateDocumentMetadataOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.UpdateDocumentMetadataInput) (*ssm.UpdateDocumentMetadataOutput, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(*ssm.UpdateDocumentMetadataInput) *ssm.UpdateDocumentMetadataOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.UpdateDocumentMetadataOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// UpdateDocumentMetadataWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) UpdateDocumentMetadataWithContext(_a0 context.Context, _a1 *ssm.UpdateDocumentMetadataInput, _a2 ...request.Option) (*ssm.UpdateDocumentMetadataOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := 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.UpdateDocumentMetadataOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.UpdateDocumentMetadataInput, ...request.Option) (*ssm.UpdateDocumentMetadataOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.UpdateDocumentMetadataInput, ...request.Option) *ssm.UpdateDocumentMetadataOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.UpdateDocumentMetadataOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ssm.UpdateDocumentMetadataInput, ...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
	var r1 *ssm.UpdateDocumentOutput
	if rf, ok := ret.Get(0).(func(*ssm.UpdateDocumentInput) (*request.Request, *ssm.UpdateDocumentOutput)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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 context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.UpdateDocumentInput, ...request.Option) (*ssm.UpdateDocumentOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.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)
		}
	}

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

	return r0, r1
}

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

	var r0 *ssm.UpdateInstanceAssociationStatusOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.UpdateInstanceAssociationStatusInput) (*ssm.UpdateInstanceAssociationStatusOutput, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(*ssm.UpdateInstanceAssociationStatusInput) *ssm.UpdateInstanceAssociationStatusOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.UpdateInstanceAssociationStatusOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// UpdateInstanceAssociationStatusWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) UpdateInstanceAssociationStatusWithContext(_a0 context.Context, _a1 *ssm.UpdateInstanceAssociationStatusInput, _a2 ...request.Option) (*ssm.UpdateInstanceAssociationStatusOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := 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.UpdateInstanceAssociationStatusOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.UpdateInstanceAssociationStatusInput, ...request.Option) (*ssm.UpdateInstanceAssociationStatusOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.UpdateInstanceAssociationStatusInput, ...request.Option) *ssm.UpdateInstanceAssociationStatusOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.UpdateInstanceAssociationStatusOutput)
		}
	}

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

	return r0, r1
}

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

	var r0 *ssm.UpdateInstanceInformationOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.UpdateInstanceInformationInput) (*ssm.UpdateInstanceInformationOutput, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(*ssm.UpdateInstanceInformationInput) *ssm.UpdateInstanceInformationOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.UpdateInstanceInformationOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// UpdateInstanceInformationWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) UpdateInstanceInformationWithContext(_a0 context.Context, _a1 *ssm.UpdateInstanceInformationInput, _a2 ...request.Option) (*ssm.UpdateInstanceInformationOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := 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.UpdateInstanceInformationOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.UpdateInstanceInformationInput, ...request.Option) (*ssm.UpdateInstanceInformationOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.UpdateInstanceInformationInput, ...request.Option) *ssm.UpdateInstanceInformationOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.UpdateInstanceInformationOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ssm.UpdateInstanceInformationInput, ...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
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.UpdateMaintenanceWindowInput) (*ssm.UpdateMaintenanceWindowOutput, error)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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
	var r1 *ssm.UpdateMaintenanceWindowOutput
	if rf, ok := ret.Get(0).(func(*ssm.UpdateMaintenanceWindowInput) (*request.Request, *ssm.UpdateMaintenanceWindowOutput)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.UpdateMaintenanceWindowTargetInput) (*ssm.UpdateMaintenanceWindowTargetOutput, error)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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
	var r1 *ssm.UpdateMaintenanceWindowTargetOutput
	if rf, ok := ret.Get(0).(func(*ssm.UpdateMaintenanceWindowTargetInput) (*request.Request, *ssm.UpdateMaintenanceWindowTargetOutput)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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 context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.UpdateMaintenanceWindowTargetInput, ...request.Option) (*ssm.UpdateMaintenanceWindowTargetOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.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)
		}
	}

	if rf, ok := ret.Get(1).(func(context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.UpdateMaintenanceWindowTaskInput) (*ssm.UpdateMaintenanceWindowTaskOutput, error)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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
	var r1 *ssm.UpdateMaintenanceWindowTaskOutput
	if rf, ok := ret.Get(0).(func(*ssm.UpdateMaintenanceWindowTaskInput) (*request.Request, *ssm.UpdateMaintenanceWindowTaskOutput)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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 context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.UpdateMaintenanceWindowTaskInput, ...request.Option) (*ssm.UpdateMaintenanceWindowTaskOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.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)
		}
	}

	if rf, ok := ret.Get(1).(func(context.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 context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.UpdateMaintenanceWindowInput, ...request.Option) (*ssm.UpdateMaintenanceWindowOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.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)
		}
	}

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

	return r0, r1
}

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

	var r0 *ssm.UpdateManagedInstancePublicKeyOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.UpdateManagedInstancePublicKeyInput) (*ssm.UpdateManagedInstancePublicKeyOutput, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(*ssm.UpdateManagedInstancePublicKeyInput) *ssm.UpdateManagedInstancePublicKeyOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.UpdateManagedInstancePublicKeyOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// UpdateManagedInstancePublicKeyWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) UpdateManagedInstancePublicKeyWithContext(_a0 context.Context, _a1 *ssm.UpdateManagedInstancePublicKeyInput, _a2 ...request.Option) (*ssm.UpdateManagedInstancePublicKeyOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := 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.UpdateManagedInstancePublicKeyOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.UpdateManagedInstancePublicKeyInput, ...request.Option) (*ssm.UpdateManagedInstancePublicKeyOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.UpdateManagedInstancePublicKeyInput, ...request.Option) *ssm.UpdateManagedInstancePublicKeyOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.UpdateManagedInstancePublicKeyOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ssm.UpdateManagedInstancePublicKeyInput, ...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
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.UpdateManagedInstanceRoleInput) (*ssm.UpdateManagedInstanceRoleOutput, error)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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
	var r1 *ssm.UpdateManagedInstanceRoleOutput
	if rf, ok := ret.Get(0).(func(*ssm.UpdateManagedInstanceRoleInput) (*request.Request, *ssm.UpdateManagedInstanceRoleOutput)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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 context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.UpdateManagedInstanceRoleInput, ...request.Option) (*ssm.UpdateManagedInstanceRoleOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.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)
		}
	}

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

	return r0, r1
}

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

	var r0 *ssm.UpdateOpsItemOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.UpdateOpsItemInput) (*ssm.UpdateOpsItemOutput, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(*ssm.UpdateOpsItemInput) *ssm.UpdateOpsItemOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.UpdateOpsItemOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// UpdateOpsItemWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) UpdateOpsItemWithContext(_a0 context.Context, _a1 *ssm.UpdateOpsItemInput, _a2 ...request.Option) (*ssm.UpdateOpsItemOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := 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.UpdateOpsItemOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.UpdateOpsItemInput, ...request.Option) (*ssm.UpdateOpsItemOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.UpdateOpsItemInput, ...request.Option) *ssm.UpdateOpsItemOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.UpdateOpsItemOutput)
		}
	}

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

	return r0, r1
}

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

	var r0 *ssm.UpdateOpsMetadataOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.UpdateOpsMetadataInput) (*ssm.UpdateOpsMetadataOutput, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(*ssm.UpdateOpsMetadataInput) *ssm.UpdateOpsMetadataOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.UpdateOpsMetadataOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// UpdateOpsMetadataWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) UpdateOpsMetadataWithContext(_a0 context.Context, _a1 *ssm.UpdateOpsMetadataInput, _a2 ...request.Option) (*ssm.UpdateOpsMetadataOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := 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.UpdateOpsMetadataOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.UpdateOpsMetadataInput, ...request.Option) (*ssm.UpdateOpsMetadataOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.UpdateOpsMetadataInput, ...request.Option) *ssm.UpdateOpsMetadataOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.UpdateOpsMetadataOutput)
		}
	}

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

	return r0, r1
}

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

	var r0 *ssm.UpdateParameterDataInternalOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.UpdateParameterDataInternalInput) (*ssm.UpdateParameterDataInternalOutput, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(*ssm.UpdateParameterDataInternalInput) *ssm.UpdateParameterDataInternalOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.UpdateParameterDataInternalOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// UpdateParameterDataInternalWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) UpdateParameterDataInternalWithContext(_a0 context.Context, _a1 *ssm.UpdateParameterDataInternalInput, _a2 ...request.Option) (*ssm.UpdateParameterDataInternalOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := 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.UpdateParameterDataInternalOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.UpdateParameterDataInternalInput, ...request.Option) (*ssm.UpdateParameterDataInternalOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.UpdateParameterDataInternalInput, ...request.Option) *ssm.UpdateParameterDataInternalOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.UpdateParameterDataInternalOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ssm.UpdateParameterDataInternalInput, ...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
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.UpdatePatchBaselineInput) (*ssm.UpdatePatchBaselineOutput, error)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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
	var r1 *ssm.UpdatePatchBaselineOutput
	if rf, ok := ret.Get(0).(func(*ssm.UpdatePatchBaselineInput) (*request.Request, *ssm.UpdatePatchBaselineOutput)); ok {
		return rf(_a0)
	}
	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)
		}
	}

	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 context.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
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.UpdatePatchBaselineInput, ...request.Option) (*ssm.UpdatePatchBaselineOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.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)
		}
	}

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

	return r0, r1
}

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

	var r0 *ssm.UpdateResourceDataSyncOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.UpdateResourceDataSyncInput) (*ssm.UpdateResourceDataSyncOutput, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(*ssm.UpdateResourceDataSyncInput) *ssm.UpdateResourceDataSyncOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.UpdateResourceDataSyncOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// UpdateResourceDataSyncWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) UpdateResourceDataSyncWithContext(_a0 context.Context, _a1 *ssm.UpdateResourceDataSyncInput, _a2 ...request.Option) (*ssm.UpdateResourceDataSyncOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := 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.UpdateResourceDataSyncOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.UpdateResourceDataSyncInput, ...request.Option) (*ssm.UpdateResourceDataSyncOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.UpdateResourceDataSyncInput, ...request.Option) *ssm.UpdateResourceDataSyncOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.UpdateResourceDataSyncOutput)
		}
	}

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

	return r0, r1
}

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

	var r0 *ssm.UpdateResourceSharingStateV2Output
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.UpdateResourceSharingStateV2Input) (*ssm.UpdateResourceSharingStateV2Output, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(*ssm.UpdateResourceSharingStateV2Input) *ssm.UpdateResourceSharingStateV2Output); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.UpdateResourceSharingStateV2Output)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// UpdateResourceSharingStateV2WithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) UpdateResourceSharingStateV2WithContext(_a0 context.Context, _a1 *ssm.UpdateResourceSharingStateV2Input, _a2 ...request.Option) (*ssm.UpdateResourceSharingStateV2Output, error) {
	_va := make([]interface{}, len(_a2))
	for _i := 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.UpdateResourceSharingStateV2Output
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.UpdateResourceSharingStateV2Input, ...request.Option) (*ssm.UpdateResourceSharingStateV2Output, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.UpdateResourceSharingStateV2Input, ...request.Option) *ssm.UpdateResourceSharingStateV2Output); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.UpdateResourceSharingStateV2Output)
		}
	}

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

	return r0, r1
}

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

	var r0 *ssm.UpdateServiceSettingOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.UpdateServiceSettingInput) (*ssm.UpdateServiceSettingOutput, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(*ssm.UpdateServiceSettingInput) *ssm.UpdateServiceSettingOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.UpdateServiceSettingOutput)
		}
	}

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

	return r0, r1
}

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

	var r0 *ssm.UpdateServiceSettingInternalOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.UpdateServiceSettingInternalInput) (*ssm.UpdateServiceSettingInternalOutput, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(*ssm.UpdateServiceSettingInternalInput) *ssm.UpdateServiceSettingInternalOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.UpdateServiceSettingInternalOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// UpdateServiceSettingInternalWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) UpdateServiceSettingInternalWithContext(_a0 context.Context, _a1 *ssm.UpdateServiceSettingInternalInput, _a2 ...request.Option) (*ssm.UpdateServiceSettingInternalOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := 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.UpdateServiceSettingInternalOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.UpdateServiceSettingInternalInput, ...request.Option) (*ssm.UpdateServiceSettingInternalOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.UpdateServiceSettingInternalInput, ...request.Option) *ssm.UpdateServiceSettingInternalOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.UpdateServiceSettingInternalOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// UpdateServiceSettingWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) UpdateServiceSettingWithContext(_a0 context.Context, _a1 *ssm.UpdateServiceSettingInput, _a2 ...request.Option) (*ssm.UpdateServiceSettingOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := 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.UpdateServiceSettingOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.UpdateServiceSettingInput, ...request.Option) (*ssm.UpdateServiceSettingOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.UpdateServiceSettingInput, ...request.Option) *ssm.UpdateServiceSettingOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.UpdateServiceSettingOutput)
		}
	}

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

	return r0, r1
}

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

	var r0 *ssm.ValidateResourceSharingOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(*ssm.ValidateResourceSharingInput) (*ssm.ValidateResourceSharingOutput, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(*ssm.ValidateResourceSharingInput) *ssm.ValidateResourceSharingOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.ValidateResourceSharingOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// ValidateResourceSharingWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) ValidateResourceSharingWithContext(_a0 context.Context, _a1 *ssm.ValidateResourceSharingInput, _a2 ...request.Option) (*ssm.ValidateResourceSharingOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := 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.ValidateResourceSharingOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.ValidateResourceSharingInput, ...request.Option) (*ssm.ValidateResourceSharingOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.ValidateResourceSharingInput, ...request.Option) *ssm.ValidateResourceSharingOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.ValidateResourceSharingOutput)
		}
	}

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

	return r0, r1
}

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

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

	return r0
}

// WaitUntilCommandExecutedWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) WaitUntilCommandExecutedWithContext(_a0 context.Context, _a1 *ssm.GetCommandInvocationInput, _a2 ...request.WaiterOption) error {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *ssm.GetCommandInvocationInput, ...request.WaiterOption) error); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

type mockConstructorTestingTNewSSMAPI interface {
	mock.TestingT
	Cleanup(func())
}

// NewSSMAPI creates a new instance of SSMAPI. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
func NewSSMAPI(t mockConstructorTestingTNewSSMAPI) *SSMAPI {
	mock := &SSMAPI{}
	mock.Mock.Test(t)

	t.Cleanup(func() { mock.AssertExpectations(t) })

	return mock
}