// Code generated by mockery v0.0.0-dev. DO NOT EDIT.

package aws

import (
	context "context"

	cloudfront "github.com/aws/aws-sdk-go/service/cloudfront"

	mock "github.com/stretchr/testify/mock"

	request "github.com/aws/aws-sdk-go/aws/request"
)

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

// CreateCachePolicy provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) CreateCachePolicy(_a0 *cloudfront.CreateCachePolicyInput) (*cloudfront.CreateCachePolicyOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudfront.CreateCachePolicyOutput
	if rf, ok := ret.Get(0).(func(*cloudfront.CreateCachePolicyInput) *cloudfront.CreateCachePolicyOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudfront.CreateCachePolicyOutput)
		}
	}

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

	return r0, r1
}

// CreateCachePolicyRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) CreateCachePolicyRequest(_a0 *cloudfront.CreateCachePolicyInput) (*request.Request, *cloudfront.CreateCachePolicyOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudfront.CreateCachePolicyOutput
	if rf, ok := ret.Get(1).(func(*cloudfront.CreateCachePolicyInput) *cloudfront.CreateCachePolicyOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudfront.CreateCachePolicyOutput)
		}
	}

	return r0, r1
}

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

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

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

	return r0, r1
}

// CreateCloudFrontOriginAccessIdentity provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) CreateCloudFrontOriginAccessIdentity(_a0 *cloudfront.CreateCloudFrontOriginAccessIdentityInput) (*cloudfront.CreateCloudFrontOriginAccessIdentityOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudfront.CreateCloudFrontOriginAccessIdentityOutput
	if rf, ok := ret.Get(0).(func(*cloudfront.CreateCloudFrontOriginAccessIdentityInput) *cloudfront.CreateCloudFrontOriginAccessIdentityOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudfront.CreateCloudFrontOriginAccessIdentityOutput)
		}
	}

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

	return r0, r1
}

// CreateCloudFrontOriginAccessIdentityRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) CreateCloudFrontOriginAccessIdentityRequest(_a0 *cloudfront.CreateCloudFrontOriginAccessIdentityInput) (*request.Request, *cloudfront.CreateCloudFrontOriginAccessIdentityOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudfront.CreateCloudFrontOriginAccessIdentityOutput
	if rf, ok := ret.Get(1).(func(*cloudfront.CreateCloudFrontOriginAccessIdentityInput) *cloudfront.CreateCloudFrontOriginAccessIdentityOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudfront.CreateCloudFrontOriginAccessIdentityOutput)
		}
	}

	return r0, r1
}

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

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

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

	return r0, r1
}

// CreateDistribution provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) CreateDistribution(_a0 *cloudfront.CreateDistributionInput) (*cloudfront.CreateDistributionOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudfront.CreateDistributionOutput
	if rf, ok := ret.Get(0).(func(*cloudfront.CreateDistributionInput) *cloudfront.CreateDistributionOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudfront.CreateDistributionOutput)
		}
	}

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

	return r0, r1
}

// CreateDistributionRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) CreateDistributionRequest(_a0 *cloudfront.CreateDistributionInput) (*request.Request, *cloudfront.CreateDistributionOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudfront.CreateDistributionOutput
	if rf, ok := ret.Get(1).(func(*cloudfront.CreateDistributionInput) *cloudfront.CreateDistributionOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudfront.CreateDistributionOutput)
		}
	}

	return r0, r1
}

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

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

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

	return r0, r1
}

// CreateDistributionWithTags provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) CreateDistributionWithTags(_a0 *cloudfront.CreateDistributionWithTagsInput) (*cloudfront.CreateDistributionWithTagsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudfront.CreateDistributionWithTagsOutput
	if rf, ok := ret.Get(0).(func(*cloudfront.CreateDistributionWithTagsInput) *cloudfront.CreateDistributionWithTagsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudfront.CreateDistributionWithTagsOutput)
		}
	}

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

	return r0, r1
}

// CreateDistributionWithTagsRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) CreateDistributionWithTagsRequest(_a0 *cloudfront.CreateDistributionWithTagsInput) (*request.Request, *cloudfront.CreateDistributionWithTagsOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudfront.CreateDistributionWithTagsOutput
	if rf, ok := ret.Get(1).(func(*cloudfront.CreateDistributionWithTagsInput) *cloudfront.CreateDistributionWithTagsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudfront.CreateDistributionWithTagsOutput)
		}
	}

	return r0, r1
}

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

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

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

	return r0, r1
}

// CreateFieldLevelEncryptionConfig provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) CreateFieldLevelEncryptionConfig(_a0 *cloudfront.CreateFieldLevelEncryptionConfigInput) (*cloudfront.CreateFieldLevelEncryptionConfigOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudfront.CreateFieldLevelEncryptionConfigOutput
	if rf, ok := ret.Get(0).(func(*cloudfront.CreateFieldLevelEncryptionConfigInput) *cloudfront.CreateFieldLevelEncryptionConfigOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudfront.CreateFieldLevelEncryptionConfigOutput)
		}
	}

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

	return r0, r1
}

// CreateFieldLevelEncryptionConfigRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) CreateFieldLevelEncryptionConfigRequest(_a0 *cloudfront.CreateFieldLevelEncryptionConfigInput) (*request.Request, *cloudfront.CreateFieldLevelEncryptionConfigOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudfront.CreateFieldLevelEncryptionConfigOutput
	if rf, ok := ret.Get(1).(func(*cloudfront.CreateFieldLevelEncryptionConfigInput) *cloudfront.CreateFieldLevelEncryptionConfigOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudfront.CreateFieldLevelEncryptionConfigOutput)
		}
	}

	return r0, r1
}

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

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

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

	return r0, r1
}

// CreateFieldLevelEncryptionProfile provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) CreateFieldLevelEncryptionProfile(_a0 *cloudfront.CreateFieldLevelEncryptionProfileInput) (*cloudfront.CreateFieldLevelEncryptionProfileOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudfront.CreateFieldLevelEncryptionProfileOutput
	if rf, ok := ret.Get(0).(func(*cloudfront.CreateFieldLevelEncryptionProfileInput) *cloudfront.CreateFieldLevelEncryptionProfileOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudfront.CreateFieldLevelEncryptionProfileOutput)
		}
	}

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

	return r0, r1
}

// CreateFieldLevelEncryptionProfileRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) CreateFieldLevelEncryptionProfileRequest(_a0 *cloudfront.CreateFieldLevelEncryptionProfileInput) (*request.Request, *cloudfront.CreateFieldLevelEncryptionProfileOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudfront.CreateFieldLevelEncryptionProfileOutput
	if rf, ok := ret.Get(1).(func(*cloudfront.CreateFieldLevelEncryptionProfileInput) *cloudfront.CreateFieldLevelEncryptionProfileOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudfront.CreateFieldLevelEncryptionProfileOutput)
		}
	}

	return r0, r1
}

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

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

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

	return r0, r1
}

// CreateInvalidation provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) CreateInvalidation(_a0 *cloudfront.CreateInvalidationInput) (*cloudfront.CreateInvalidationOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudfront.CreateInvalidationOutput
	if rf, ok := ret.Get(0).(func(*cloudfront.CreateInvalidationInput) *cloudfront.CreateInvalidationOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudfront.CreateInvalidationOutput)
		}
	}

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

	return r0, r1
}

// CreateInvalidationRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) CreateInvalidationRequest(_a0 *cloudfront.CreateInvalidationInput) (*request.Request, *cloudfront.CreateInvalidationOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudfront.CreateInvalidationOutput
	if rf, ok := ret.Get(1).(func(*cloudfront.CreateInvalidationInput) *cloudfront.CreateInvalidationOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudfront.CreateInvalidationOutput)
		}
	}

	return r0, r1
}

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

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

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

	return r0, r1
}

// CreateOriginRequestPolicy provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) CreateOriginRequestPolicy(_a0 *cloudfront.CreateOriginRequestPolicyInput) (*cloudfront.CreateOriginRequestPolicyOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudfront.CreateOriginRequestPolicyOutput
	if rf, ok := ret.Get(0).(func(*cloudfront.CreateOriginRequestPolicyInput) *cloudfront.CreateOriginRequestPolicyOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudfront.CreateOriginRequestPolicyOutput)
		}
	}

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

	return r0, r1
}

// CreateOriginRequestPolicyRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) CreateOriginRequestPolicyRequest(_a0 *cloudfront.CreateOriginRequestPolicyInput) (*request.Request, *cloudfront.CreateOriginRequestPolicyOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudfront.CreateOriginRequestPolicyOutput
	if rf, ok := ret.Get(1).(func(*cloudfront.CreateOriginRequestPolicyInput) *cloudfront.CreateOriginRequestPolicyOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudfront.CreateOriginRequestPolicyOutput)
		}
	}

	return r0, r1
}

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

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

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

	return r0, r1
}

// CreatePublicKey provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) CreatePublicKey(_a0 *cloudfront.CreatePublicKeyInput) (*cloudfront.CreatePublicKeyOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudfront.CreatePublicKeyOutput
	if rf, ok := ret.Get(0).(func(*cloudfront.CreatePublicKeyInput) *cloudfront.CreatePublicKeyOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudfront.CreatePublicKeyOutput)
		}
	}

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

	return r0, r1
}

// CreatePublicKeyRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) CreatePublicKeyRequest(_a0 *cloudfront.CreatePublicKeyInput) (*request.Request, *cloudfront.CreatePublicKeyOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudfront.CreatePublicKeyOutput
	if rf, ok := ret.Get(1).(func(*cloudfront.CreatePublicKeyInput) *cloudfront.CreatePublicKeyOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudfront.CreatePublicKeyOutput)
		}
	}

	return r0, r1
}

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

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

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

	return r0, r1
}

// CreateStreamingDistribution provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) CreateStreamingDistribution(_a0 *cloudfront.CreateStreamingDistributionInput) (*cloudfront.CreateStreamingDistributionOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudfront.CreateStreamingDistributionOutput
	if rf, ok := ret.Get(0).(func(*cloudfront.CreateStreamingDistributionInput) *cloudfront.CreateStreamingDistributionOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudfront.CreateStreamingDistributionOutput)
		}
	}

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

	return r0, r1
}

// CreateStreamingDistributionRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) CreateStreamingDistributionRequest(_a0 *cloudfront.CreateStreamingDistributionInput) (*request.Request, *cloudfront.CreateStreamingDistributionOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudfront.CreateStreamingDistributionOutput
	if rf, ok := ret.Get(1).(func(*cloudfront.CreateStreamingDistributionInput) *cloudfront.CreateStreamingDistributionOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudfront.CreateStreamingDistributionOutput)
		}
	}

	return r0, r1
}

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

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

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

	return r0, r1
}

// CreateStreamingDistributionWithTags provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) CreateStreamingDistributionWithTags(_a0 *cloudfront.CreateStreamingDistributionWithTagsInput) (*cloudfront.CreateStreamingDistributionWithTagsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudfront.CreateStreamingDistributionWithTagsOutput
	if rf, ok := ret.Get(0).(func(*cloudfront.CreateStreamingDistributionWithTagsInput) *cloudfront.CreateStreamingDistributionWithTagsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudfront.CreateStreamingDistributionWithTagsOutput)
		}
	}

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

	return r0, r1
}

// CreateStreamingDistributionWithTagsRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) CreateStreamingDistributionWithTagsRequest(_a0 *cloudfront.CreateStreamingDistributionWithTagsInput) (*request.Request, *cloudfront.CreateStreamingDistributionWithTagsOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudfront.CreateStreamingDistributionWithTagsOutput
	if rf, ok := ret.Get(1).(func(*cloudfront.CreateStreamingDistributionWithTagsInput) *cloudfront.CreateStreamingDistributionWithTagsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudfront.CreateStreamingDistributionWithTagsOutput)
		}
	}

	return r0, r1
}

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

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

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

	return r0, r1
}

// DeleteCachePolicy provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) DeleteCachePolicy(_a0 *cloudfront.DeleteCachePolicyInput) (*cloudfront.DeleteCachePolicyOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudfront.DeleteCachePolicyOutput
	if rf, ok := ret.Get(0).(func(*cloudfront.DeleteCachePolicyInput) *cloudfront.DeleteCachePolicyOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudfront.DeleteCachePolicyOutput)
		}
	}

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

	return r0, r1
}

// DeleteCachePolicyRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) DeleteCachePolicyRequest(_a0 *cloudfront.DeleteCachePolicyInput) (*request.Request, *cloudfront.DeleteCachePolicyOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudfront.DeleteCachePolicyOutput
	if rf, ok := ret.Get(1).(func(*cloudfront.DeleteCachePolicyInput) *cloudfront.DeleteCachePolicyOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudfront.DeleteCachePolicyOutput)
		}
	}

	return r0, r1
}

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

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

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

	return r0, r1
}

// DeleteCloudFrontOriginAccessIdentity provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) DeleteCloudFrontOriginAccessIdentity(_a0 *cloudfront.DeleteCloudFrontOriginAccessIdentityInput) (*cloudfront.DeleteCloudFrontOriginAccessIdentityOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudfront.DeleteCloudFrontOriginAccessIdentityOutput
	if rf, ok := ret.Get(0).(func(*cloudfront.DeleteCloudFrontOriginAccessIdentityInput) *cloudfront.DeleteCloudFrontOriginAccessIdentityOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudfront.DeleteCloudFrontOriginAccessIdentityOutput)
		}
	}

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

	return r0, r1
}

// DeleteCloudFrontOriginAccessIdentityRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) DeleteCloudFrontOriginAccessIdentityRequest(_a0 *cloudfront.DeleteCloudFrontOriginAccessIdentityInput) (*request.Request, *cloudfront.DeleteCloudFrontOriginAccessIdentityOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudfront.DeleteCloudFrontOriginAccessIdentityOutput
	if rf, ok := ret.Get(1).(func(*cloudfront.DeleteCloudFrontOriginAccessIdentityInput) *cloudfront.DeleteCloudFrontOriginAccessIdentityOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudfront.DeleteCloudFrontOriginAccessIdentityOutput)
		}
	}

	return r0, r1
}

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

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

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

	return r0, r1
}

// DeleteDistribution provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) DeleteDistribution(_a0 *cloudfront.DeleteDistributionInput) (*cloudfront.DeleteDistributionOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudfront.DeleteDistributionOutput
	if rf, ok := ret.Get(0).(func(*cloudfront.DeleteDistributionInput) *cloudfront.DeleteDistributionOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudfront.DeleteDistributionOutput)
		}
	}

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

	return r0, r1
}

// DeleteDistributionRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) DeleteDistributionRequest(_a0 *cloudfront.DeleteDistributionInput) (*request.Request, *cloudfront.DeleteDistributionOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudfront.DeleteDistributionOutput
	if rf, ok := ret.Get(1).(func(*cloudfront.DeleteDistributionInput) *cloudfront.DeleteDistributionOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudfront.DeleteDistributionOutput)
		}
	}

	return r0, r1
}

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

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

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

	return r0, r1
}

// DeleteFieldLevelEncryptionConfig provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) DeleteFieldLevelEncryptionConfig(_a0 *cloudfront.DeleteFieldLevelEncryptionConfigInput) (*cloudfront.DeleteFieldLevelEncryptionConfigOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudfront.DeleteFieldLevelEncryptionConfigOutput
	if rf, ok := ret.Get(0).(func(*cloudfront.DeleteFieldLevelEncryptionConfigInput) *cloudfront.DeleteFieldLevelEncryptionConfigOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudfront.DeleteFieldLevelEncryptionConfigOutput)
		}
	}

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

	return r0, r1
}

// DeleteFieldLevelEncryptionConfigRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) DeleteFieldLevelEncryptionConfigRequest(_a0 *cloudfront.DeleteFieldLevelEncryptionConfigInput) (*request.Request, *cloudfront.DeleteFieldLevelEncryptionConfigOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudfront.DeleteFieldLevelEncryptionConfigOutput
	if rf, ok := ret.Get(1).(func(*cloudfront.DeleteFieldLevelEncryptionConfigInput) *cloudfront.DeleteFieldLevelEncryptionConfigOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudfront.DeleteFieldLevelEncryptionConfigOutput)
		}
	}

	return r0, r1
}

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

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

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

	return r0, r1
}

