SSMAPI.go

// Code generated by mockery v2.14.0. 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
	if rf, ok := ret.Get(0).(func(*ssm.AddTagsToResourceInput) *ssm.AddTagsToResourceOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.AddTagsToResourceOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// AddTagsToResourceWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) AddTagsToResourceWithContext(_a0 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
	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)
		}
	}

	var r1 error
	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
	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)
		}
	}

	var r1 error
	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
	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)
		}
	}

	var r1 *ssm.AssociateOpsItemRelatedItemOutput
	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
	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)
		}
	}

	var r1 error
	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
	if rf, ok := ret.Get(0).(func(*ssm.CancelCommandInput) *ssm.CancelCommandOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.CancelCommandOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// CancelCommandWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) CancelCommandWithContext(_a0 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
	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)
		}
	}

	var r1 error
	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
	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)
		}
	}

	var r1 error
	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
	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)
		}
	}

	var r1 *ssm.CancelMaintenanceWindowExecutionOutput
	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
	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)
		}
	}

	var r1 error
	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
	if rf, ok := ret.Get(0).(func(*ssm.CreateActivationInput) *ssm.CreateActivationOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.CreateActivationOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// CreateActivationWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) CreateActivationWithContext(_a0 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
	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)
		}
	}

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

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// CreateAssociationBatchWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) CreateAssociationBatchWithContext(_a0 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
	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)
		}
	}

	var r1 error
	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
	if rf, ok := ret.Get(0).(func(*ssm.CreateAssociationInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

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

	return r0, r1
}

// CreateAssociationWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) CreateAssociationWithContext(_a0 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
	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)
		}
	}

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

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// CreateDocumentWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) CreateDocumentWithContext(_a0 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
	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)
		}
	}

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

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// CreateMaintenanceWindowWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) CreateMaintenanceWindowWithContext(_a0 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
	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)
		}
	}

	var r1 error
	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
	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)
		}
	}

	var r1 error
	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
	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)
		}
	}

	var r1 *ssm.CreateOpsItemOutput
	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
	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)
		}
	}

	var r1 error
	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
	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)
		}
	}

	var r1 error
	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
	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)
		}
	}

	var r1 *ssm.CreateOpsMetadataOutput
	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
	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)
		}
	}

	var r1 error
	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
	if rf, ok := ret.Get(0).(func(*ssm.CreatePatchBaselineInput) *ssm.CreatePatchBaselineOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.CreatePatchBaselineOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// CreatePatchBaselineWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) CreatePatchBaselineWithContext(_a0 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
	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)
		}
	}

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

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// CreateResourceDataSyncWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) CreateResourceDataSyncWithContext(_a0 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
	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)
		}
	}

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

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// DeleteActivationWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) DeleteActivationWithContext(_a0 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
	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)
		}
	}

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

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// DeleteAssociationWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) DeleteAssociationWithContext(_a0 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
	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)
		}
	}

	var r1 error
	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
}

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

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

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// DeleteDocumentWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) DeleteDocumentWithContext(_a0 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
	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)
		}
	}

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

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// DeleteInventoryWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) DeleteInventoryWithContext(_a0 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
	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)
		}
	}

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

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// DeleteMaintenanceWindowWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) DeleteMaintenanceWindowWithContext(_a0 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
	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)
		}
	}

	var r1 error
	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
	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)
		}
	}

	var r1 error
	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
	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)
		}
	}

	var r1 *ssm.DeleteOpsMetadataOutput
	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
	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)
		}
	}

	var r1 error
	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
	if rf, ok := ret.Get(0).(func(*ssm.DeleteParameterInput) *ssm.DeleteParameterOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.DeleteParameterOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// DeleteParameterWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) DeleteParameterWithContext(_a0 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
	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)
		}
	}

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

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// DeleteParametersWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) DeleteParametersWithContext(_a0 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
	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)
		}
	}

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

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// DeletePatchBaselineWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) DeletePatchBaselineWithContext(_a0 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
	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)
		}
	}

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

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// DeleteResourceDataSyncWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) DeleteResourceDataSyncWithContext(_a0 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
	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)
		}
	}

	var r1 error
	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
}

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

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

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// DeregisterManagedInstanceWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) DeregisterManagedInstanceWithContext(_a0 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
	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)
		}
	}

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

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// DeregisterPatchBaselineForPatchGroupWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) DeregisterPatchBaselineForPatchGroupWithContext(_a0 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
	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)
		}
	}

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

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// DeregisterTargetFromMaintenanceWindowWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) DeregisterTargetFromMaintenanceWindowWithContext(_a0 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
	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)
		}
	}

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

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// DeregisterTaskFromMaintenanceWindowWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) DeregisterTaskFromMaintenanceWindowWithContext(_a0 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
	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)
		}
	}

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

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

	return r0, r1
}

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

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

	return r0
}

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

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

	return r0, r1
}

// DescribeActivationsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) DescribeActivationsWithContext(_a0 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
	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)
		}
	}

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

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

	return r0, r1
}

// 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
	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)
		}
	}

	var r1 error
	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
	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)
		}
	}

	var r1 *ssm.DescribeAssociationExecutionTargetsOutput
	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
	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)
		}
	}

	var r1 error
	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
	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)
		}
	}

	var r1 error
	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
	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)
		}
	}

	var r1 *ssm.DescribeAssociationExecutionsOutput
	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
	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)
		}
	}

	var r1 error
	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
	if rf, ok := ret.Get(0).(func(*ssm.DescribeAssociationInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

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

	return r0, r1
}

// DescribeAssociationWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) DescribeAssociationWithContext(_a0 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
	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)
		}
	}

	var r1 error
	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
}

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

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

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

	return r0, r1
}

// 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
	if rf, ok := ret.Get(0).(func(*ssm.DescribeAutomationExecutionsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

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

	return r0, r1
}

// DescribeAutomationExecutionsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) DescribeAutomationExecutionsWithContext(_a0 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
	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)
		}
	}

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

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

	return r0, r1
}

// 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
	if rf, ok := ret.Get(0).(func(*ssm.DescribeAutomationStepExecutionsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

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

	return r0, r1
}

// DescribeAutomationStepExecutionsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) DescribeAutomationStepExecutionsWithContext(_a0 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
	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)
		}
	}

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

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

	return r0, r1
}

// 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
	if rf, ok := ret.Get(0).(func(*ssm.DescribeAvailablePatchesInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

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

	return r0, r1
}

// DescribeAvailablePatchesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) DescribeAvailablePatchesWithContext(_a0 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
	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)
		}
	}

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

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// DescribeDocumentPermissionWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) DescribeDocumentPermissionWithContext(_a0 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
	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)
		}
	}

	var r1 error
	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
	if rf, ok := ret.Get(0).(func(*ssm.DescribeDocumentInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

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

	return r0, r1
}

// DescribeDocumentWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) DescribeDocumentWithContext(_a0 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
	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)
		}
	}

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

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

	return r0, r1
}

// 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
	if rf, ok := ret.Get(0).(func(*ssm.DescribeEffectiveInstanceAssociationsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

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

	return r0, r1
}

// DescribeEffectiveInstanceAssociationsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) DescribeEffectiveInstanceAssociationsWithContext(_a0 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
	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)
		}
	}

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

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

	return r0, r1
}

// 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
	if rf, ok := ret.Get(0).(func(*ssm.DescribeEffectivePatchesForPatchBaselineInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

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

	return r0, r1
}

// DescribeEffectivePatchesForPatchBaselineWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) DescribeEffectivePatchesForPatchBaselineWithContext(_a0 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
	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)
		}
	}

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

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

	return r0, r1
}

// 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
	if rf, ok := ret.Get(0).(func(*ssm.DescribeInstanceAssociationsStatusInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

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

	return r0, r1
}

// DescribeInstanceAssociationsStatusWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) DescribeInstanceAssociationsStatusWithContext(_a0 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
	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)
		}
	}

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

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

	return r0, r1
}

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

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

	return r0
}

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

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

	return r0, r1
}

// DescribeInstanceInformationWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) DescribeInstanceInformationWithContext(_a0 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
	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)
		}
	}

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

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// 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
	if rf, ok := ret.Get(0).(func(*ssm.DescribeInstancePatchStatesForPatchGroupInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

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

	return r0, r1
}

// DescribeInstancePatchStatesForPatchGroupWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) DescribeInstancePatchStatesForPatchGroupWithContext(_a0 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
	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)
		}
	}

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

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

	return r0, r1
}

// DescribeInstancePatchStatesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) DescribeInstancePatchStatesWithContext(_a0 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
	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)
		}
	}

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

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

	return r0, r1
}