// DeleteFieldLevelEncryptionProfile provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) DeleteFieldLevelEncryptionProfile(_a0 *cloudfront.DeleteFieldLevelEncryptionProfileInput) (*cloudfront.DeleteFieldLevelEncryptionProfileOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudfront.DeleteFieldLevelEncryptionProfileOutput
	if rf, ok := ret.Get(0).(func(*cloudfront.DeleteFieldLevelEncryptionProfileInput) *cloudfront.DeleteFieldLevelEncryptionProfileOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudfront.DeleteFieldLevelEncryptionProfileOutput)
		}
	}

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

	return r0, r1
}

// DeleteFieldLevelEncryptionProfileRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) DeleteFieldLevelEncryptionProfileRequest(_a0 *cloudfront.DeleteFieldLevelEncryptionProfileInput) (*request.Request, *cloudfront.DeleteFieldLevelEncryptionProfileOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudfront.DeleteFieldLevelEncryptionProfileOutput
	if rf, ok := ret.Get(1).(func(*cloudfront.DeleteFieldLevelEncryptionProfileInput) *cloudfront.DeleteFieldLevelEncryptionProfileOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudfront.DeleteFieldLevelEncryptionProfileOutput)
		}
	}

	return r0, r1
}

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

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

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

	return r0, r1
}

// DeleteOriginRequestPolicy provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) DeleteOriginRequestPolicy(_a0 *cloudfront.DeleteOriginRequestPolicyInput) (*cloudfront.DeleteOriginRequestPolicyOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudfront.DeleteOriginRequestPolicyOutput
	if rf, ok := ret.Get(0).(func(*cloudfront.DeleteOriginRequestPolicyInput) *cloudfront.DeleteOriginRequestPolicyOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudfront.DeleteOriginRequestPolicyOutput)
		}
	}

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

	return r0, r1
}

// DeleteOriginRequestPolicyRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) DeleteOriginRequestPolicyRequest(_a0 *cloudfront.DeleteOriginRequestPolicyInput) (*request.Request, *cloudfront.DeleteOriginRequestPolicyOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudfront.DeleteOriginRequestPolicyOutput
	if rf, ok := ret.Get(1).(func(*cloudfront.DeleteOriginRequestPolicyInput) *cloudfront.DeleteOriginRequestPolicyOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudfront.DeleteOriginRequestPolicyOutput)
		}
	}

	return r0, r1
}

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

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

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

	return r0, r1
}

// DeletePublicKey provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) DeletePublicKey(_a0 *cloudfront.DeletePublicKeyInput) (*cloudfront.DeletePublicKeyOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudfront.DeletePublicKeyOutput
	if rf, ok := ret.Get(0).(func(*cloudfront.DeletePublicKeyInput) *cloudfront.DeletePublicKeyOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudfront.DeletePublicKeyOutput)
		}
	}

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

	return r0, r1
}

// DeletePublicKeyRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) DeletePublicKeyRequest(_a0 *cloudfront.DeletePublicKeyInput) (*request.Request, *cloudfront.DeletePublicKeyOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudfront.DeletePublicKeyOutput
	if rf, ok := ret.Get(1).(func(*cloudfront.DeletePublicKeyInput) *cloudfront.DeletePublicKeyOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudfront.DeletePublicKeyOutput)
		}
	}

	return r0, r1
}

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

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

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

	return r0, r1
}

// DeleteStreamingDistribution provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) DeleteStreamingDistribution(_a0 *cloudfront.DeleteStreamingDistributionInput) (*cloudfront.DeleteStreamingDistributionOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudfront.DeleteStreamingDistributionOutput
	if rf, ok := ret.Get(0).(func(*cloudfront.DeleteStreamingDistributionInput) *cloudfront.DeleteStreamingDistributionOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudfront.DeleteStreamingDistributionOutput)
		}
	}

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

	return r0, r1
}

// DeleteStreamingDistributionRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) DeleteStreamingDistributionRequest(_a0 *cloudfront.DeleteStreamingDistributionInput) (*request.Request, *cloudfront.DeleteStreamingDistributionOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudfront.DeleteStreamingDistributionOutput
	if rf, ok := ret.Get(1).(func(*cloudfront.DeleteStreamingDistributionInput) *cloudfront.DeleteStreamingDistributionOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudfront.DeleteStreamingDistributionOutput)
		}
	}

	return r0, r1
}

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

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

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

	return r0, r1
}

// GetCachePolicy provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) GetCachePolicy(_a0 *cloudfront.GetCachePolicyInput) (*cloudfront.GetCachePolicyOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudfront.GetCachePolicyOutput
	if rf, ok := ret.Get(0).(func(*cloudfront.GetCachePolicyInput) *cloudfront.GetCachePolicyOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudfront.GetCachePolicyOutput)
		}
	}

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

	return r0, r1
}

// GetCachePolicyConfig provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) GetCachePolicyConfig(_a0 *cloudfront.GetCachePolicyConfigInput) (*cloudfront.GetCachePolicyConfigOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudfront.GetCachePolicyConfigOutput
	if rf, ok := ret.Get(0).(func(*cloudfront.GetCachePolicyConfigInput) *cloudfront.GetCachePolicyConfigOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudfront.GetCachePolicyConfigOutput)
		}
	}

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

	return r0, r1
}

// GetCachePolicyConfigRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) GetCachePolicyConfigRequest(_a0 *cloudfront.GetCachePolicyConfigInput) (*request.Request, *cloudfront.GetCachePolicyConfigOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudfront.GetCachePolicyConfigOutput
	if rf, ok := ret.Get(1).(func(*cloudfront.GetCachePolicyConfigInput) *cloudfront.GetCachePolicyConfigOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudfront.GetCachePolicyConfigOutput)
		}
	}

	return r0, r1
}

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

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

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

	return r0, r1
}

// GetCachePolicyRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) GetCachePolicyRequest(_a0 *cloudfront.GetCachePolicyInput) (*request.Request, *cloudfront.GetCachePolicyOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudfront.GetCachePolicyOutput
	if rf, ok := ret.Get(1).(func(*cloudfront.GetCachePolicyInput) *cloudfront.GetCachePolicyOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudfront.GetCachePolicyOutput)
		}
	}

	return r0, r1
}

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

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

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

	return r0, r1
}

// GetCloudFrontOriginAccessIdentity provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) GetCloudFrontOriginAccessIdentity(_a0 *cloudfront.GetCloudFrontOriginAccessIdentityInput) (*cloudfront.GetCloudFrontOriginAccessIdentityOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudfront.GetCloudFrontOriginAccessIdentityOutput
	if rf, ok := ret.Get(0).(func(*cloudfront.GetCloudFrontOriginAccessIdentityInput) *cloudfront.GetCloudFrontOriginAccessIdentityOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudfront.GetCloudFrontOriginAccessIdentityOutput)
		}
	}

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

	return r0, r1
}

// GetCloudFrontOriginAccessIdentityConfig provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) GetCloudFrontOriginAccessIdentityConfig(_a0 *cloudfront.GetCloudFrontOriginAccessIdentityConfigInput) (*cloudfront.GetCloudFrontOriginAccessIdentityConfigOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudfront.GetCloudFrontOriginAccessIdentityConfigOutput
	if rf, ok := ret.Get(0).(func(*cloudfront.GetCloudFrontOriginAccessIdentityConfigInput) *cloudfront.GetCloudFrontOriginAccessIdentityConfigOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudfront.GetCloudFrontOriginAccessIdentityConfigOutput)
		}
	}

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

	return r0, r1
}

// GetCloudFrontOriginAccessIdentityConfigRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) GetCloudFrontOriginAccessIdentityConfigRequest(_a0 *cloudfront.GetCloudFrontOriginAccessIdentityConfigInput) (*request.Request, *cloudfront.GetCloudFrontOriginAccessIdentityConfigOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudfront.GetCloudFrontOriginAccessIdentityConfigOutput
	if rf, ok := ret.Get(1).(func(*cloudfront.GetCloudFrontOriginAccessIdentityConfigInput) *cloudfront.GetCloudFrontOriginAccessIdentityConfigOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudfront.GetCloudFrontOriginAccessIdentityConfigOutput)
		}
	}

	return r0, r1
}

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

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

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

	return r0, r1
}

// GetCloudFrontOriginAccessIdentityRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) GetCloudFrontOriginAccessIdentityRequest(_a0 *cloudfront.GetCloudFrontOriginAccessIdentityInput) (*request.Request, *cloudfront.GetCloudFrontOriginAccessIdentityOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudfront.GetCloudFrontOriginAccessIdentityOutput
	if rf, ok := ret.Get(1).(func(*cloudfront.GetCloudFrontOriginAccessIdentityInput) *cloudfront.GetCloudFrontOriginAccessIdentityOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudfront.GetCloudFrontOriginAccessIdentityOutput)
		}
	}

	return r0, r1
}

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

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

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

	return r0, r1
}

// GetDistribution provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) GetDistribution(_a0 *cloudfront.GetDistributionInput) (*cloudfront.GetDistributionOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudfront.GetDistributionOutput
	if rf, ok := ret.Get(0).(func(*cloudfront.GetDistributionInput) *cloudfront.GetDistributionOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudfront.GetDistributionOutput)
		}
	}

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

	return r0, r1
}

// GetDistributionConfig provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) GetDistributionConfig(_a0 *cloudfront.GetDistributionConfigInput) (*cloudfront.GetDistributionConfigOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudfront.GetDistributionConfigOutput
	if rf, ok := ret.Get(0).(func(*cloudfront.GetDistributionConfigInput) *cloudfront.GetDistributionConfigOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudfront.GetDistributionConfigOutput)
		}
	}

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

	return r0, r1
}

// GetDistributionConfigRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) GetDistributionConfigRequest(_a0 *cloudfront.GetDistributionConfigInput) (*request.Request, *cloudfront.GetDistributionConfigOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudfront.GetDistributionConfigOutput
	if rf, ok := ret.Get(1).(func(*cloudfront.GetDistributionConfigInput) *cloudfront.GetDistributionConfigOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudfront.GetDistributionConfigOutput)
		}
	}

	return r0, r1
}

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

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

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

	return r0, r1
}

// GetDistributionRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) GetDistributionRequest(_a0 *cloudfront.GetDistributionInput) (*request.Request, *cloudfront.GetDistributionOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudfront.GetDistributionOutput
	if rf, ok := ret.Get(1).(func(*cloudfront.GetDistributionInput) *cloudfront.GetDistributionOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudfront.GetDistributionOutput)
		}
	}

	return r0, r1
}

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

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

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

	return r0, r1
}

// GetFieldLevelEncryption provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) GetFieldLevelEncryption(_a0 *cloudfront.GetFieldLevelEncryptionInput) (*cloudfront.GetFieldLevelEncryptionOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudfront.GetFieldLevelEncryptionOutput
	if rf, ok := ret.Get(0).(func(*cloudfront.GetFieldLevelEncryptionInput) *cloudfront.GetFieldLevelEncryptionOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudfront.GetFieldLevelEncryptionOutput)
		}
	}

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

	return r0, r1
}

// GetFieldLevelEncryptionConfig provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) GetFieldLevelEncryptionConfig(_a0 *cloudfront.GetFieldLevelEncryptionConfigInput) (*cloudfront.GetFieldLevelEncryptionConfigOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudfront.GetFieldLevelEncryptionConfigOutput
	if rf, ok := ret.Get(0).(func(*cloudfront.GetFieldLevelEncryptionConfigInput) *cloudfront.GetFieldLevelEncryptionConfigOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudfront.GetFieldLevelEncryptionConfigOutput)
		}
	}

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

	return r0, r1
}

// GetFieldLevelEncryptionConfigRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) GetFieldLevelEncryptionConfigRequest(_a0 *cloudfront.GetFieldLevelEncryptionConfigInput) (*request.Request, *cloudfront.GetFieldLevelEncryptionConfigOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudfront.GetFieldLevelEncryptionConfigOutput
	if rf, ok := ret.Get(1).(func(*cloudfront.GetFieldLevelEncryptionConfigInput) *cloudfront.GetFieldLevelEncryptionConfigOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudfront.GetFieldLevelEncryptionConfigOutput)
		}
	}

	return r0, r1
}

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

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

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

	return r0, r1
}

// GetFieldLevelEncryptionProfile provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) GetFieldLevelEncryptionProfile(_a0 *cloudfront.GetFieldLevelEncryptionProfileInput) (*cloudfront.GetFieldLevelEncryptionProfileOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudfront.GetFieldLevelEncryptionProfileOutput
	if rf, ok := ret.Get(0).(func(*cloudfront.GetFieldLevelEncryptionProfileInput) *cloudfront.GetFieldLevelEncryptionProfileOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudfront.GetFieldLevelEncryptionProfileOutput)
		}
	}

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

	return r0, r1
}

// GetFieldLevelEncryptionProfileConfig provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) GetFieldLevelEncryptionProfileConfig(_a0 *cloudfront.GetFieldLevelEncryptionProfileConfigInput) (*cloudfront.GetFieldLevelEncryptionProfileConfigOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudfront.GetFieldLevelEncryptionProfileConfigOutput
	if rf, ok := ret.Get(0).(func(*cloudfront.GetFieldLevelEncryptionProfileConfigInput) *cloudfront.GetFieldLevelEncryptionProfileConfigOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudfront.GetFieldLevelEncryptionProfileConfigOutput)
		}
	}

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

	return r0, r1
}

// GetFieldLevelEncryptionProfileConfigRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) GetFieldLevelEncryptionProfileConfigRequest(_a0 *cloudfront.GetFieldLevelEncryptionProfileConfigInput) (*request.Request, *cloudfront.GetFieldLevelEncryptionProfileConfigOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudfront.GetFieldLevelEncryptionProfileConfigOutput
	if rf, ok := ret.Get(1).(func(*cloudfront.GetFieldLevelEncryptionProfileConfigInput) *cloudfront.GetFieldLevelEncryptionProfileConfigOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudfront.GetFieldLevelEncryptionProfileConfigOutput)
		}
	}

	return r0, r1
}

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

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

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

	return r0, r1
}

// GetFieldLevelEncryptionProfileRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) GetFieldLevelEncryptionProfileRequest(_a0 *cloudfront.GetFieldLevelEncryptionProfileInput) (*request.Request, *cloudfront.GetFieldLevelEncryptionProfileOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudfront.GetFieldLevelEncryptionProfileOutput
	if rf, ok := ret.Get(1).(func(*cloudfront.GetFieldLevelEncryptionProfileInput) *cloudfront.GetFieldLevelEncryptionProfileOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudfront.GetFieldLevelEncryptionProfileOutput)
		}
	}

	return r0, r1
}

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

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

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

	return r0, r1
}

// GetFieldLevelEncryptionRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) GetFieldLevelEncryptionRequest(_a0 *cloudfront.GetFieldLevelEncryptionInput) (*request.Request, *cloudfront.GetFieldLevelEncryptionOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudfront.GetFieldLevelEncryptionOutput
	if rf, ok := ret.Get(1).(func(*cloudfront.GetFieldLevelEncryptionInput) *cloudfront.GetFieldLevelEncryptionOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudfront.GetFieldLevelEncryptionOutput)
		}
	}

	return r0, r1
}

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

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

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

	return r0, r1
}

// GetInvalidation provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) GetInvalidation(_a0 *cloudfront.GetInvalidationInput) (*cloudfront.GetInvalidationOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudfront.GetInvalidationOutput
	if rf, ok := ret.Get(0).(func(*cloudfront.GetInvalidationInput) *cloudfront.GetInvalidationOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudfront.GetInvalidationOutput)
		}
	}

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

	return r0, r1
}

// GetInvalidationRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) GetInvalidationRequest(_a0 *cloudfront.GetInvalidationInput) (*request.Request, *cloudfront.GetInvalidationOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudfront.GetInvalidationOutput
	if rf, ok := ret.Get(1).(func(*cloudfront.GetInvalidationInput) *cloudfront.GetInvalidationOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudfront.GetInvalidationOutput)
		}
	}

	return r0, r1
}

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

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

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

	return r0, r1
}

// GetOriginRequestPolicy provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) GetOriginRequestPolicy(_a0 *cloudfront.GetOriginRequestPolicyInput) (*cloudfront.GetOriginRequestPolicyOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudfront.GetOriginRequestPolicyOutput
	if rf, ok := ret.Get(0).(func(*cloudfront.GetOriginRequestPolicyInput) *cloudfront.GetOriginRequestPolicyOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudfront.GetOriginRequestPolicyOutput)
		}
	}

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

	return r0, r1
}