// 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
	if rf, ok := ret.Get(0).(func(*ssm.DescribeInstancePatchesInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

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

	return r0, r1
}

// DescribeInstancePatchesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) DescribeInstancePatchesWithContext(_a0 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
	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)
		}
	}

	var r1 error
	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
}

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

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

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

	return r0, r1
}

// 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
	if rf, ok := ret.Get(0).(func(*ssm.DescribeInventoryDeletionsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

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

	return r0, r1
}

// DescribeInventoryDeletionsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) DescribeInventoryDeletionsWithContext(_a0 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
	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)
		}
	}

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

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

	return r0, r1
}

// 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
	if rf, ok := ret.Get(0).(func(*ssm.DescribeMaintenanceWindowExecutionTaskInvocationsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

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

	return r0, r1
}

// DescribeMaintenanceWindowExecutionTaskInvocationsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) DescribeMaintenanceWindowExecutionTaskInvocationsWithContext(_a0 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
	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)
		}
	}

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

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

	return r0, r1
}

// 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
	if rf, ok := ret.Get(0).(func(*ssm.DescribeMaintenanceWindowExecutionTasksInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

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

	return r0, r1
}

// DescribeMaintenanceWindowExecutionTasksWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) DescribeMaintenanceWindowExecutionTasksWithContext(_a0 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
	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)
		}
	}

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

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

	return r0, r1
}

// 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
	if rf, ok := ret.Get(0).(func(*ssm.DescribeMaintenanceWindowExecutionsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

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

	return r0, r1
}

// DescribeMaintenanceWindowExecutionsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) DescribeMaintenanceWindowExecutionsWithContext(_a0 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
	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)
		}
	}

	var r1 error
	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
	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)
		}
	}

	var r1 error
	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
	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)
		}
	}

	var r1 *ssm.DescribeMaintenanceWindowScheduleOutput
	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
	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)
		}
	}

	var r1 error
	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
	if rf, ok := ret.Get(0).(func(*ssm.DescribeMaintenanceWindowTargetsInput) *ssm.DescribeMaintenanceWindowTargetsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.DescribeMaintenanceWindowTargetsOutput)
		}
	}

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

	return r0, r1
}

// 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
	if rf, ok := ret.Get(0).(func(*ssm.DescribeMaintenanceWindowTargetsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

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

	return r0, r1
}

// DescribeMaintenanceWindowTargetsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) DescribeMaintenanceWindowTargetsWithContext(_a0 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
	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)
		}
	}

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

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

	return r0, r1
}

// 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
	if rf, ok := ret.Get(0).(func(*ssm.DescribeMaintenanceWindowTasksInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

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

	return r0, r1
}

// DescribeMaintenanceWindowTasksWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) DescribeMaintenanceWindowTasksWithContext(_a0 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
	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)
		}
	}

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

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

	return r0, r1
}

// 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
	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)
		}
	}

	var r1 error
	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
	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)
		}
	}

	var r1 *ssm.DescribeMaintenanceWindowsForTargetOutput
	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
	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)
		}
	}

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

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

	return r0, r1
}

// DescribeMaintenanceWindowsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) DescribeMaintenanceWindowsWithContext(_a0 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
	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)
		}
	}

	var r1 error
	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
	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)
		}
	}

	var r1 error
	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
	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)
		}
	}

	var r1 *ssm.DescribeOpsItemsOutput
	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
	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)
		}
	}

	var r1 error
	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
	if rf, ok := ret.Get(0).(func(*ssm.DescribeParametersInput) *ssm.DescribeParametersOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.DescribeParametersOutput)
		}
	}

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

	return r0, r1
}

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

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

	return r0
}

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

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

	return r0, r1
}

// DescribeParametersWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) DescribeParametersWithContext(_a0 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
	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)
		}
	}

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

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

	return r0, r1
}

// 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
	if rf, ok := ret.Get(0).(func(*ssm.DescribePatchBaselinesInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

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

	return r0, r1
}

// DescribePatchBaselinesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) DescribePatchBaselinesWithContext(_a0 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
	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)
		}
	}

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

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// DescribePatchGroupStateWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) DescribePatchGroupStateWithContext(_a0 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
	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)
		}
	}

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

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

	return r0, r1
}