// GetOriginRequestPolicyConfig provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) GetOriginRequestPolicyConfig(_a0 *cloudfront.GetOriginRequestPolicyConfigInput) (*cloudfront.GetOriginRequestPolicyConfigOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudfront.GetOriginRequestPolicyConfigOutput
	if rf, ok := ret.Get(0).(func(*cloudfront.GetOriginRequestPolicyConfigInput) *cloudfront.GetOriginRequestPolicyConfigOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudfront.GetOriginRequestPolicyConfigOutput)
		}
	}

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

	return r0, r1
}

// GetOriginRequestPolicyConfigRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) GetOriginRequestPolicyConfigRequest(_a0 *cloudfront.GetOriginRequestPolicyConfigInput) (*request.Request, *cloudfront.GetOriginRequestPolicyConfigOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudfront.GetOriginRequestPolicyConfigOutput
	if rf, ok := ret.Get(1).(func(*cloudfront.GetOriginRequestPolicyConfigInput) *cloudfront.GetOriginRequestPolicyConfigOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudfront.GetOriginRequestPolicyConfigOutput)
		}
	}

	return r0, r1
}

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

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

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

	return r0, r1
}

// GetOriginRequestPolicyRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) GetOriginRequestPolicyRequest(_a0 *cloudfront.GetOriginRequestPolicyInput) (*request.Request, *cloudfront.GetOriginRequestPolicyOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudfront.GetOriginRequestPolicyOutput
	if rf, ok := ret.Get(1).(func(*cloudfront.GetOriginRequestPolicyInput) *cloudfront.GetOriginRequestPolicyOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudfront.GetOriginRequestPolicyOutput)
		}
	}

	return r0, r1
}

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

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

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

	return r0, r1
}

// GetPublicKey provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) GetPublicKey(_a0 *cloudfront.GetPublicKeyInput) (*cloudfront.GetPublicKeyOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudfront.GetPublicKeyOutput
	if rf, ok := ret.Get(0).(func(*cloudfront.GetPublicKeyInput) *cloudfront.GetPublicKeyOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudfront.GetPublicKeyOutput)
		}
	}

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

	return r0, r1
}

// GetPublicKeyConfig provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) GetPublicKeyConfig(_a0 *cloudfront.GetPublicKeyConfigInput) (*cloudfront.GetPublicKeyConfigOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudfront.GetPublicKeyConfigOutput
	if rf, ok := ret.Get(0).(func(*cloudfront.GetPublicKeyConfigInput) *cloudfront.GetPublicKeyConfigOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudfront.GetPublicKeyConfigOutput)
		}
	}

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

	return r0, r1
}

// GetPublicKeyConfigRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) GetPublicKeyConfigRequest(_a0 *cloudfront.GetPublicKeyConfigInput) (*request.Request, *cloudfront.GetPublicKeyConfigOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudfront.GetPublicKeyConfigOutput
	if rf, ok := ret.Get(1).(func(*cloudfront.GetPublicKeyConfigInput) *cloudfront.GetPublicKeyConfigOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudfront.GetPublicKeyConfigOutput)
		}
	}

	return r0, r1
}

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

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

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

	return r0, r1
}

// GetPublicKeyRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) GetPublicKeyRequest(_a0 *cloudfront.GetPublicKeyInput) (*request.Request, *cloudfront.GetPublicKeyOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudfront.GetPublicKeyOutput
	if rf, ok := ret.Get(1).(func(*cloudfront.GetPublicKeyInput) *cloudfront.GetPublicKeyOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudfront.GetPublicKeyOutput)
		}
	}

	return r0, r1
}

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

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

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

	return r0, r1
}

// GetStreamingDistribution provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) GetStreamingDistribution(_a0 *cloudfront.GetStreamingDistributionInput) (*cloudfront.GetStreamingDistributionOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudfront.GetStreamingDistributionOutput
	if rf, ok := ret.Get(0).(func(*cloudfront.GetStreamingDistributionInput) *cloudfront.GetStreamingDistributionOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudfront.GetStreamingDistributionOutput)
		}
	}

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

	return r0, r1
}

// GetStreamingDistributionConfig provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) GetStreamingDistributionConfig(_a0 *cloudfront.GetStreamingDistributionConfigInput) (*cloudfront.GetStreamingDistributionConfigOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudfront.GetStreamingDistributionConfigOutput
	if rf, ok := ret.Get(0).(func(*cloudfront.GetStreamingDistributionConfigInput) *cloudfront.GetStreamingDistributionConfigOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudfront.GetStreamingDistributionConfigOutput)
		}
	}

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

	return r0, r1
}

// GetStreamingDistributionConfigRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) GetStreamingDistributionConfigRequest(_a0 *cloudfront.GetStreamingDistributionConfigInput) (*request.Request, *cloudfront.GetStreamingDistributionConfigOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudfront.GetStreamingDistributionConfigOutput
	if rf, ok := ret.Get(1).(func(*cloudfront.GetStreamingDistributionConfigInput) *cloudfront.GetStreamingDistributionConfigOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudfront.GetStreamingDistributionConfigOutput)
		}
	}

	return r0, r1
}

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

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

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

	return r0, r1
}

// GetStreamingDistributionRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) GetStreamingDistributionRequest(_a0 *cloudfront.GetStreamingDistributionInput) (*request.Request, *cloudfront.GetStreamingDistributionOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudfront.GetStreamingDistributionOutput
	if rf, ok := ret.Get(1).(func(*cloudfront.GetStreamingDistributionInput) *cloudfront.GetStreamingDistributionOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudfront.GetStreamingDistributionOutput)
		}
	}

	return r0, r1
}

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

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

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

	return r0, r1
}

// ListCachePolicies provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) ListCachePolicies(_a0 *cloudfront.ListCachePoliciesInput) (*cloudfront.ListCachePoliciesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudfront.ListCachePoliciesOutput
	if rf, ok := ret.Get(0).(func(*cloudfront.ListCachePoliciesInput) *cloudfront.ListCachePoliciesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudfront.ListCachePoliciesOutput)
		}
	}

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

	return r0, r1
}

// ListCachePoliciesRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) ListCachePoliciesRequest(_a0 *cloudfront.ListCachePoliciesInput) (*request.Request, *cloudfront.ListCachePoliciesOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudfront.ListCachePoliciesOutput
	if rf, ok := ret.Get(1).(func(*cloudfront.ListCachePoliciesInput) *cloudfront.ListCachePoliciesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudfront.ListCachePoliciesOutput)
		}
	}

	return r0, r1
}

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

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

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

	return r0, r1
}

// ListCloudFrontOriginAccessIdentities provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) ListCloudFrontOriginAccessIdentities(_a0 *cloudfront.ListCloudFrontOriginAccessIdentitiesInput) (*cloudfront.ListCloudFrontOriginAccessIdentitiesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudfront.ListCloudFrontOriginAccessIdentitiesOutput
	if rf, ok := ret.Get(0).(func(*cloudfront.ListCloudFrontOriginAccessIdentitiesInput) *cloudfront.ListCloudFrontOriginAccessIdentitiesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudfront.ListCloudFrontOriginAccessIdentitiesOutput)
		}
	}

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

	return r0, r1
}

// ListCloudFrontOriginAccessIdentitiesPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeCloudFront) ListCloudFrontOriginAccessIdentitiesPages(_a0 *cloudfront.ListCloudFrontOriginAccessIdentitiesInput, _a1 func(*cloudfront.ListCloudFrontOriginAccessIdentitiesOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

// ListCloudFrontOriginAccessIdentitiesPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeCloudFront) ListCloudFrontOriginAccessIdentitiesPagesWithContext(_a0 context.Context, _a1 *cloudfront.ListCloudFrontOriginAccessIdentitiesInput, _a2 func(*cloudfront.ListCloudFrontOriginAccessIdentitiesOutput, 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, *cloudfront.ListCloudFrontOriginAccessIdentitiesInput, func(*cloudfront.ListCloudFrontOriginAccessIdentitiesOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListCloudFrontOriginAccessIdentitiesRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) ListCloudFrontOriginAccessIdentitiesRequest(_a0 *cloudfront.ListCloudFrontOriginAccessIdentitiesInput) (*request.Request, *cloudfront.ListCloudFrontOriginAccessIdentitiesOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudfront.ListCloudFrontOriginAccessIdentitiesOutput
	if rf, ok := ret.Get(1).(func(*cloudfront.ListCloudFrontOriginAccessIdentitiesInput) *cloudfront.ListCloudFrontOriginAccessIdentitiesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudfront.ListCloudFrontOriginAccessIdentitiesOutput)
		}
	}

	return r0, r1
}

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

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

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

	return r0, r1
}

// ListDistributions provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) ListDistributions(_a0 *cloudfront.ListDistributionsInput) (*cloudfront.ListDistributionsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudfront.ListDistributionsOutput
	if rf, ok := ret.Get(0).(func(*cloudfront.ListDistributionsInput) *cloudfront.ListDistributionsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudfront.ListDistributionsOutput)
		}
	}

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

	return r0, r1
}

// ListDistributionsByCachePolicyId provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) ListDistributionsByCachePolicyId(_a0 *cloudfront.ListDistributionsByCachePolicyIdInput) (*cloudfront.ListDistributionsByCachePolicyIdOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudfront.ListDistributionsByCachePolicyIdOutput
	if rf, ok := ret.Get(0).(func(*cloudfront.ListDistributionsByCachePolicyIdInput) *cloudfront.ListDistributionsByCachePolicyIdOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudfront.ListDistributionsByCachePolicyIdOutput)
		}
	}

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

	return r0, r1
}

// ListDistributionsByCachePolicyIdRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) ListDistributionsByCachePolicyIdRequest(_a0 *cloudfront.ListDistributionsByCachePolicyIdInput) (*request.Request, *cloudfront.ListDistributionsByCachePolicyIdOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudfront.ListDistributionsByCachePolicyIdOutput
	if rf, ok := ret.Get(1).(func(*cloudfront.ListDistributionsByCachePolicyIdInput) *cloudfront.ListDistributionsByCachePolicyIdOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudfront.ListDistributionsByCachePolicyIdOutput)
		}
	}

	return r0, r1
}

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

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

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

	return r0, r1
}

// ListDistributionsByOriginRequestPolicyId provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) ListDistributionsByOriginRequestPolicyId(_a0 *cloudfront.ListDistributionsByOriginRequestPolicyIdInput) (*cloudfront.ListDistributionsByOriginRequestPolicyIdOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudfront.ListDistributionsByOriginRequestPolicyIdOutput
	if rf, ok := ret.Get(0).(func(*cloudfront.ListDistributionsByOriginRequestPolicyIdInput) *cloudfront.ListDistributionsByOriginRequestPolicyIdOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudfront.ListDistributionsByOriginRequestPolicyIdOutput)
		}
	}

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

	return r0, r1
}

// ListDistributionsByOriginRequestPolicyIdRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) ListDistributionsByOriginRequestPolicyIdRequest(_a0 *cloudfront.ListDistributionsByOriginRequestPolicyIdInput) (*request.Request, *cloudfront.ListDistributionsByOriginRequestPolicyIdOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudfront.ListDistributionsByOriginRequestPolicyIdOutput
	if rf, ok := ret.Get(1).(func(*cloudfront.ListDistributionsByOriginRequestPolicyIdInput) *cloudfront.ListDistributionsByOriginRequestPolicyIdOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudfront.ListDistributionsByOriginRequestPolicyIdOutput)
		}
	}

	return r0, r1
}

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

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

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

	return r0, r1
}

// ListDistributionsByWebACLId provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) ListDistributionsByWebACLId(_a0 *cloudfront.ListDistributionsByWebACLIdInput) (*cloudfront.ListDistributionsByWebACLIdOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudfront.ListDistributionsByWebACLIdOutput
	if rf, ok := ret.Get(0).(func(*cloudfront.ListDistributionsByWebACLIdInput) *cloudfront.ListDistributionsByWebACLIdOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudfront.ListDistributionsByWebACLIdOutput)
		}
	}

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

	return r0, r1
}

// ListDistributionsByWebACLIdRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) ListDistributionsByWebACLIdRequest(_a0 *cloudfront.ListDistributionsByWebACLIdInput) (*request.Request, *cloudfront.ListDistributionsByWebACLIdOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudfront.ListDistributionsByWebACLIdOutput
	if rf, ok := ret.Get(1).(func(*cloudfront.ListDistributionsByWebACLIdInput) *cloudfront.ListDistributionsByWebACLIdOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudfront.ListDistributionsByWebACLIdOutput)
		}
	}

	return r0, r1
}

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

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

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

	return r0, r1
}

// ListDistributionsPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeCloudFront) ListDistributionsPages(_a0 *cloudfront.ListDistributionsInput, _a1 func(*cloudfront.ListDistributionsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

// ListDistributionsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeCloudFront) ListDistributionsPagesWithContext(_a0 context.Context, _a1 *cloudfront.ListDistributionsInput, _a2 func(*cloudfront.ListDistributionsOutput, 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, *cloudfront.ListDistributionsInput, func(*cloudfront.ListDistributionsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListDistributionsRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) ListDistributionsRequest(_a0 *cloudfront.ListDistributionsInput) (*request.Request, *cloudfront.ListDistributionsOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudfront.ListDistributionsOutput
	if rf, ok := ret.Get(1).(func(*cloudfront.ListDistributionsInput) *cloudfront.ListDistributionsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudfront.ListDistributionsOutput)
		}
	}

	return r0, r1
}

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

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

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

	return r0, r1
}

// ListFieldLevelEncryptionConfigs provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) ListFieldLevelEncryptionConfigs(_a0 *cloudfront.ListFieldLevelEncryptionConfigsInput) (*cloudfront.ListFieldLevelEncryptionConfigsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudfront.ListFieldLevelEncryptionConfigsOutput
	if rf, ok := ret.Get(0).(func(*cloudfront.ListFieldLevelEncryptionConfigsInput) *cloudfront.ListFieldLevelEncryptionConfigsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudfront.ListFieldLevelEncryptionConfigsOutput)
		}
	}

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

	return r0, r1
}

// ListFieldLevelEncryptionConfigsRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) ListFieldLevelEncryptionConfigsRequest(_a0 *cloudfront.ListFieldLevelEncryptionConfigsInput) (*request.Request, *cloudfront.ListFieldLevelEncryptionConfigsOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudfront.ListFieldLevelEncryptionConfigsOutput
	if rf, ok := ret.Get(1).(func(*cloudfront.ListFieldLevelEncryptionConfigsInput) *cloudfront.ListFieldLevelEncryptionConfigsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudfront.ListFieldLevelEncryptionConfigsOutput)
		}
	}

	return r0, r1
}

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

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

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

	return r0, r1
}

// ListFieldLevelEncryptionProfiles provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) ListFieldLevelEncryptionProfiles(_a0 *cloudfront.ListFieldLevelEncryptionProfilesInput) (*cloudfront.ListFieldLevelEncryptionProfilesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudfront.ListFieldLevelEncryptionProfilesOutput
	if rf, ok := ret.Get(0).(func(*cloudfront.ListFieldLevelEncryptionProfilesInput) *cloudfront.ListFieldLevelEncryptionProfilesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudfront.ListFieldLevelEncryptionProfilesOutput)
		}
	}

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

	return r0, r1
}

// ListFieldLevelEncryptionProfilesRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) ListFieldLevelEncryptionProfilesRequest(_a0 *cloudfront.ListFieldLevelEncryptionProfilesInput) (*request.Request, *cloudfront.ListFieldLevelEncryptionProfilesOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudfront.ListFieldLevelEncryptionProfilesOutput
	if rf, ok := ret.Get(1).(func(*cloudfront.ListFieldLevelEncryptionProfilesInput) *cloudfront.ListFieldLevelEncryptionProfilesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudfront.ListFieldLevelEncryptionProfilesOutput)
		}
	}

	return r0, r1
}

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

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

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

	return r0, r1
}

// ListInvalidations provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) ListInvalidations(_a0 *cloudfront.ListInvalidationsInput) (*cloudfront.ListInvalidationsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudfront.ListInvalidationsOutput
	if rf, ok := ret.Get(0).(func(*cloudfront.ListInvalidationsInput) *cloudfront.ListInvalidationsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudfront.ListInvalidationsOutput)
		}
	}

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

	return r0, r1
}

// ListInvalidationsPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeCloudFront) ListInvalidationsPages(_a0 *cloudfront.ListInvalidationsInput, _a1 func(*cloudfront.ListInvalidationsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

// ListInvalidationsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeCloudFront) ListInvalidationsPagesWithContext(_a0 context.Context, _a1 *cloudfront.ListInvalidationsInput, _a2 func(*cloudfront.ListInvalidationsOutput, 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, *cloudfront.ListInvalidationsInput, func(*cloudfront.ListInvalidationsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListInvalidationsRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) ListInvalidationsRequest(_a0 *cloudfront.ListInvalidationsInput) (*request.Request, *cloudfront.ListInvalidationsOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudfront.ListInvalidationsOutput
	if rf, ok := ret.Get(1).(func(*cloudfront.ListInvalidationsInput) *cloudfront.ListInvalidationsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudfront.ListInvalidationsOutput)
		}
	}

	return r0, r1
}

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

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

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

	return r0, r1
}

// ListOriginRequestPolicies provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) ListOriginRequestPolicies(_a0 *cloudfront.ListOriginRequestPoliciesInput) (*cloudfront.ListOriginRequestPoliciesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudfront.ListOriginRequestPoliciesOutput
	if rf, ok := ret.Get(0).(func(*cloudfront.ListOriginRequestPoliciesInput) *cloudfront.ListOriginRequestPoliciesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudfront.ListOriginRequestPoliciesOutput)
		}
	}

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

	return r0, r1
}

// ListOriginRequestPoliciesRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) ListOriginRequestPoliciesRequest(_a0 *cloudfront.ListOriginRequestPoliciesInput) (*request.Request, *cloudfront.ListOriginRequestPoliciesOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudfront.ListOriginRequestPoliciesOutput
	if rf, ok := ret.Get(1).(func(*cloudfront.ListOriginRequestPoliciesInput) *cloudfront.ListOriginRequestPoliciesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudfront.ListOriginRequestPoliciesOutput)
		}
	}

	return r0, r1
}

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

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

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

	return r0, r1
}

// ListPublicKeys provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) ListPublicKeys(_a0 *cloudfront.ListPublicKeysInput) (*cloudfront.ListPublicKeysOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudfront.ListPublicKeysOutput
	if rf, ok := ret.Get(0).(func(*cloudfront.ListPublicKeysInput) *cloudfront.ListPublicKeysOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudfront.ListPublicKeysOutput)
		}
	}

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

	return r0, r1
}

// ListPublicKeysRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) ListPublicKeysRequest(_a0 *cloudfront.ListPublicKeysInput) (*request.Request, *cloudfront.ListPublicKeysOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudfront.ListPublicKeysOutput
	if rf, ok := ret.Get(1).(func(*cloudfront.ListPublicKeysInput) *cloudfront.ListPublicKeysOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudfront.ListPublicKeysOutput)
		}
	}

	return r0, r1
}

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

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

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

	return r0, r1
}

// ListStreamingDistributions provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) ListStreamingDistributions(_a0 *cloudfront.ListStreamingDistributionsInput) (*cloudfront.ListStreamingDistributionsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudfront.ListStreamingDistributionsOutput
	if rf, ok := ret.Get(0).(func(*cloudfront.ListStreamingDistributionsInput) *cloudfront.ListStreamingDistributionsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudfront.ListStreamingDistributionsOutput)
		}
	}

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

	return r0, r1
}

// ListStreamingDistributionsPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeCloudFront) ListStreamingDistributionsPages(_a0 *cloudfront.ListStreamingDistributionsInput, _a1 func(*cloudfront.ListStreamingDistributionsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

// ListStreamingDistributionsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeCloudFront) ListStreamingDistributionsPagesWithContext(_a0 context.Context, _a1 *cloudfront.ListStreamingDistributionsInput, _a2 func(*cloudfront.ListStreamingDistributionsOutput, 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, *cloudfront.ListStreamingDistributionsInput, func(*cloudfront.ListStreamingDistributionsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListStreamingDistributionsRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) ListStreamingDistributionsRequest(_a0 *cloudfront.ListStreamingDistributionsInput) (*request.Request, *cloudfront.ListStreamingDistributionsOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudfront.ListStreamingDistributionsOutput
	if rf, ok := ret.Get(1).(func(*cloudfront.ListStreamingDistributionsInput) *cloudfront.ListStreamingDistributionsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudfront.ListStreamingDistributionsOutput)
		}
	}

	return r0, r1
}

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

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

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *cloudfront.ListStreamingDistributionsInput, ...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 *MockFakeCloudFront) ListTagsForResource(_a0 *cloudfront.ListTagsForResourceInput) (*cloudfront.ListTagsForResourceOutput, error) {
	ret := _m.Called(_a0)

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

	var r1 error
	if rf, ok := ret.Get(1).(func(*cloudfront.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 *MockFakeCloudFront) ListTagsForResourceRequest(_a0 *cloudfront.ListTagsForResourceInput) (*request.Request, *cloudfront.ListTagsForResourceOutput) {
	ret := _m.Called(_a0)

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

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

	return r0, r1
}

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

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

	return r0, r1
}

// TagResource provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) TagResource(_a0 *cloudfront.TagResourceInput) (*cloudfront.TagResourceOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudfront.TagResourceOutput
	if rf, ok := ret.Get(0).(func(*cloudfront.TagResourceInput) *cloudfront.TagResourceOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudfront.TagResourceOutput)
		}
	}

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

	return r0, r1
}

// TagResourceRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) TagResourceRequest(_a0 *cloudfront.TagResourceInput) (*request.Request, *cloudfront.TagResourceOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudfront.TagResourceOutput
	if rf, ok := ret.Get(1).(func(*cloudfront.TagResourceInput) *cloudfront.TagResourceOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudfront.TagResourceOutput)
		}
	}

	return r0, r1
}

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

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

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

	return r0, r1
}

// UntagResource provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) UntagResource(_a0 *cloudfront.UntagResourceInput) (*cloudfront.UntagResourceOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudfront.UntagResourceOutput
	if rf, ok := ret.Get(0).(func(*cloudfront.UntagResourceInput) *cloudfront.UntagResourceOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudfront.UntagResourceOutput)
		}
	}

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

	return r0, r1
}

// UntagResourceRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) UntagResourceRequest(_a0 *cloudfront.UntagResourceInput) (*request.Request, *cloudfront.UntagResourceOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudfront.UntagResourceOutput
	if rf, ok := ret.Get(1).(func(*cloudfront.UntagResourceInput) *cloudfront.UntagResourceOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudfront.UntagResourceOutput)
		}
	}

	return r0, r1
}

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

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

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

	return r0, r1
}

// UpdateCachePolicy provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) UpdateCachePolicy(_a0 *cloudfront.UpdateCachePolicyInput) (*cloudfront.UpdateCachePolicyOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudfront.UpdateCachePolicyOutput
	if rf, ok := ret.Get(0).(func(*cloudfront.UpdateCachePolicyInput) *cloudfront.UpdateCachePolicyOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudfront.UpdateCachePolicyOutput)
		}
	}

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

	return r0, r1
}

// UpdateCachePolicyRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) UpdateCachePolicyRequest(_a0 *cloudfront.UpdateCachePolicyInput) (*request.Request, *cloudfront.UpdateCachePolicyOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudfront.UpdateCachePolicyOutput
	if rf, ok := ret.Get(1).(func(*cloudfront.UpdateCachePolicyInput) *cloudfront.UpdateCachePolicyOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudfront.UpdateCachePolicyOutput)
		}
	}

	return r0, r1
}

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

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

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

	return r0, r1
}

// UpdateCloudFrontOriginAccessIdentity provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) UpdateCloudFrontOriginAccessIdentity(_a0 *cloudfront.UpdateCloudFrontOriginAccessIdentityInput) (*cloudfront.UpdateCloudFrontOriginAccessIdentityOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudfront.UpdateCloudFrontOriginAccessIdentityOutput
	if rf, ok := ret.Get(0).(func(*cloudfront.UpdateCloudFrontOriginAccessIdentityInput) *cloudfront.UpdateCloudFrontOriginAccessIdentityOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudfront.UpdateCloudFrontOriginAccessIdentityOutput)
		}
	}

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

	return r0, r1
}

// UpdateCloudFrontOriginAccessIdentityRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) UpdateCloudFrontOriginAccessIdentityRequest(_a0 *cloudfront.UpdateCloudFrontOriginAccessIdentityInput) (*request.Request, *cloudfront.UpdateCloudFrontOriginAccessIdentityOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudfront.UpdateCloudFrontOriginAccessIdentityOutput
	if rf, ok := ret.Get(1).(func(*cloudfront.UpdateCloudFrontOriginAccessIdentityInput) *cloudfront.UpdateCloudFrontOriginAccessIdentityOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudfront.UpdateCloudFrontOriginAccessIdentityOutput)
		}
	}

	return r0, r1
}

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

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

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

	return r0, r1
}