// 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
	if rf, ok := ret.Get(0).(func(*ssm.DescribePatchGroupsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

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

	return r0, r1
}

// DescribePatchGroupsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) DescribePatchGroupsWithContext(_a0 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
	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)
		}
	}

	var r1 error
	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
	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)
		}
	}

	var r1 error
	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
	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)
		}
	}

	var r1 *ssm.DescribePatchPropertiesOutput
	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
	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)
		}
	}

	var r1 error
	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
	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)
		}
	}

	var r1 error
	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
	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)
		}
	}

	var r1 *ssm.DescribeSessionsOutput
	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
	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)
		}
	}

	var r1 error
	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
	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)
		}
	}

	var r1 error
	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
	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)
		}
	}

	var r1 *ssm.DisassociateOpsItemRelatedItemOutput
	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
	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)
		}
	}

	var r1 error
	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
}

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

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

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// GetAutomationExecutionWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) GetAutomationExecutionWithContext(_a0 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
	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)
		}
	}

	var r1 error
	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
}

// 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
	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)
		}
	}

	var r1 error
	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
	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)
		}
	}

	var r1 *ssm.GetCalendarStateOutput
	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
	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)
		}
	}

	var r1 error
	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
}

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

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

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// GetCommandInvocationWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) GetCommandInvocationWithContext(_a0 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
	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)
		}
	}

	var r1 error
	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
	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)
		}
	}

	var r1 error
	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
	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)
		}
	}

	var r1 *ssm.GetConnectionStatusOutput
	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
	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)
		}
	}

	var r1 error
	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
	if rf, ok := ret.Get(0).(func(*ssm.GetDefaultPatchBaselineInput) *ssm.GetDefaultPatchBaselineOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.GetDefaultPatchBaselineOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// GetDefaultPatchBaselineWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) GetDefaultPatchBaselineWithContext(_a0 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
	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)
		}
	}

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

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// GetDeployablePatchSnapshotForInstanceWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) GetDeployablePatchSnapshotForInstanceWithContext(_a0 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
	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)
		}
	}

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

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// GetDocumentWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) GetDocumentWithContext(_a0 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
	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)
		}
	}

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

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

	return r0, r1
}

// 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
	if rf, ok := ret.Get(0).(func(*ssm.GetInventoryInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// 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
	if rf, ok := ret.Get(0).(func(*ssm.GetInventorySchemaInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

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

	return r0, r1
}

// GetInventorySchemaWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) GetInventorySchemaWithContext(_a0 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
	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)
		}
	}

	var r1 error
	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
	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)
		}
	}

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

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// GetMaintenanceWindowExecutionTaskInvocationWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) GetMaintenanceWindowExecutionTaskInvocationWithContext(_a0 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
	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)
		}
	}

	var r1 error
	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
	if rf, ok := ret.Get(0).(func(*ssm.GetMaintenanceWindowExecutionTaskInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

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

	return r0, r1
}

// GetMaintenanceWindowExecutionTaskWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) GetMaintenanceWindowExecutionTaskWithContext(_a0 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
	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)
		}
	}

	var r1 error
	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
	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)
		}
	}

	var r1 error
	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
	if rf, ok := ret.Get(0).(func(*ssm.GetMaintenanceWindowInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// GetMaintenanceWindowTaskWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) GetMaintenanceWindowTaskWithContext(_a0 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
	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)
		}
	}

	var r1 error
	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
	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)
		}
	}

	var r1 error
	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
}

// 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
	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)
		}
	}

	var r1 error
	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
	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)
		}
	}

	var r1 *ssm.GetOpsItemOutput
	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
	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)
		}
	}

	var r1 error
	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
	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)
		}
	}

	var r1 error
	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
	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)
		}
	}

	var r1 *ssm.GetOpsMetadataOutput
	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
	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)
		}
	}

	var r1 error
	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
	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)
		}
	}

	var r1 error
	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
	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)
		}
	}

	var r1 *ssm.GetOpsSummaryOutput
	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
	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)
		}
	}

	var r1 error
	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
	if rf, ok := ret.Get(0).(func(*ssm.GetParameterInput) *ssm.GetParameterOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.GetParameterOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

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

	return r0
}

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

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

	return r0, r1
}

// GetParameterHistoryWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) GetParameterHistoryWithContext(_a0 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
	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)
		}
	}

	var r1 error
	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
	if rf, ok := ret.Get(0).(func(*ssm.GetParameterInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

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

	return r0, r1
}

// GetParameterWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) GetParameterWithContext(_a0 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
	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)
		}
	}

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

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

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

	return r0
}

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

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

	return r0, r1
}

// GetParametersByPathWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) GetParametersByPathWithContext(_a0 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
	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)
		}
	}

	var r1 error
	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
	if rf, ok := ret.Get(0).(func(*ssm.GetParametersInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

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

	return r0, r1
}

// GetParametersWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) GetParametersWithContext(_a0 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
	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)
		}
	}

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

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// GetPatchBaselineForPatchGroupWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) GetPatchBaselineForPatchGroupWithContext(_a0 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
	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)
		}
	}

	var r1 error
	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
	if rf, ok := ret.Get(0).(func(*ssm.GetPatchBaselineInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

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

	return r0, r1
}

// GetPatchBaselineWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) GetPatchBaselineWithContext(_a0 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
	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)
		}
	}

	var r1 error
	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
}

// 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
	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)
		}
	}

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

	var r1 *ssm.GetServiceSettingOutput
	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
	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)
		}
	}

	var r1 error
	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
	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)
		}
	}

	var r1 error
	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
	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)
		}
	}

	var r1 *ssm.LabelParameterVersionOutput
	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
	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)
		}
	}

	var r1 error
	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
	if rf, ok := ret.Get(0).(func(*ssm.ListAssociationVersionsInput) *ssm.ListAssociationVersionsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.ListAssociationVersionsOutput)
		}
	}

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

	return r0, r1
}

// 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
	if rf, ok := ret.Get(0).(func(*ssm.ListAssociationVersionsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

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

	return r0, r1
}

// ListAssociationVersionsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) ListAssociationVersionsWithContext(_a0 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
	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)
		}
	}

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

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

	return r0, r1
}

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

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

	return r0
}

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

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

	return r0, r1
}

// ListAssociationsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) ListAssociationsWithContext(_a0 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
	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)
		}
	}

	var r1 error
	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
}

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

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

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

	return r0, r1
}

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

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

	return r0
}

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

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

	return r0, r1
}

// ListCommandInvocationsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) ListCommandInvocationsWithContext(_a0 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
	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)
		}
	}

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

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

	return r0, r1
}

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

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

	return r0
}

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

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

	return r0, r1
}

// ListCommandsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) ListCommandsWithContext(_a0 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
	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)
		}
	}

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

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

	return r0, r1
}

// 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
	if rf, ok := ret.Get(0).(func(*ssm.ListComplianceItemsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

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

	return r0, r1
}

// ListComplianceItemsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) ListComplianceItemsWithContext(_a0 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
	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)
		}
	}

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

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

	return r0, r1
}

// 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
	if rf, ok := ret.Get(0).(func(*ssm.ListComplianceSummariesInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

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

	return r0, r1
}

// ListComplianceSummariesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) ListComplianceSummariesWithContext(_a0 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
	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)
		}
	}

	var r1 error
	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
}

// 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
	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)
		}
	}

	var r1 error
	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
	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)
		}
	}

	var r1 *ssm.ListDocumentMetadataHistoryOutput
	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
	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)
		}
	}

	var r1 error
	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
	if rf, ok := ret.Get(0).(func(*ssm.ListDocumentVersionsInput) *ssm.ListDocumentVersionsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.ListDocumentVersionsOutput)
		}
	}

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

	return r0, r1
}

// 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
	if rf, ok := ret.Get(0).(func(*ssm.ListDocumentVersionsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

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

	return r0, r1
}

// ListDocumentVersionsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) ListDocumentVersionsWithContext(_a0 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
	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)
		}
	}

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

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

	return r0, r1
}

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

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

	return r0
}

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

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

	return r0, r1
}

// ListDocumentsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) ListDocumentsWithContext(_a0 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
	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)
		}
	}

	var r1 error
	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
}

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

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

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// ListInventoryEntriesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) ListInventoryEntriesWithContext(_a0 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
	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)
		}
	}

	var r1 error
	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
	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)
		}
	}

	var r1 error
	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
	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)
		}
	}

	var r1 *ssm.ListOpsItemEventsOutput
	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
	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)
		}
	}

	var r1 error
	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
	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)
		}
	}

	var r1 error
	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
	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)
		}
	}

	var r1 *ssm.ListOpsItemRelatedItemsOutput
	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
	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)
		}
	}

	var r1 error
	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
	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)
		}
	}

	var r1 error
	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
	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)
		}
	}

	var r1 *ssm.ListOpsMetadataOutput
	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
	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)
		}
	}

	var r1 error
	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
	if rf, ok := ret.Get(0).(func(*ssm.ListResourceComplianceSummariesInput) *ssm.ListResourceComplianceSummariesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.ListResourceComplianceSummariesOutput)
		}
	}

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

	return r0, r1
}

// 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
	if rf, ok := ret.Get(0).(func(*ssm.ListResourceComplianceSummariesInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

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

	return r0, r1
}

// ListResourceComplianceSummariesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) ListResourceComplianceSummariesWithContext(_a0 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
	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)
		}
	}

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

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

	return r0, r1
}

// 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
	if rf, ok := ret.Get(0).(func(*ssm.ListResourceDataSyncInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

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

	return r0, r1
}

// ListResourceDataSyncWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) ListResourceDataSyncWithContext(_a0 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
	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)
		}
	}

	var r1 error
	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
}

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

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

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// ListTagsForResourceWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) ListTagsForResourceWithContext(_a0 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
	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)
		}
	}

	var r1 error
	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
}

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

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

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// ModifyDocumentPermissionWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) ModifyDocumentPermissionWithContext(_a0 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
	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)
		}
	}

	var r1 error
	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
}

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

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

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// PutComplianceItemsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) PutComplianceItemsWithContext(_a0 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
	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)
		}
	}

	var r1 error
	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
}

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

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

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// PutInventoryWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) PutInventoryWithContext(_a0 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
	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)
		}
	}

	var r1 error
	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
	if rf, ok := ret.Get(0).(func(*ssm.PutParameterInput) *ssm.PutParameterOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.PutParameterOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// PutParameterWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) PutParameterWithContext(_a0 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
	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)
		}
	}

	var r1 error
	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
}

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

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

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// RegisterDefaultPatchBaselineWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) RegisterDefaultPatchBaselineWithContext(_a0 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
	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)
		}
	}

	var r1 error
	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
}

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

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

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// RegisterPatchBaselineForPatchGroupWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) RegisterPatchBaselineForPatchGroupWithContext(_a0 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
	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)
		}
	}

	var r1 error
	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
	if rf, ok := ret.Get(0).(func(*ssm.RegisterTargetWithMaintenanceWindowInput) *ssm.RegisterTargetWithMaintenanceWindowOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.RegisterTargetWithMaintenanceWindowOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// RegisterTargetWithMaintenanceWindowWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) RegisterTargetWithMaintenanceWindowWithContext(_a0 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
	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)
		}
	}

	var r1 error
	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
	if rf, ok := ret.Get(0).(func(*ssm.RegisterTaskWithMaintenanceWindowInput) *ssm.RegisterTaskWithMaintenanceWindowOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.RegisterTaskWithMaintenanceWindowOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// RegisterTaskWithMaintenanceWindowWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) RegisterTaskWithMaintenanceWindowWithContext(_a0 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
	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)
		}
	}

	var r1 error
	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
	if rf, ok := ret.Get(0).(func(*ssm.RemoveTagsFromResourceInput) *ssm.RemoveTagsFromResourceOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.RemoveTagsFromResourceOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// RemoveTagsFromResourceWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) RemoveTagsFromResourceWithContext(_a0 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
	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)
		}
	}

	var r1 error
	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
}