// UpdateDistribution provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) UpdateDistribution(_a0 *cloudfront.UpdateDistributionInput) (*cloudfront.UpdateDistributionOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudfront.UpdateDistributionOutput
	if rf, ok := ret.Get(0).(func(*cloudfront.UpdateDistributionInput) *cloudfront.UpdateDistributionOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudfront.UpdateDistributionOutput)
		}
	}

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

	return r0, r1
}

// UpdateDistributionRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) UpdateDistributionRequest(_a0 *cloudfront.UpdateDistributionInput) (*request.Request, *cloudfront.UpdateDistributionOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudfront.UpdateDistributionOutput
	if rf, ok := ret.Get(1).(func(*cloudfront.UpdateDistributionInput) *cloudfront.UpdateDistributionOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudfront.UpdateDistributionOutput)
		}
	}

	return r0, r1
}

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

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

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

	return r0, r1
}

// UpdateFieldLevelEncryptionConfig provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) UpdateFieldLevelEncryptionConfig(_a0 *cloudfront.UpdateFieldLevelEncryptionConfigInput) (*cloudfront.UpdateFieldLevelEncryptionConfigOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudfront.UpdateFieldLevelEncryptionConfigOutput
	if rf, ok := ret.Get(0).(func(*cloudfront.UpdateFieldLevelEncryptionConfigInput) *cloudfront.UpdateFieldLevelEncryptionConfigOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudfront.UpdateFieldLevelEncryptionConfigOutput)
		}
	}

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

	return r0, r1
}

// UpdateFieldLevelEncryptionConfigRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) UpdateFieldLevelEncryptionConfigRequest(_a0 *cloudfront.UpdateFieldLevelEncryptionConfigInput) (*request.Request, *cloudfront.UpdateFieldLevelEncryptionConfigOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudfront.UpdateFieldLevelEncryptionConfigOutput
	if rf, ok := ret.Get(1).(func(*cloudfront.UpdateFieldLevelEncryptionConfigInput) *cloudfront.UpdateFieldLevelEncryptionConfigOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudfront.UpdateFieldLevelEncryptionConfigOutput)
		}
	}

	return r0, r1
}

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

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

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

	return r0, r1
}

// UpdateFieldLevelEncryptionProfile provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) UpdateFieldLevelEncryptionProfile(_a0 *cloudfront.UpdateFieldLevelEncryptionProfileInput) (*cloudfront.UpdateFieldLevelEncryptionProfileOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudfront.UpdateFieldLevelEncryptionProfileOutput
	if rf, ok := ret.Get(0).(func(*cloudfront.UpdateFieldLevelEncryptionProfileInput) *cloudfront.UpdateFieldLevelEncryptionProfileOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudfront.UpdateFieldLevelEncryptionProfileOutput)
		}
	}

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

	return r0, r1
}

// UpdateFieldLevelEncryptionProfileRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) UpdateFieldLevelEncryptionProfileRequest(_a0 *cloudfront.UpdateFieldLevelEncryptionProfileInput) (*request.Request, *cloudfront.UpdateFieldLevelEncryptionProfileOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudfront.UpdateFieldLevelEncryptionProfileOutput
	if rf, ok := ret.Get(1).(func(*cloudfront.UpdateFieldLevelEncryptionProfileInput) *cloudfront.UpdateFieldLevelEncryptionProfileOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudfront.UpdateFieldLevelEncryptionProfileOutput)
		}
	}

	return r0, r1
}

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

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

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

	return r0, r1
}

// UpdateOriginRequestPolicy provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) UpdateOriginRequestPolicy(_a0 *cloudfront.UpdateOriginRequestPolicyInput) (*cloudfront.UpdateOriginRequestPolicyOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudfront.UpdateOriginRequestPolicyOutput
	if rf, ok := ret.Get(0).(func(*cloudfront.UpdateOriginRequestPolicyInput) *cloudfront.UpdateOriginRequestPolicyOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudfront.UpdateOriginRequestPolicyOutput)
		}
	}

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

	return r0, r1
}

// UpdateOriginRequestPolicyRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) UpdateOriginRequestPolicyRequest(_a0 *cloudfront.UpdateOriginRequestPolicyInput) (*request.Request, *cloudfront.UpdateOriginRequestPolicyOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudfront.UpdateOriginRequestPolicyOutput
	if rf, ok := ret.Get(1).(func(*cloudfront.UpdateOriginRequestPolicyInput) *cloudfront.UpdateOriginRequestPolicyOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudfront.UpdateOriginRequestPolicyOutput)
		}
	}

	return r0, r1
}

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

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

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

	return r0, r1
}

// UpdatePublicKey provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) UpdatePublicKey(_a0 *cloudfront.UpdatePublicKeyInput) (*cloudfront.UpdatePublicKeyOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudfront.UpdatePublicKeyOutput
	if rf, ok := ret.Get(0).(func(*cloudfront.UpdatePublicKeyInput) *cloudfront.UpdatePublicKeyOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudfront.UpdatePublicKeyOutput)
		}
	}

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

	return r0, r1
}

// UpdatePublicKeyRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) UpdatePublicKeyRequest(_a0 *cloudfront.UpdatePublicKeyInput) (*request.Request, *cloudfront.UpdatePublicKeyOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudfront.UpdatePublicKeyOutput
	if rf, ok := ret.Get(1).(func(*cloudfront.UpdatePublicKeyInput) *cloudfront.UpdatePublicKeyOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudfront.UpdatePublicKeyOutput)
		}
	}

	return r0, r1
}

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

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

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

	return r0, r1
}

// UpdateStreamingDistribution provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) UpdateStreamingDistribution(_a0 *cloudfront.UpdateStreamingDistributionInput) (*cloudfront.UpdateStreamingDistributionOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudfront.UpdateStreamingDistributionOutput
	if rf, ok := ret.Get(0).(func(*cloudfront.UpdateStreamingDistributionInput) *cloudfront.UpdateStreamingDistributionOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudfront.UpdateStreamingDistributionOutput)
		}
	}

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

	return r0, r1
}

// UpdateStreamingDistributionRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) UpdateStreamingDistributionRequest(_a0 *cloudfront.UpdateStreamingDistributionInput) (*request.Request, *cloudfront.UpdateStreamingDistributionOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudfront.UpdateStreamingDistributionOutput
	if rf, ok := ret.Get(1).(func(*cloudfront.UpdateStreamingDistributionInput) *cloudfront.UpdateStreamingDistributionOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudfront.UpdateStreamingDistributionOutput)
		}
	}

	return r0, r1
}

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

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

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

	return r0, r1
}

// WaitUntilDistributionDeployed provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) WaitUntilDistributionDeployed(_a0 *cloudfront.GetDistributionInput) error {
	ret := _m.Called(_a0)

	var r0 error
	if rf, ok := ret.Get(0).(func(*cloudfront.GetDistributionInput) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilDistributionDeployedWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeCloudFront) WaitUntilDistributionDeployedWithContext(_a0 context.Context, _a1 *cloudfront.GetDistributionInput, _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, *cloudfront.GetDistributionInput, ...request.WaiterOption) error); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilInvalidationCompleted provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) WaitUntilInvalidationCompleted(_a0 *cloudfront.GetInvalidationInput) error {
	ret := _m.Called(_a0)

	var r0 error
	if rf, ok := ret.Get(0).(func(*cloudfront.GetInvalidationInput) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilInvalidationCompletedWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeCloudFront) WaitUntilInvalidationCompletedWithContext(_a0 context.Context, _a1 *cloudfront.GetInvalidationInput, _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, *cloudfront.GetInvalidationInput, ...request.WaiterOption) error); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilStreamingDistributionDeployed provides a mock function with given fields: _a0
func (_m *MockFakeCloudFront) WaitUntilStreamingDistributionDeployed(_a0 *cloudfront.GetStreamingDistributionInput) error {
	ret := _m.Called(_a0)

	var r0 error
	if rf, ok := ret.Get(0).(func(*cloudfront.GetStreamingDistributionInput) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilStreamingDistributionDeployedWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeCloudFront) WaitUntilStreamingDistributionDeployedWithContext(_a0 context.Context, _a1 *cloudfront.GetStreamingDistributionInput, _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, *cloudfront.GetStreamingDistributionInput, ...request.WaiterOption) error); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}