// 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
	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)
		}
	}

	var r1 error
	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
	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)
		}
	}

	var r1 *ssm.ResetServiceSettingOutput
	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
	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)
		}
	}

	var r1 error
	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
	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)
		}
	}

	var r1 error
	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
	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)
		}
	}

	var r1 *ssm.ResumeSessionOutput
	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
	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)
		}
	}

	var r1 error
	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
	if rf, ok := ret.Get(0).(func(*ssm.SendAutomationSignalInput) *ssm.SendAutomationSignalOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.SendAutomationSignalOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// SendAutomationSignalWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) SendAutomationSignalWithContext(_a0 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
	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)
		}
	}

	var r1 error
	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
	if rf, ok := ret.Get(0).(func(*ssm.SendCommandInput) *ssm.SendCommandOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.SendCommandOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// SendCommandWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) SendCommandWithContext(_a0 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
	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)
		}
	}

	var r1 error
	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
	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)
		}
	}

	var r1 error
	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
	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)
		}
	}

	var r1 *ssm.StartAssociationsOnceOutput
	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
	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)
		}
	}

	var r1 error
	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
	if rf, ok := ret.Get(0).(func(*ssm.StartAutomationExecutionInput) *ssm.StartAutomationExecutionOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.StartAutomationExecutionOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// StartAutomationExecutionWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) StartAutomationExecutionWithContext(_a0 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
	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)
		}
	}

	var r1 error
	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
	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)
		}
	}

	var r1 error
	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
	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)
		}
	}

	var r1 *ssm.StartChangeRequestExecutionOutput
	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
	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)
		}
	}

	var r1 error
	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
	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)
		}
	}

	var r1 error
	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
	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)
		}
	}

	var r1 *ssm.StartSessionOutput
	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
	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)
		}
	}

	var r1 error
	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
	if rf, ok := ret.Get(0).(func(*ssm.StopAutomationExecutionInput) *ssm.StopAutomationExecutionOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.StopAutomationExecutionOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// StopAutomationExecutionWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) StopAutomationExecutionWithContext(_a0 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
	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)
		}
	}

	var r1 error
	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
	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)
		}
	}

	var r1 error
	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
	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)
		}
	}

	var r1 *ssm.TerminateSessionOutput
	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
	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)
		}
	}

	var r1 error
	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
	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)
		}
	}

	var r1 error
	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
	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)
		}
	}

	var r1 *ssm.UnlabelParameterVersionOutput
	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
	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)
		}
	}

	var r1 error
	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
}

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

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

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// UpdateAssociationStatusWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) UpdateAssociationStatusWithContext(_a0 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
	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)
		}
	}

	var r1 error
	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
	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)
		}
	}

	var r1 error
	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
	if rf, ok := ret.Get(0).(func(*ssm.UpdateDocumentInput) *ssm.UpdateDocumentOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.UpdateDocumentOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// UpdateDocumentDefaultVersionWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) UpdateDocumentDefaultVersionWithContext(_a0 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
	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)
		}
	}

	var r1 error
	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
	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)
		}
	}

	var r1 error
	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
	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)
		}
	}

	var r1 *ssm.UpdateDocumentMetadataOutput
	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
	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)
		}
	}

	var r1 error
	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
	if rf, ok := ret.Get(0).(func(*ssm.UpdateDocumentInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

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

	return r0, r1
}

// UpdateDocumentWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) UpdateDocumentWithContext(_a0 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
	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)
		}
	}

	var r1 error
	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
}

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

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

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// UpdateMaintenanceWindowTargetWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) UpdateMaintenanceWindowTargetWithContext(_a0 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
	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)
		}
	}

	var r1 error
	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
	if rf, ok := ret.Get(0).(func(*ssm.UpdateMaintenanceWindowTaskInput) *ssm.UpdateMaintenanceWindowTaskOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ssm.UpdateMaintenanceWindowTaskOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// UpdateMaintenanceWindowTaskWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) UpdateMaintenanceWindowTaskWithContext(_a0 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
	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)
		}
	}

	var r1 error
	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
	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)
		}
	}

	var r1 error
	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
}

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

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

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// UpdateManagedInstanceRoleWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) UpdateManagedInstanceRoleWithContext(_a0 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
	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)
		}
	}

	var r1 error
	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
	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)
		}
	}

	var r1 error
	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
	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)
		}
	}

	var r1 *ssm.UpdateOpsItemOutput
	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
	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)
		}
	}

	var r1 error
	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
	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)
		}
	}

	var r1 error
	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
	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)
		}
	}

	var r1 *ssm.UpdateOpsMetadataOutput
	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
	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)
		}
	}

	var r1 error
	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
}

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

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

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// UpdatePatchBaselineWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *SSMAPI) UpdatePatchBaselineWithContext(_a0 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
	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)
		}
	}

	var r1 error
	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
	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)
		}
	}

	var r1 error
	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
	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)
		}
	}

	var r1 *ssm.UpdateResourceDataSyncOutput
	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
	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)
		}
	}

	var r1 error
	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
}

// 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
	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)
		}
	}

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

	var r1 *ssm.UpdateServiceSettingOutput
	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
	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)
		}
	}

	var r1 error
	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
}

// 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
}