sdk.go

// Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License"). You may
// not use this file except in compliance with the License. A copy of the
// License is located at
//
//     http://aws.amazon.com/apache2.0/
//
// or in the "license" file accompanying this file. This file is distributed
// on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
// express or implied. See the License for the specific language governing
// permissions and limitations under the License.

// Code generated by ack-generate. DO NOT EDIT.

package bucket

import (
	"context"
	"errors"
	"fmt"
	"reflect"
	"strings"

	ackv1alpha1 "github.com/aws-controllers-k8s/runtime/apis/core/v1alpha1"
	ackcompare "github.com/aws-controllers-k8s/runtime/pkg/compare"
	ackcondition "github.com/aws-controllers-k8s/runtime/pkg/condition"
	ackerr "github.com/aws-controllers-k8s/runtime/pkg/errors"
	ackrequeue "github.com/aws-controllers-k8s/runtime/pkg/requeue"
	ackrtlog "github.com/aws-controllers-k8s/runtime/pkg/runtime/log"
	"github.com/aws/aws-sdk-go/aws"
	svcsdk "github.com/aws/aws-sdk-go/service/s3"
	corev1 "k8s.io/api/core/v1"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"

	svcapitypes "github.com/aws-controllers-k8s/s3-controller/apis/v1alpha1"
)

// Hack to avoid import errors during build...
var (
	_ = &metav1.Time{}
	_ = strings.ToLower("")
	_ = &aws.JSONValue{}
	_ = &svcsdk.S3{}
	_ = &svcapitypes.Bucket{}
	_ = ackv1alpha1.AWSAccountID("")
	_ = &ackerr.NotFound
	_ = &ackcondition.NotManagedMessage
	_ = &reflect.Value{}
	_ = fmt.Sprintf("")
	_ = &ackrequeue.NoRequeue{}
)

// sdkFind returns SDK-specific information about a supplied resource
func (rm *resourceManager) sdkFind(
	ctx context.Context,
	r *resource,
) (latest *resource, err error) {
	rlog := ackrtlog.FromContext(ctx)
	exit := rlog.Trace("rm.sdkFind")
	defer func() {
		exit(err)
	}()
	// If any required fields in the input shape are missing, AWS resource is
	// not created yet. Return NotFound here to indicate to callers that the
	// resource isn't yet created.
	if rm.requiredFieldsMissingFromReadManyInput(r) {
		return nil, ackerr.NotFound
	}

	input, err := rm.newListRequestPayload(r)
	if err != nil {
		return nil, err
	}
	var resp *svcsdk.ListBucketsOutput
	resp, err = rm.sdkapi.ListBucketsWithContext(ctx, input)
	rm.metrics.RecordAPICall("READ_MANY", "ListBuckets", err)
	if err != nil {
		if awsErr, ok := ackerr.AWSError(err); ok && awsErr.Code() == "NoSuchBucket" {
			return nil, ackerr.NotFound
		}
		return nil, err
	}

	// Merge in the information we read from the API call above to the copy of
	// the original Kubernetes object we passed to the function
	ko := r.ko.DeepCopy()

	found := false
	for _, elem := range resp.Buckets {
		if elem.Name != nil {
			if ko.Spec.Name != nil {
				if *elem.Name != *ko.Spec.Name {
					continue
				}
			}
			ko.Spec.Name = elem.Name
		} else {
			ko.Spec.Name = nil
		}
		found = true
		break
	}
	if !found {
		return nil, ackerr.NotFound
	}

	rm.setStatusDefaults(ko)
	if err := rm.addPutFieldsToSpec(ctx, r, ko); err != nil {
		return nil, err
	}
	return &resource{ko}, nil
}

// requiredFieldsMissingFromReadManyInput returns true if there are any fields
// for the ReadMany Input shape that are required but not present in the
// resource's Spec or Status
func (rm *resourceManager) requiredFieldsMissingFromReadManyInput(
	r *resource,
) bool {
	return false
}

// newListRequestPayload returns SDK-specific struct for the HTTP request
// payload of the List API call for the resource
func (rm *resourceManager) newListRequestPayload(
	r *resource,
) (*svcsdk.ListBucketsInput, error) {
	res := &svcsdk.ListBucketsInput{}

	return res, nil
}

// sdkCreate creates the supplied resource in the backend AWS service API and
// returns a copy of the resource with resource fields (in both Spec and
// Status) filled in with values from the CREATE API operation's Output shape.
func (rm *resourceManager) sdkCreate(
	ctx context.Context,
	desired *resource,
) (created *resource, err error) {
	rlog := ackrtlog.FromContext(ctx)
	exit := rlog.Trace("rm.sdkCreate")
	defer func() {
		exit(err)
	}()
	input, err := rm.newCreateRequestPayload(ctx, desired)
	if err != nil {
		return nil, err
	}

	var resp *svcsdk.CreateBucketOutput
	_ = resp
	resp, err = rm.sdkapi.CreateBucketWithContext(ctx, input)
	rm.metrics.RecordAPICall("CREATE", "CreateBucket", err)
	if err != nil {
		return nil, err
	}
	// Merge in the information we read from the API call above to the copy of
	// the original Kubernetes object we passed to the function
	ko := desired.ko.DeepCopy()

	if resp.Location != nil {
		ko.Status.Location = resp.Location
	} else {
		ko.Status.Location = nil
	}

	rm.setStatusDefaults(ko)
	if err := rm.createPutFields(ctx, desired); err != nil {
		return nil, err
	}
	return &resource{ko}, nil
}

// newCreateRequestPayload returns an SDK-specific struct for the HTTP request
// payload of the Create API call for the resource
func (rm *resourceManager) newCreateRequestPayload(
	ctx context.Context,
	r *resource,
) (*svcsdk.CreateBucketInput, error) {
	res := &svcsdk.CreateBucketInput{}

	if r.ko.Spec.ACL != nil {
		res.SetACL(*r.ko.Spec.ACL)
	}
	if r.ko.Spec.Name != nil {
		res.SetBucket(*r.ko.Spec.Name)
	}
	if r.ko.Spec.CreateBucketConfiguration != nil {
		f2 := &svcsdk.CreateBucketConfiguration{}
		if r.ko.Spec.CreateBucketConfiguration.LocationConstraint != nil {
			f2.SetLocationConstraint(*r.ko.Spec.CreateBucketConfiguration.LocationConstraint)
		}
		res.SetCreateBucketConfiguration(f2)
	}
	if r.ko.Spec.GrantFullControl != nil {
		res.SetGrantFullControl(*r.ko.Spec.GrantFullControl)
	}
	if r.ko.Spec.GrantRead != nil {
		res.SetGrantRead(*r.ko.Spec.GrantRead)
	}
	if r.ko.Spec.GrantReadACP != nil {
		res.SetGrantReadACP(*r.ko.Spec.GrantReadACP)
	}
	if r.ko.Spec.GrantWrite != nil {
		res.SetGrantWrite(*r.ko.Spec.GrantWrite)
	}
	if r.ko.Spec.GrantWriteACP != nil {
		res.SetGrantWriteACP(*r.ko.Spec.GrantWriteACP)
	}
	if r.ko.Spec.ObjectLockEnabledForBucket != nil {
		res.SetObjectLockEnabledForBucket(*r.ko.Spec.ObjectLockEnabledForBucket)
	}
	if r.ko.Spec.ObjectOwnership != nil {
		res.SetObjectOwnership(*r.ko.Spec.ObjectOwnership)
	}

	return res, nil
}

// sdkUpdate patches the supplied resource in the backend AWS service API and
// returns a new resource with updated fields.
func (rm *resourceManager) sdkUpdate(
	ctx context.Context,
	desired *resource,
	latest *resource,
	delta *ackcompare.Delta,
) (*resource, error) {
	return rm.customUpdateBucket(ctx, desired, latest, delta)
}

// sdkDelete deletes the supplied resource in the backend AWS service API
func (rm *resourceManager) sdkDelete(
	ctx context.Context,
	r *resource,
) (latest *resource, err error) {
	rlog := ackrtlog.FromContext(ctx)
	exit := rlog.Trace("rm.sdkDelete")
	defer func() {
		exit(err)
	}()
	input, err := rm.newDeleteRequestPayload(r)
	if err != nil {
		return nil, err
	}
	var resp *svcsdk.DeleteBucketOutput
	_ = resp
	resp, err = rm.sdkapi.DeleteBucketWithContext(ctx, input)
	rm.metrics.RecordAPICall("DELETE", "DeleteBucket", err)
	return nil, err
}

// newDeleteRequestPayload returns an SDK-specific struct for the HTTP request
// payload of the Delete API call for the resource
func (rm *resourceManager) newDeleteRequestPayload(
	r *resource,
) (*svcsdk.DeleteBucketInput, error) {
	res := &svcsdk.DeleteBucketInput{}

	if r.ko.Spec.Name != nil {
		res.SetBucket(*r.ko.Spec.Name)
	}

	return res, nil
}

// setStatusDefaults sets default properties into supplied custom resource
func (rm *resourceManager) setStatusDefaults(
	ko *svcapitypes.Bucket,
) {
	if ko.Status.ACKResourceMetadata == nil {
		ko.Status.ACKResourceMetadata = &ackv1alpha1.ResourceMetadata{}
	}
	if ko.Status.ACKResourceMetadata.Region == nil {
		ko.Status.ACKResourceMetadata.Region = &rm.awsRegion
	}
	if ko.Status.ACKResourceMetadata.OwnerAccountID == nil {
		ko.Status.ACKResourceMetadata.OwnerAccountID = &rm.awsAccountID
	}
	if ko.Status.Conditions == nil {
		ko.Status.Conditions = []*ackv1alpha1.Condition{}
	}
}

// updateConditions returns updated resource, true; if conditions were updated
// else it returns nil, false
func (rm *resourceManager) updateConditions(
	r *resource,
	onSuccess bool,
	err error,
) (*resource, bool) {
	ko := r.ko.DeepCopy()
	rm.setStatusDefaults(ko)

	// Terminal condition
	var terminalCondition *ackv1alpha1.Condition = nil
	var recoverableCondition *ackv1alpha1.Condition = nil
	var syncCondition *ackv1alpha1.Condition = nil
	for _, condition := range ko.Status.Conditions {
		if condition.Type == ackv1alpha1.ConditionTypeTerminal {
			terminalCondition = condition
		}
		if condition.Type == ackv1alpha1.ConditionTypeRecoverable {
			recoverableCondition = condition
		}
		if condition.Type == ackv1alpha1.ConditionTypeResourceSynced {
			syncCondition = condition
		}
	}
	var termError *ackerr.TerminalError
	if rm.terminalAWSError(err) || err == ackerr.SecretTypeNotSupported || err == ackerr.SecretNotFound || errors.As(err, &termError) {
		if terminalCondition == nil {
			terminalCondition = &ackv1alpha1.Condition{
				Type: ackv1alpha1.ConditionTypeTerminal,
			}
			ko.Status.Conditions = append(ko.Status.Conditions, terminalCondition)
		}
		var errorMessage = ""
		if err == ackerr.SecretTypeNotSupported || err == ackerr.SecretNotFound || errors.As(err, &termError) {
			errorMessage = err.Error()
		} else {
			awsErr, _ := ackerr.AWSError(err)
			errorMessage = awsErr.Error()
		}
		terminalCondition.Status = corev1.ConditionTrue
		terminalCondition.Message = &errorMessage
	} else {
		// Clear the terminal condition if no longer present
		if terminalCondition != nil {
			terminalCondition.Status = corev1.ConditionFalse
			terminalCondition.Message = nil
		}
		// Handling Recoverable Conditions
		if err != nil {
			if recoverableCondition == nil {
				// Add a new Condition containing a non-terminal error
				recoverableCondition = &ackv1alpha1.Condition{
					Type: ackv1alpha1.ConditionTypeRecoverable,
				}
				ko.Status.Conditions = append(ko.Status.Conditions, recoverableCondition)
			}
			recoverableCondition.Status = corev1.ConditionTrue
			awsErr, _ := ackerr.AWSError(err)
			errorMessage := err.Error()
			if awsErr != nil {
				errorMessage = awsErr.Error()
			}
			recoverableCondition.Message = &errorMessage
		} else if recoverableCondition != nil {
			recoverableCondition.Status = corev1.ConditionFalse
			recoverableCondition.Message = nil
		}
	}
	// Required to avoid the "declared but not used" error in the default case
	_ = syncCondition
	if terminalCondition != nil || recoverableCondition != nil || syncCondition != nil {
		return &resource{ko}, true // updated
	}
	return nil, false // not updated
}

// terminalAWSError returns awserr, true; if the supplied error is an aws Error type
// and if the exception indicates that it is a Terminal exception
// 'Terminal' exception are specified in generator configuration
func (rm *resourceManager) terminalAWSError(err error) bool {
	// No terminal_errors specified for this resource in generator config
	return false
}

// newAccelerateConfiguration returns a AccelerateConfiguration object
// with each the field set by the resource's corresponding spec field.
func (rm *resourceManager) newAccelerateConfiguration(
	r *resource,
) *svcsdk.AccelerateConfiguration {
	res := &svcsdk.AccelerateConfiguration{}

	if r.ko.Spec.Accelerate.Status != nil {
		res.SetStatus(*r.ko.Spec.Accelerate.Status)
	}

	return res
}

// setResourceAccelerate sets the `Accelerate` spec field
// given the output of a `GetBucketAccelerateConfiguration` operation.
func (rm *resourceManager) setResourceAccelerate(
	r *resource,
	resp *svcsdk.GetBucketAccelerateConfigurationOutput,
) *svcapitypes.AccelerateConfiguration {
	res := &svcapitypes.AccelerateConfiguration{}

	if resp.Status != nil {
		res.Status = resp.Status
	}

	return res
}

// newAnalyticsConfiguration returns a AnalyticsConfiguration object
// with each the field set by the corresponding configuration's fields.
func (rm *resourceManager) newAnalyticsConfiguration(
	c *svcapitypes.AnalyticsConfiguration,
) *svcsdk.AnalyticsConfiguration {
	res := &svcsdk.AnalyticsConfiguration{}

	if c.Filter != nil {
		resf0 := &svcsdk.AnalyticsFilter{}
		if c.Filter.And != nil {
			resf0f0 := &svcsdk.AnalyticsAndOperator{}
			if c.Filter.And.Prefix != nil {
				resf0f0.SetPrefix(*c.Filter.And.Prefix)
			}
			if c.Filter.And.Tags != nil {
				resf0f0f1 := []*svcsdk.Tag{}
				for _, resf0f0f1iter := range c.Filter.And.Tags {
					resf0f0f1elem := &svcsdk.Tag{}
					if resf0f0f1iter.Key != nil {
						resf0f0f1elem.SetKey(*resf0f0f1iter.Key)
					}
					if resf0f0f1iter.Value != nil {
						resf0f0f1elem.SetValue(*resf0f0f1iter.Value)
					}
					resf0f0f1 = append(resf0f0f1, resf0f0f1elem)
				}
				resf0f0.SetTags(resf0f0f1)
			}
			resf0.SetAnd(resf0f0)
		}
		if c.Filter.Prefix != nil {
			resf0.SetPrefix(*c.Filter.Prefix)
		}
		if c.Filter.Tag != nil {
			resf0f2 := &svcsdk.Tag{}
			if c.Filter.Tag.Key != nil {
				resf0f2.SetKey(*c.Filter.Tag.Key)
			}
			if c.Filter.Tag.Value != nil {
				resf0f2.SetValue(*c.Filter.Tag.Value)
			}
			resf0.SetTag(resf0f2)
		}
		res.SetFilter(resf0)
	}
	if c.ID != nil {
		res.SetId(*c.ID)
	}
	if c.StorageClassAnalysis != nil {
		resf2 := &svcsdk.StorageClassAnalysis{}
		if c.StorageClassAnalysis.DataExport != nil {
			resf2f0 := &svcsdk.StorageClassAnalysisDataExport{}
			if c.StorageClassAnalysis.DataExport.Destination != nil {
				resf2f0f0 := &svcsdk.AnalyticsExportDestination{}
				if c.StorageClassAnalysis.DataExport.Destination.S3BucketDestination != nil {
					resf2f0f0f0 := &svcsdk.AnalyticsS3BucketDestination{}
					if c.StorageClassAnalysis.DataExport.Destination.S3BucketDestination.Bucket != nil {
						resf2f0f0f0.SetBucket(*c.StorageClassAnalysis.DataExport.Destination.S3BucketDestination.Bucket)
					}
					if c.StorageClassAnalysis.DataExport.Destination.S3BucketDestination.BucketAccountID != nil {
						resf2f0f0f0.SetBucketAccountId(*c.StorageClassAnalysis.DataExport.Destination.S3BucketDestination.BucketAccountID)
					}
					if c.StorageClassAnalysis.DataExport.Destination.S3BucketDestination.Format != nil {
						resf2f0f0f0.SetFormat(*c.StorageClassAnalysis.DataExport.Destination.S3BucketDestination.Format)
					}
					if c.StorageClassAnalysis.DataExport.Destination.S3BucketDestination.Prefix != nil {
						resf2f0f0f0.SetPrefix(*c.StorageClassAnalysis.DataExport.Destination.S3BucketDestination.Prefix)
					}
					resf2f0f0.SetS3BucketDestination(resf2f0f0f0)
				}
				resf2f0.SetDestination(resf2f0f0)
			}
			if c.StorageClassAnalysis.DataExport.OutputSchemaVersion != nil {
				resf2f0.SetOutputSchemaVersion(*c.StorageClassAnalysis.DataExport.OutputSchemaVersion)
			}
			resf2.SetDataExport(resf2f0)
		}
		res.SetStorageClassAnalysis(resf2)
	}

	return res
}

// setAnalyticsConfiguration sets a resource AnalyticsConfiguration type
// given the SDK type.
func (rm *resourceManager) setResourceAnalyticsConfiguration(
	r *resource,
	resp *svcsdk.AnalyticsConfiguration,
) *svcapitypes.AnalyticsConfiguration {
	res := &svcapitypes.AnalyticsConfiguration{}

	if resp.Filter != nil {
		resf0 := &svcapitypes.AnalyticsFilter{}
		if resp.Filter.And != nil {
			resf0f0 := &svcapitypes.AnalyticsAndOperator{}
			if resp.Filter.And.Prefix != nil {
				resf0f0.Prefix = resp.Filter.And.Prefix
			}
			if resp.Filter.And.Tags != nil {
				resf0f0f1 := []*svcapitypes.Tag{}
				for _, resf0f0f1iter := range resp.Filter.And.Tags {
					resf0f0f1elem := &svcapitypes.Tag{}
					if resf0f0f1iter.Key != nil {
						resf0f0f1elem.Key = resf0f0f1iter.Key
					}
					if resf0f0f1iter.Value != nil {
						resf0f0f1elem.Value = resf0f0f1iter.Value
					}
					resf0f0f1 = append(resf0f0f1, resf0f0f1elem)
				}
				resf0f0.Tags = resf0f0f1
			}
			resf0.And = resf0f0
		}
		if resp.Filter.Prefix != nil {
			resf0.Prefix = resp.Filter.Prefix
		}
		if resp.Filter.Tag != nil {
			resf0f2 := &svcapitypes.Tag{}
			if resp.Filter.Tag.Key != nil {
				resf0f2.Key = resp.Filter.Tag.Key
			}
			if resp.Filter.Tag.Value != nil {
				resf0f2.Value = resp.Filter.Tag.Value
			}
			resf0.Tag = resf0f2
		}
		res.Filter = resf0
	}
	if resp.Id != nil {
		res.ID = resp.Id
	}
	if resp.StorageClassAnalysis != nil {
		resf2 := &svcapitypes.StorageClassAnalysis{}
		if resp.StorageClassAnalysis.DataExport != nil {
			resf2f0 := &svcapitypes.StorageClassAnalysisDataExport{}
			if resp.StorageClassAnalysis.DataExport.Destination != nil {
				resf2f0f0 := &svcapitypes.AnalyticsExportDestination{}
				if resp.StorageClassAnalysis.DataExport.Destination.S3BucketDestination != nil {
					resf2f0f0f0 := &svcapitypes.AnalyticsS3BucketDestination{}
					if resp.StorageClassAnalysis.DataExport.Destination.S3BucketDestination.Bucket != nil {
						resf2f0f0f0.Bucket = resp.StorageClassAnalysis.DataExport.Destination.S3BucketDestination.Bucket
					}
					if resp.StorageClassAnalysis.DataExport.Destination.S3BucketDestination.BucketAccountId != nil {
						resf2f0f0f0.BucketAccountID = resp.StorageClassAnalysis.DataExport.Destination.S3BucketDestination.BucketAccountId
					}
					if resp.StorageClassAnalysis.DataExport.Destination.S3BucketDestination.Format != nil {
						resf2f0f0f0.Format = resp.StorageClassAnalysis.DataExport.Destination.S3BucketDestination.Format
					}
					if resp.StorageClassAnalysis.DataExport.Destination.S3BucketDestination.Prefix != nil {
						resf2f0f0f0.Prefix = resp.StorageClassAnalysis.DataExport.Destination.S3BucketDestination.Prefix
					}
					resf2f0f0.S3BucketDestination = resf2f0f0f0
				}
				resf2f0.Destination = resf2f0f0
			}
			if resp.StorageClassAnalysis.DataExport.OutputSchemaVersion != nil {
				resf2f0.OutputSchemaVersion = resp.StorageClassAnalysis.DataExport.OutputSchemaVersion
			}
			resf2.DataExport = resf2f0
		}
		res.StorageClassAnalysis = resf2
	}

	return res
}

func compareAnalyticsConfiguration(
	a *svcapitypes.AnalyticsConfiguration,
	b *svcapitypes.AnalyticsConfiguration,
) *ackcompare.Delta {
	delta := ackcompare.NewDelta()
	if ackcompare.HasNilDifference(a.Filter, b.Filter) {
		delta.Add("AnalyticsConfiguration.Filter", a.Filter, b.Filter)
	} else if a.Filter != nil && b.Filter != nil {
		if ackcompare.HasNilDifference(a.Filter.And, b.Filter.And) {
			delta.Add("AnalyticsConfiguration.Filter.And", a.Filter.And, b.Filter.And)
		} else if a.Filter.And != nil && b.Filter.And != nil {
			if ackcompare.HasNilDifference(a.Filter.And.Prefix, b.Filter.And.Prefix) {
				delta.Add("AnalyticsConfiguration.Filter.And.Prefix", a.Filter.And.Prefix, b.Filter.And.Prefix)
			} else if a.Filter.And.Prefix != nil && b.Filter.And.Prefix != nil {
				if *a.Filter.And.Prefix != *b.Filter.And.Prefix {
					delta.Add("AnalyticsConfiguration.Filter.And.Prefix", a.Filter.And.Prefix, b.Filter.And.Prefix)
				}
			}
			if len(a.Filter.And.Tags) != len(b.Filter.And.Tags) {
				delta.Add("AnalyticsConfiguration.Filter.And.Tags", a.Filter.And.Tags, b.Filter.And.Tags)
			} else if len(a.Filter.And.Tags) > 0 {
				if !reflect.DeepEqual(a.Filter.And.Tags, b.Filter.And.Tags) {
					delta.Add("AnalyticsConfiguration.Filter.And.Tags", a.Filter.And.Tags, b.Filter.And.Tags)
				}
			}
		}
		if ackcompare.HasNilDifference(a.Filter.Prefix, b.Filter.Prefix) {
			delta.Add("AnalyticsConfiguration.Filter.Prefix", a.Filter.Prefix, b.Filter.Prefix)
		} else if a.Filter.Prefix != nil && b.Filter.Prefix != nil {
			if *a.Filter.Prefix != *b.Filter.Prefix {
				delta.Add("AnalyticsConfiguration.Filter.Prefix", a.Filter.Prefix, b.Filter.Prefix)
			}
		}
		if ackcompare.HasNilDifference(a.Filter.Tag, b.Filter.Tag) {
			delta.Add("AnalyticsConfiguration.Filter.Tag", a.Filter.Tag, b.Filter.Tag)
		} else if a.Filter.Tag != nil && b.Filter.Tag != nil {
			if ackcompare.HasNilDifference(a.Filter.Tag.Key, b.Filter.Tag.Key) {
				delta.Add("AnalyticsConfiguration.Filter.Tag.Key", a.Filter.Tag.Key, b.Filter.Tag.Key)
			} else if a.Filter.Tag.Key != nil && b.Filter.Tag.Key != nil {
				if *a.Filter.Tag.Key != *b.Filter.Tag.Key {
					delta.Add("AnalyticsConfiguration.Filter.Tag.Key", a.Filter.Tag.Key, b.Filter.Tag.Key)
				}
			}
			if ackcompare.HasNilDifference(a.Filter.Tag.Value, b.Filter.Tag.Value) {
				delta.Add("AnalyticsConfiguration.Filter.Tag.Value", a.Filter.Tag.Value, b.Filter.Tag.Value)
			} else if a.Filter.Tag.Value != nil && b.Filter.Tag.Value != nil {
				if *a.Filter.Tag.Value != *b.Filter.Tag.Value {
					delta.Add("AnalyticsConfiguration.Filter.Tag.Value", a.Filter.Tag.Value, b.Filter.Tag.Value)
				}
			}
		}
	}
	if ackcompare.HasNilDifference(a.ID, b.ID) {
		delta.Add("AnalyticsConfiguration.ID", a.ID, b.ID)
	} else if a.ID != nil && b.ID != nil {
		if *a.ID != *b.ID {
			delta.Add("AnalyticsConfiguration.ID", a.ID, b.ID)
		}
	}
	if ackcompare.HasNilDifference(a.StorageClassAnalysis, b.StorageClassAnalysis) {
		delta.Add("AnalyticsConfiguration.StorageClassAnalysis", a.StorageClassAnalysis, b.StorageClassAnalysis)
	} else if a.StorageClassAnalysis != nil && b.StorageClassAnalysis != nil {
		if ackcompare.HasNilDifference(a.StorageClassAnalysis.DataExport, b.StorageClassAnalysis.DataExport) {
			delta.Add("AnalyticsConfiguration.StorageClassAnalysis.DataExport", a.StorageClassAnalysis.DataExport, b.StorageClassAnalysis.DataExport)
		} else if a.StorageClassAnalysis.DataExport != nil && b.StorageClassAnalysis.DataExport != nil {
			if ackcompare.HasNilDifference(a.StorageClassAnalysis.DataExport.Destination, b.StorageClassAnalysis.DataExport.Destination) {
				delta.Add("AnalyticsConfiguration.StorageClassAnalysis.DataExport.Destination", a.StorageClassAnalysis.DataExport.Destination, b.StorageClassAnalysis.DataExport.Destination)
			} else if a.StorageClassAnalysis.DataExport.Destination != nil && b.StorageClassAnalysis.DataExport.Destination != nil {
				if ackcompare.HasNilDifference(a.StorageClassAnalysis.DataExport.Destination.S3BucketDestination, b.StorageClassAnalysis.DataExport.Destination.S3BucketDestination) {
					delta.Add("AnalyticsConfiguration.StorageClassAnalysis.DataExport.Destination.S3BucketDestination", a.StorageClassAnalysis.DataExport.Destination.S3BucketDestination, b.StorageClassAnalysis.DataExport.Destination.S3BucketDestination)
				} else if a.StorageClassAnalysis.DataExport.Destination.S3BucketDestination != nil && b.StorageClassAnalysis.DataExport.Destination.S3BucketDestination != nil {
					if ackcompare.HasNilDifference(a.StorageClassAnalysis.DataExport.Destination.S3BucketDestination.Bucket, b.StorageClassAnalysis.DataExport.Destination.S3BucketDestination.Bucket) {
						delta.Add("AnalyticsConfiguration.StorageClassAnalysis.DataExport.Destination.S3BucketDestination.Bucket", a.StorageClassAnalysis.DataExport.Destination.S3BucketDestination.Bucket, b.StorageClassAnalysis.DataExport.Destination.S3BucketDestination.Bucket)
					} else if a.StorageClassAnalysis.DataExport.Destination.S3BucketDestination.Bucket != nil && b.StorageClassAnalysis.DataExport.Destination.S3BucketDestination.Bucket != nil {
						if *a.StorageClassAnalysis.DataExport.Destination.S3BucketDestination.Bucket != *b.StorageClassAnalysis.DataExport.Destination.S3BucketDestination.Bucket {
							delta.Add("AnalyticsConfiguration.StorageClassAnalysis.DataExport.Destination.S3BucketDestination.Bucket", a.StorageClassAnalysis.DataExport.Destination.S3BucketDestination.Bucket, b.StorageClassAnalysis.DataExport.Destination.S3BucketDestination.Bucket)
						}
					}
					if ackcompare.HasNilDifference(a.StorageClassAnalysis.DataExport.Destination.S3BucketDestination.BucketAccountID, b.StorageClassAnalysis.DataExport.Destination.S3BucketDestination.BucketAccountID) {
						delta.Add("AnalyticsConfiguration.StorageClassAnalysis.DataExport.Destination.S3BucketDestination.BucketAccountID", a.StorageClassAnalysis.DataExport.Destination.S3BucketDestination.BucketAccountID, b.StorageClassAnalysis.DataExport.Destination.S3BucketDestination.BucketAccountID)
					} else if a.StorageClassAnalysis.DataExport.Destination.S3BucketDestination.BucketAccountID != nil && b.StorageClassAnalysis.DataExport.Destination.S3BucketDestination.BucketAccountID != nil {
						if *a.StorageClassAnalysis.DataExport.Destination.S3BucketDestination.BucketAccountID != *b.StorageClassAnalysis.DataExport.Destination.S3BucketDestination.BucketAccountID {
							delta.Add("AnalyticsConfiguration.StorageClassAnalysis.DataExport.Destination.S3BucketDestination.BucketAccountID", a.StorageClassAnalysis.DataExport.Destination.S3BucketDestination.BucketAccountID, b.StorageClassAnalysis.DataExport.Destination.S3BucketDestination.BucketAccountID)
						}
					}
					if ackcompare.HasNilDifference(a.StorageClassAnalysis.DataExport.Destination.S3BucketDestination.Format, b.StorageClassAnalysis.DataExport.Destination.S3BucketDestination.Format) {
						delta.Add("AnalyticsConfiguration.StorageClassAnalysis.DataExport.Destination.S3BucketDestination.Format", a.StorageClassAnalysis.DataExport.Destination.S3BucketDestination.Format, b.StorageClassAnalysis.DataExport.Destination.S3BucketDestination.Format)
					} else if a.StorageClassAnalysis.DataExport.Destination.S3BucketDestination.Format != nil && b.StorageClassAnalysis.DataExport.Destination.S3BucketDestination.Format != nil {
						if *a.StorageClassAnalysis.DataExport.Destination.S3BucketDestination.Format != *b.StorageClassAnalysis.DataExport.Destination.S3BucketDestination.Format {
							delta.Add("AnalyticsConfiguration.StorageClassAnalysis.DataExport.Destination.S3BucketDestination.Format", a.StorageClassAnalysis.DataExport.Destination.S3BucketDestination.Format, b.StorageClassAnalysis.DataExport.Destination.S3BucketDestination.Format)
						}
					}
					if ackcompare.HasNilDifference(a.StorageClassAnalysis.DataExport.Destination.S3BucketDestination.Prefix, b.StorageClassAnalysis.DataExport.Destination.S3BucketDestination.Prefix) {
						delta.Add("AnalyticsConfiguration.StorageClassAnalysis.DataExport.Destination.S3BucketDestination.Prefix", a.StorageClassAnalysis.DataExport.Destination.S3BucketDestination.Prefix, b.StorageClassAnalysis.DataExport.Destination.S3BucketDestination.Prefix)
					} else if a.StorageClassAnalysis.DataExport.Destination.S3BucketDestination.Prefix != nil && b.StorageClassAnalysis.DataExport.Destination.S3BucketDestination.Prefix != nil {
						if *a.StorageClassAnalysis.DataExport.Destination.S3BucketDestination.Prefix != *b.StorageClassAnalysis.DataExport.Destination.S3BucketDestination.Prefix {
							delta.Add("AnalyticsConfiguration.StorageClassAnalysis.DataExport.Destination.S3BucketDestination.Prefix", a.StorageClassAnalysis.DataExport.Destination.S3BucketDestination.Prefix, b.StorageClassAnalysis.DataExport.Destination.S3BucketDestination.Prefix)
						}
					}
				}
			}
			if ackcompare.HasNilDifference(a.StorageClassAnalysis.DataExport.OutputSchemaVersion, b.StorageClassAnalysis.DataExport.OutputSchemaVersion) {
				delta.Add("AnalyticsConfiguration.StorageClassAnalysis.DataExport.OutputSchemaVersion", a.StorageClassAnalysis.DataExport.OutputSchemaVersion, b.StorageClassAnalysis.DataExport.OutputSchemaVersion)
			} else if a.StorageClassAnalysis.DataExport.OutputSchemaVersion != nil && b.StorageClassAnalysis.DataExport.OutputSchemaVersion != nil {
				if *a.StorageClassAnalysis.DataExport.OutputSchemaVersion != *b.StorageClassAnalysis.DataExport.OutputSchemaVersion {
					delta.Add("AnalyticsConfiguration.StorageClassAnalysis.DataExport.OutputSchemaVersion", a.StorageClassAnalysis.DataExport.OutputSchemaVersion, b.StorageClassAnalysis.DataExport.OutputSchemaVersion)
				}
			}
		}
	}

	return delta
}

// getAnalyticsConfigurationAction returns the determined action for a given
// configuration object, depending on the desired and latest values
func getAnalyticsConfigurationAction(
	c *svcapitypes.AnalyticsConfiguration,
	latest *resource,
) ConfigurationAction {
	action := ConfigurationActionPut
	if latest != nil {
		for _, l := range latest.ko.Spec.Analytics {
			if *l.ID != *c.ID {
				continue
			}

			// Don't perform any action if they are identical
			delta := compareAnalyticsConfiguration(l, c)
			if len(delta.Differences) > 0 {
				action = ConfigurationActionUpdate
			} else {
				action = ConfigurationActionNone
			}
			break
		}
	}
	return action
}

func (rm *resourceManager) newListBucketAnalyticsPayload(
	r *resource,
) *svcsdk.ListBucketAnalyticsConfigurationsInput {
	res := &svcsdk.ListBucketAnalyticsConfigurationsInput{}
	res.SetBucket(*r.ko.Spec.Name)
	return res
}

func (rm *resourceManager) newPutBucketAnalyticsPayload(
	r *resource,
	c svcapitypes.AnalyticsConfiguration,
) *svcsdk.PutBucketAnalyticsConfigurationInput {
	res := &svcsdk.PutBucketAnalyticsConfigurationInput{}
	res.SetBucket(*r.ko.Spec.Name)
	res.SetId(*c.ID)
	res.SetAnalyticsConfiguration(rm.newAnalyticsConfiguration(&c))

	return res
}

func (rm *resourceManager) newDeleteBucketAnalyticsPayload(
	r *resource,
	c svcapitypes.AnalyticsConfiguration,
) *svcsdk.DeleteBucketAnalyticsConfigurationInput {
	res := &svcsdk.DeleteBucketAnalyticsConfigurationInput{}
	res.SetBucket(*r.ko.Spec.Name)
	res.SetId(*c.ID)

	return res
}

func (rm *resourceManager) deleteAnalyticsConfiguration(
	ctx context.Context,
	r *resource,
	c svcapitypes.AnalyticsConfiguration,
) (err error) {
	rlog := ackrtlog.FromContext(ctx)
	exit := rlog.Trace("rm.deleteAnalyticsConfiguration")
	defer exit(err)

	input := rm.newDeleteBucketAnalyticsPayload(r, c)
	_, err = rm.sdkapi.DeleteBucketAnalyticsConfigurationWithContext(ctx, input)
	rm.metrics.RecordAPICall("DELETE", "DeleteBucketAnalyticsConfiguration", err)
	return err
}

func (rm *resourceManager) putAnalyticsConfiguration(
	ctx context.Context,
	r *resource,
	c svcapitypes.AnalyticsConfiguration,
) (err error) {
	rlog := ackrtlog.FromContext(ctx)
	exit := rlog.Trace("rm.putAnalyticsConfiguration")
	defer exit(err)

	input := rm.newPutBucketAnalyticsPayload(r, c)
	_, err = rm.sdkapi.PutBucketAnalyticsConfigurationWithContext(ctx, input)
	rm.metrics.RecordAPICall("UPDATE", "PutBucketAnalyticsConfiguration", err)
	return err
}

func (rm *resourceManager) syncAnalytics(
	ctx context.Context,
	desired *resource,
	latest *resource,
) (err error) {
	rlog := ackrtlog.FromContext(ctx)
	exit := rlog.Trace("rm.syncAnalytics")
	defer exit(err)

	for _, c := range desired.ko.Spec.Analytics {
		action := getAnalyticsConfigurationAction(c, latest)

		switch action {
		case ConfigurationActionUpdate:
			fallthrough
		case ConfigurationActionPut:
			if err = rm.putAnalyticsConfiguration(ctx, desired, *c); err != nil {
				return err
			}
		default:
		}
	}

	if latest != nil {
		// Find any configurations that are in the latest but not in desired
		for _, l := range latest.ko.Spec.Analytics {
			exists := false
			for _, c := range desired.ko.Spec.Analytics {
				if *c.ID != *l.ID {
					continue
				}
				exists = true
				break
			}

			if !exists {
				if err = rm.deleteAnalyticsConfiguration(ctx, desired, *l); err != nil {
					return err
				}
			}
		}
	}

	return nil
}

// newCORSConfiguration returns a CORSConfiguration object
// with each the field set by the resource's corresponding spec field.
func (rm *resourceManager) newCORSConfiguration(
	r *resource,
) *svcsdk.CORSConfiguration {
	res := &svcsdk.CORSConfiguration{}

	if r.ko.Spec.CORS.CORSRules != nil {
		resf0 := []*svcsdk.CORSRule{}
		for _, resf0iter := range r.ko.Spec.CORS.CORSRules {
			resf0elem := &svcsdk.CORSRule{}
			if resf0iter.AllowedHeaders != nil {
				resf0elemf0 := []*string{}
				for _, resf0elemf0iter := range resf0iter.AllowedHeaders {
					var resf0elemf0elem string
					resf0elemf0elem = *resf0elemf0iter
					resf0elemf0 = append(resf0elemf0, &resf0elemf0elem)
				}
				resf0elem.SetAllowedHeaders(resf0elemf0)
			}
			if resf0iter.AllowedMethods != nil {
				resf0elemf1 := []*string{}
				for _, resf0elemf1iter := range resf0iter.AllowedMethods {
					var resf0elemf1elem string
					resf0elemf1elem = *resf0elemf1iter
					resf0elemf1 = append(resf0elemf1, &resf0elemf1elem)
				}
				resf0elem.SetAllowedMethods(resf0elemf1)
			}
			if resf0iter.AllowedOrigins != nil {
				resf0elemf2 := []*string{}
				for _, resf0elemf2iter := range resf0iter.AllowedOrigins {
					var resf0elemf2elem string
					resf0elemf2elem = *resf0elemf2iter
					resf0elemf2 = append(resf0elemf2, &resf0elemf2elem)
				}
				resf0elem.SetAllowedOrigins(resf0elemf2)
			}
			if resf0iter.ExposeHeaders != nil {
				resf0elemf3 := []*string{}
				for _, resf0elemf3iter := range resf0iter.ExposeHeaders {
					var resf0elemf3elem string
					resf0elemf3elem = *resf0elemf3iter
					resf0elemf3 = append(resf0elemf3, &resf0elemf3elem)
				}
				resf0elem.SetExposeHeaders(resf0elemf3)
			}
			if resf0iter.ID != nil {
				resf0elem.SetID(*resf0iter.ID)
			}
			if resf0iter.MaxAgeSeconds != nil {
				resf0elem.SetMaxAgeSeconds(*resf0iter.MaxAgeSeconds)
			}
			resf0 = append(resf0, resf0elem)
		}
		res.SetCORSRules(resf0)
	}

	return res
}

// setResourceCORS sets the `CORS` spec field
// given the output of a `GetBucketCors` operation.
func (rm *resourceManager) setResourceCORS(
	r *resource,
	resp *svcsdk.GetBucketCorsOutput,
) *svcapitypes.CORSConfiguration {
	res := &svcapitypes.CORSConfiguration{}

	if resp.CORSRules != nil {
		resf0 := []*svcapitypes.CORSRule{}
		for _, resf0iter := range resp.CORSRules {
			resf0elem := &svcapitypes.CORSRule{}
			if resf0iter.AllowedHeaders != nil {
				resf0elemf0 := []*string{}
				for _, resf0elemf0iter := range resf0iter.AllowedHeaders {
					var resf0elemf0elem string
					resf0elemf0elem = *resf0elemf0iter
					resf0elemf0 = append(resf0elemf0, &resf0elemf0elem)
				}
				resf0elem.AllowedHeaders = resf0elemf0
			}
			if resf0iter.AllowedMethods != nil {
				resf0elemf1 := []*string{}
				for _, resf0elemf1iter := range resf0iter.AllowedMethods {
					var resf0elemf1elem string
					resf0elemf1elem = *resf0elemf1iter
					resf0elemf1 = append(resf0elemf1, &resf0elemf1elem)
				}
				resf0elem.AllowedMethods = resf0elemf1
			}
			if resf0iter.AllowedOrigins != nil {
				resf0elemf2 := []*string{}
				for _, resf0elemf2iter := range resf0iter.AllowedOrigins {
					var resf0elemf2elem string
					resf0elemf2elem = *resf0elemf2iter
					resf0elemf2 = append(resf0elemf2, &resf0elemf2elem)
				}
				resf0elem.AllowedOrigins = resf0elemf2
			}
			if resf0iter.ExposeHeaders != nil {
				resf0elemf3 := []*string{}
				for _, resf0elemf3iter := range resf0iter.ExposeHeaders {
					var resf0elemf3elem string
					resf0elemf3elem = *resf0elemf3iter
					resf0elemf3 = append(resf0elemf3, &resf0elemf3elem)
				}
				resf0elem.ExposeHeaders = resf0elemf3
			}
			if resf0iter.ID != nil {
				resf0elem.ID = resf0iter.ID
			}
			if resf0iter.MaxAgeSeconds != nil {
				resf0elem.MaxAgeSeconds = resf0iter.MaxAgeSeconds
			}
			resf0 = append(resf0, resf0elem)
		}
		res.CORSRules = resf0
	}

	return res
}

// newServerSideEncryptionConfiguration returns a ServerSideEncryptionConfiguration object
// with each the field set by the resource's corresponding spec field.
func (rm *resourceManager) newServerSideEncryptionConfiguration(
	r *resource,
) *svcsdk.ServerSideEncryptionConfiguration {
	res := &svcsdk.ServerSideEncryptionConfiguration{}

	if r.ko.Spec.Encryption.Rules != nil {
		resf0 := []*svcsdk.ServerSideEncryptionRule{}
		for _, resf0iter := range r.ko.Spec.Encryption.Rules {
			resf0elem := &svcsdk.ServerSideEncryptionRule{}
			if resf0iter.ApplyServerSideEncryptionByDefault != nil {
				resf0elemf0 := &svcsdk.ServerSideEncryptionByDefault{}
				if resf0iter.ApplyServerSideEncryptionByDefault.KMSMasterKeyID != nil {
					resf0elemf0.SetKMSMasterKeyID(*resf0iter.ApplyServerSideEncryptionByDefault.KMSMasterKeyID)
				}
				if resf0iter.ApplyServerSideEncryptionByDefault.SSEAlgorithm != nil {
					resf0elemf0.SetSSEAlgorithm(*resf0iter.ApplyServerSideEncryptionByDefault.SSEAlgorithm)
				}
				resf0elem.SetApplyServerSideEncryptionByDefault(resf0elemf0)
			}
			if resf0iter.BucketKeyEnabled != nil {
				resf0elem.SetBucketKeyEnabled(*resf0iter.BucketKeyEnabled)
			}
			resf0 = append(resf0, resf0elem)
		}
		res.SetRules(resf0)
	}

	return res
}

// setResourceEncryption sets the `Encryption` spec field
// given the output of a `GetBucketEncryption` operation.
func (rm *resourceManager) setResourceEncryption(
	r *resource,
	resp *svcsdk.GetBucketEncryptionOutput,
) *svcapitypes.ServerSideEncryptionConfiguration {
	res := &svcapitypes.ServerSideEncryptionConfiguration{}

	if resp.ServerSideEncryptionConfiguration.Rules != nil {
		resf0 := []*svcapitypes.ServerSideEncryptionRule{}
		for _, resf0iter := range resp.ServerSideEncryptionConfiguration.Rules {
			resf0elem := &svcapitypes.ServerSideEncryptionRule{}
			if resf0iter.ApplyServerSideEncryptionByDefault != nil {
				resf0elemf0 := &svcapitypes.ServerSideEncryptionByDefault{}
				if resf0iter.ApplyServerSideEncryptionByDefault.KMSMasterKeyID != nil {
					resf0elemf0.KMSMasterKeyID = resf0iter.ApplyServerSideEncryptionByDefault.KMSMasterKeyID
				}
				if resf0iter.ApplyServerSideEncryptionByDefault.SSEAlgorithm != nil {
					resf0elemf0.SSEAlgorithm = resf0iter.ApplyServerSideEncryptionByDefault.SSEAlgorithm
				}
				resf0elem.ApplyServerSideEncryptionByDefault = resf0elemf0
			}
			if resf0iter.BucketKeyEnabled != nil {
				resf0elem.BucketKeyEnabled = resf0iter.BucketKeyEnabled
			}
			resf0 = append(resf0, resf0elem)
		}
		res.Rules = resf0
	}

	return res
}

// newIntelligentTieringConfiguration returns a IntelligentTieringConfiguration object
// with each the field set by the corresponding configuration's fields.
func (rm *resourceManager) newIntelligentTieringConfiguration(
	c *svcapitypes.IntelligentTieringConfiguration,
) *svcsdk.IntelligentTieringConfiguration {
	res := &svcsdk.IntelligentTieringConfiguration{}

	if c.Filter != nil {
		resf0 := &svcsdk.IntelligentTieringFilter{}
		if c.Filter.And != nil {
			resf0f0 := &svcsdk.IntelligentTieringAndOperator{}
			if c.Filter.And.Prefix != nil {
				resf0f0.SetPrefix(*c.Filter.And.Prefix)
			}
			if c.Filter.And.Tags != nil {
				resf0f0f1 := []*svcsdk.Tag{}
				for _, resf0f0f1iter := range c.Filter.And.Tags {
					resf0f0f1elem := &svcsdk.Tag{}
					if resf0f0f1iter.Key != nil {
						resf0f0f1elem.SetKey(*resf0f0f1iter.Key)
					}
					if resf0f0f1iter.Value != nil {
						resf0f0f1elem.SetValue(*resf0f0f1iter.Value)
					}
					resf0f0f1 = append(resf0f0f1, resf0f0f1elem)
				}
				resf0f0.SetTags(resf0f0f1)
			}
			resf0.SetAnd(resf0f0)
		}
		if c.Filter.Prefix != nil {
			resf0.SetPrefix(*c.Filter.Prefix)
		}
		if c.Filter.Tag != nil {
			resf0f2 := &svcsdk.Tag{}
			if c.Filter.Tag.Key != nil {
				resf0f2.SetKey(*c.Filter.Tag.Key)
			}
			if c.Filter.Tag.Value != nil {
				resf0f2.SetValue(*c.Filter.Tag.Value)
			}
			resf0.SetTag(resf0f2)
		}
		res.SetFilter(resf0)
	}
	if c.ID != nil {
		res.SetId(*c.ID)
	}
	if c.Status != nil {
		res.SetStatus(*c.Status)
	}
	if c.Tierings != nil {
		resf3 := []*svcsdk.Tiering{}
		for _, resf3iter := range c.Tierings {
			resf3elem := &svcsdk.Tiering{}
			if resf3iter.AccessTier != nil {
				resf3elem.SetAccessTier(*resf3iter.AccessTier)
			}
			if resf3iter.Days != nil {
				resf3elem.SetDays(*resf3iter.Days)
			}
			resf3 = append(resf3, resf3elem)
		}
		res.SetTierings(resf3)
	}

	return res
}

// setIntelligentTieringConfiguration sets a resource IntelligentTieringConfiguration type
// given the SDK type.
func (rm *resourceManager) setResourceIntelligentTieringConfiguration(
	r *resource,
	resp *svcsdk.IntelligentTieringConfiguration,
) *svcapitypes.IntelligentTieringConfiguration {
	res := &svcapitypes.IntelligentTieringConfiguration{}

	if resp.Filter != nil {
		resf0 := &svcapitypes.IntelligentTieringFilter{}
		if resp.Filter.And != nil {
			resf0f0 := &svcapitypes.IntelligentTieringAndOperator{}
			if resp.Filter.And.Prefix != nil {
				resf0f0.Prefix = resp.Filter.And.Prefix
			}
			if resp.Filter.And.Tags != nil {
				resf0f0f1 := []*svcapitypes.Tag{}
				for _, resf0f0f1iter := range resp.Filter.And.Tags {
					resf0f0f1elem := &svcapitypes.Tag{}
					if resf0f0f1iter.Key != nil {
						resf0f0f1elem.Key = resf0f0f1iter.Key
					}
					if resf0f0f1iter.Value != nil {
						resf0f0f1elem.Value = resf0f0f1iter.Value
					}
					resf0f0f1 = append(resf0f0f1, resf0f0f1elem)
				}
				resf0f0.Tags = resf0f0f1
			}
			resf0.And = resf0f0
		}
		if resp.Filter.Prefix != nil {
			resf0.Prefix = resp.Filter.Prefix
		}
		if resp.Filter.Tag != nil {
			resf0f2 := &svcapitypes.Tag{}
			if resp.Filter.Tag.Key != nil {
				resf0f2.Key = resp.Filter.Tag.Key
			}
			if resp.Filter.Tag.Value != nil {
				resf0f2.Value = resp.Filter.Tag.Value
			}
			resf0.Tag = resf0f2
		}
		res.Filter = resf0
	}
	if resp.Id != nil {
		res.ID = resp.Id
	}
	if resp.Status != nil {
		res.Status = resp.Status
	}
	if resp.Tierings != nil {
		resf3 := []*svcapitypes.Tiering{}
		for _, resf3iter := range resp.Tierings {
			resf3elem := &svcapitypes.Tiering{}
			if resf3iter.AccessTier != nil {
				resf3elem.AccessTier = resf3iter.AccessTier
			}
			if resf3iter.Days != nil {
				resf3elem.Days = resf3iter.Days
			}
			resf3 = append(resf3, resf3elem)
		}
		res.Tierings = resf3
	}

	return res
}

func compareIntelligentTieringConfiguration(
	a *svcapitypes.IntelligentTieringConfiguration,
	b *svcapitypes.IntelligentTieringConfiguration,
) *ackcompare.Delta {
	delta := ackcompare.NewDelta()
	if ackcompare.HasNilDifference(a.Filter, b.Filter) {
		delta.Add("IntelligentTieringConfiguration.Filter", a.Filter, b.Filter)
	} else if a.Filter != nil && b.Filter != nil {
		if ackcompare.HasNilDifference(a.Filter.And, b.Filter.And) {
			delta.Add("IntelligentTieringConfiguration.Filter.And", a.Filter.And, b.Filter.And)
		} else if a.Filter.And != nil && b.Filter.And != nil {
			if ackcompare.HasNilDifference(a.Filter.And.Prefix, b.Filter.And.Prefix) {
				delta.Add("IntelligentTieringConfiguration.Filter.And.Prefix", a.Filter.And.Prefix, b.Filter.And.Prefix)
			} else if a.Filter.And.Prefix != nil && b.Filter.And.Prefix != nil {
				if *a.Filter.And.Prefix != *b.Filter.And.Prefix {
					delta.Add("IntelligentTieringConfiguration.Filter.And.Prefix", a.Filter.And.Prefix, b.Filter.And.Prefix)
				}
			}
			if len(a.Filter.And.Tags) != len(b.Filter.And.Tags) {
				delta.Add("IntelligentTieringConfiguration.Filter.And.Tags", a.Filter.And.Tags, b.Filter.And.Tags)
			} else if len(a.Filter.And.Tags) > 0 {
				if !reflect.DeepEqual(a.Filter.And.Tags, b.Filter.And.Tags) {
					delta.Add("IntelligentTieringConfiguration.Filter.And.Tags", a.Filter.And.Tags, b.Filter.And.Tags)
				}
			}
		}
		if ackcompare.HasNilDifference(a.Filter.Prefix, b.Filter.Prefix) {
			delta.Add("IntelligentTieringConfiguration.Filter.Prefix", a.Filter.Prefix, b.Filter.Prefix)
		} else if a.Filter.Prefix != nil && b.Filter.Prefix != nil {
			if *a.Filter.Prefix != *b.Filter.Prefix {
				delta.Add("IntelligentTieringConfiguration.Filter.Prefix", a.Filter.Prefix, b.Filter.Prefix)
			}
		}
		if ackcompare.HasNilDifference(a.Filter.Tag, b.Filter.Tag) {
			delta.Add("IntelligentTieringConfiguration.Filter.Tag", a.Filter.Tag, b.Filter.Tag)
		} else if a.Filter.Tag != nil && b.Filter.Tag != nil {
			if ackcompare.HasNilDifference(a.Filter.Tag.Key, b.Filter.Tag.Key) {
				delta.Add("IntelligentTieringConfiguration.Filter.Tag.Key", a.Filter.Tag.Key, b.Filter.Tag.Key)
			} else if a.Filter.Tag.Key != nil && b.Filter.Tag.Key != nil {
				if *a.Filter.Tag.Key != *b.Filter.Tag.Key {
					delta.Add("IntelligentTieringConfiguration.Filter.Tag.Key", a.Filter.Tag.Key, b.Filter.Tag.Key)
				}
			}
			if ackcompare.HasNilDifference(a.Filter.Tag.Value, b.Filter.Tag.Value) {
				delta.Add("IntelligentTieringConfiguration.Filter.Tag.Value", a.Filter.Tag.Value, b.Filter.Tag.Value)
			} else if a.Filter.Tag.Value != nil && b.Filter.Tag.Value != nil {
				if *a.Filter.Tag.Value != *b.Filter.Tag.Value {
					delta.Add("IntelligentTieringConfiguration.Filter.Tag.Value", a.Filter.Tag.Value, b.Filter.Tag.Value)
				}
			}
		}
	}
	if ackcompare.HasNilDifference(a.ID, b.ID) {
		delta.Add("IntelligentTieringConfiguration.ID", a.ID, b.ID)
	} else if a.ID != nil && b.ID != nil {
		if *a.ID != *b.ID {
			delta.Add("IntelligentTieringConfiguration.ID", a.ID, b.ID)
		}
	}
	if ackcompare.HasNilDifference(a.Status, b.Status) {
		delta.Add("IntelligentTieringConfiguration.Status", a.Status, b.Status)
	} else if a.Status != nil && b.Status != nil {
		if *a.Status != *b.Status {
			delta.Add("IntelligentTieringConfiguration.Status", a.Status, b.Status)
		}
	}
	if len(a.Tierings) != len(b.Tierings) {
		delta.Add("IntelligentTieringConfiguration.Tierings", a.Tierings, b.Tierings)
	} else if len(a.Tierings) > 0 {
		if !reflect.DeepEqual(a.Tierings, b.Tierings) {
			delta.Add("IntelligentTieringConfiguration.Tierings", a.Tierings, b.Tierings)
		}
	}

	return delta
}

// getIntelligentTieringConfigurationAction returns the determined action for a given
// configuration object, depending on the desired and latest values
func getIntelligentTieringConfigurationAction(
	c *svcapitypes.IntelligentTieringConfiguration,
	latest *resource,
) ConfigurationAction {
	action := ConfigurationActionPut
	if latest != nil {
		for _, l := range latest.ko.Spec.IntelligentTiering {
			if *l.ID != *c.ID {
				continue
			}

			// Don't perform any action if they are identical
			delta := compareIntelligentTieringConfiguration(l, c)
			if len(delta.Differences) > 0 {
				action = ConfigurationActionUpdate
			} else {
				action = ConfigurationActionNone
			}
			break
		}
	}
	return action
}

func (rm *resourceManager) newListBucketIntelligentTieringPayload(
	r *resource,
) *svcsdk.ListBucketIntelligentTieringConfigurationsInput {
	res := &svcsdk.ListBucketIntelligentTieringConfigurationsInput{}
	res.SetBucket(*r.ko.Spec.Name)
	return res
}

func (rm *resourceManager) newPutBucketIntelligentTieringPayload(
	r *resource,
	c svcapitypes.IntelligentTieringConfiguration,
) *svcsdk.PutBucketIntelligentTieringConfigurationInput {
	res := &svcsdk.PutBucketIntelligentTieringConfigurationInput{}
	res.SetBucket(*r.ko.Spec.Name)
	res.SetId(*c.ID)
	res.SetIntelligentTieringConfiguration(rm.newIntelligentTieringConfiguration(&c))

	return res
}

func (rm *resourceManager) newDeleteBucketIntelligentTieringPayload(
	r *resource,
	c svcapitypes.IntelligentTieringConfiguration,
) *svcsdk.DeleteBucketIntelligentTieringConfigurationInput {
	res := &svcsdk.DeleteBucketIntelligentTieringConfigurationInput{}
	res.SetBucket(*r.ko.Spec.Name)
	res.SetId(*c.ID)

	return res
}

func (rm *resourceManager) deleteIntelligentTieringConfiguration(
	ctx context.Context,
	r *resource,
	c svcapitypes.IntelligentTieringConfiguration,
) (err error) {
	rlog := ackrtlog.FromContext(ctx)
	exit := rlog.Trace("rm.deleteIntelligentTieringConfiguration")
	defer exit(err)

	input := rm.newDeleteBucketIntelligentTieringPayload(r, c)
	_, err = rm.sdkapi.DeleteBucketIntelligentTieringConfigurationWithContext(ctx, input)
	rm.metrics.RecordAPICall("DELETE", "DeleteBucketIntelligentTieringConfiguration", err)
	return err
}

func (rm *resourceManager) putIntelligentTieringConfiguration(
	ctx context.Context,
	r *resource,
	c svcapitypes.IntelligentTieringConfiguration,
) (err error) {
	rlog := ackrtlog.FromContext(ctx)
	exit := rlog.Trace("rm.putIntelligentTieringConfiguration")
	defer exit(err)

	input := rm.newPutBucketIntelligentTieringPayload(r, c)
	_, err = rm.sdkapi.PutBucketIntelligentTieringConfigurationWithContext(ctx, input)
	rm.metrics.RecordAPICall("UPDATE", "PutBucketIntelligentTieringConfiguration", err)
	return err
}

func (rm *resourceManager) syncIntelligentTiering(
	ctx context.Context,
	desired *resource,
	latest *resource,
) (err error) {
	rlog := ackrtlog.FromContext(ctx)
	exit := rlog.Trace("rm.syncIntelligentTiering")
	defer exit(err)

	for _, c := range desired.ko.Spec.IntelligentTiering {
		action := getIntelligentTieringConfigurationAction(c, latest)

		switch action {
		case ConfigurationActionUpdate:
			fallthrough
		case ConfigurationActionPut:
			if err = rm.putIntelligentTieringConfiguration(ctx, desired, *c); err != nil {
				return err
			}
		default:
		}
	}

	if latest != nil {
		// Find any configurations that are in the latest but not in desired
		for _, l := range latest.ko.Spec.IntelligentTiering {
			exists := false
			for _, c := range desired.ko.Spec.IntelligentTiering {
				if *c.ID != *l.ID {
					continue
				}
				exists = true
				break
			}

			if !exists {
				if err = rm.deleteIntelligentTieringConfiguration(ctx, desired, *l); err != nil {
					return err
				}
			}
		}
	}

	return nil
}

// newInventoryConfiguration returns a InventoryConfiguration object
// with each the field set by the corresponding configuration's fields.
func (rm *resourceManager) newInventoryConfiguration(
	c *svcapitypes.InventoryConfiguration,
) *svcsdk.InventoryConfiguration {
	res := &svcsdk.InventoryConfiguration{}

	if c.Destination != nil {
		resf0 := &svcsdk.InventoryDestination{}
		if c.Destination.S3BucketDestination != nil {
			resf0f0 := &svcsdk.InventoryS3BucketDestination{}
			if c.Destination.S3BucketDestination.AccountID != nil {
				resf0f0.SetAccountId(*c.Destination.S3BucketDestination.AccountID)
			}
			if c.Destination.S3BucketDestination.Bucket != nil {
				resf0f0.SetBucket(*c.Destination.S3BucketDestination.Bucket)
			}
			if c.Destination.S3BucketDestination.Encryption != nil {
				resf0f0f2 := &svcsdk.InventoryEncryption{}
				if c.Destination.S3BucketDestination.Encryption.SSEKMS != nil {
					resf0f0f2f0 := &svcsdk.SSEKMS{}
					if c.Destination.S3BucketDestination.Encryption.SSEKMS.KeyID != nil {
						resf0f0f2f0.SetKeyId(*c.Destination.S3BucketDestination.Encryption.SSEKMS.KeyID)
					}
					resf0f0f2.SetSSEKMS(resf0f0f2f0)
				}
				resf0f0.SetEncryption(resf0f0f2)
			}
			if c.Destination.S3BucketDestination.Format != nil {
				resf0f0.SetFormat(*c.Destination.S3BucketDestination.Format)
			}
			if c.Destination.S3BucketDestination.Prefix != nil {
				resf0f0.SetPrefix(*c.Destination.S3BucketDestination.Prefix)
			}
			resf0.SetS3BucketDestination(resf0f0)
		}
		res.SetDestination(resf0)
	}
	if c.Filter != nil {
		resf1 := &svcsdk.InventoryFilter{}
		if c.Filter.Prefix != nil {
			resf1.SetPrefix(*c.Filter.Prefix)
		}
		res.SetFilter(resf1)
	}
	if c.ID != nil {
		res.SetId(*c.ID)
	}
	if c.IncludedObjectVersions != nil {
		res.SetIncludedObjectVersions(*c.IncludedObjectVersions)
	}
	if c.IsEnabled != nil {
		res.SetIsEnabled(*c.IsEnabled)
	}
	if c.OptionalFields != nil {
		resf5 := []*string{}
		for _, resf5iter := range c.OptionalFields {
			var resf5elem string
			resf5elem = *resf5iter
			resf5 = append(resf5, &resf5elem)
		}
		res.SetOptionalFields(resf5)
	}
	if c.Schedule != nil {
		resf6 := &svcsdk.InventorySchedule{}
		if c.Schedule.Frequency != nil {
			resf6.SetFrequency(*c.Schedule.Frequency)
		}
		res.SetSchedule(resf6)
	}

	return res
}

// setInventoryConfiguration sets a resource InventoryConfiguration type
// given the SDK type.
func (rm *resourceManager) setResourceInventoryConfiguration(
	r *resource,
	resp *svcsdk.InventoryConfiguration,
) *svcapitypes.InventoryConfiguration {
	res := &svcapitypes.InventoryConfiguration{}

	if resp.Destination != nil {
		resf0 := &svcapitypes.InventoryDestination{}
		if resp.Destination.S3BucketDestination != nil {
			resf0f0 := &svcapitypes.InventoryS3BucketDestination{}
			if resp.Destination.S3BucketDestination.AccountId != nil {
				resf0f0.AccountID = resp.Destination.S3BucketDestination.AccountId
			}
			if resp.Destination.S3BucketDestination.Bucket != nil {
				resf0f0.Bucket = resp.Destination.S3BucketDestination.Bucket
			}
			if resp.Destination.S3BucketDestination.Encryption != nil {
				resf0f0f2 := &svcapitypes.InventoryEncryption{}
				if resp.Destination.S3BucketDestination.Encryption.SSEKMS != nil {
					resf0f0f2f0 := &svcapitypes.SSEKMS{}
					if resp.Destination.S3BucketDestination.Encryption.SSEKMS.KeyId != nil {
						resf0f0f2f0.KeyID = resp.Destination.S3BucketDestination.Encryption.SSEKMS.KeyId
					}
					resf0f0f2.SSEKMS = resf0f0f2f0
				}
				resf0f0.Encryption = resf0f0f2
			}
			if resp.Destination.S3BucketDestination.Format != nil {
				resf0f0.Format = resp.Destination.S3BucketDestination.Format
			}
			if resp.Destination.S3BucketDestination.Prefix != nil {
				resf0f0.Prefix = resp.Destination.S3BucketDestination.Prefix
			}
			resf0.S3BucketDestination = resf0f0
		}
		res.Destination = resf0
	}
	if resp.Filter != nil {
		resf1 := &svcapitypes.InventoryFilter{}
		if resp.Filter.Prefix != nil {
			resf1.Prefix = resp.Filter.Prefix
		}
		res.Filter = resf1
	}
	if resp.Id != nil {
		res.ID = resp.Id
	}
	if resp.IncludedObjectVersions != nil {
		res.IncludedObjectVersions = resp.IncludedObjectVersions
	}
	if resp.IsEnabled != nil {
		res.IsEnabled = resp.IsEnabled
	}
	if resp.OptionalFields != nil {
		resf5 := []*string{}
		for _, resf5iter := range resp.OptionalFields {
			var resf5elem string
			resf5elem = *resf5iter
			resf5 = append(resf5, &resf5elem)
		}
		res.OptionalFields = resf5
	}
	if resp.Schedule != nil {
		resf6 := &svcapitypes.InventorySchedule{}
		if resp.Schedule.Frequency != nil {
			resf6.Frequency = resp.Schedule.Frequency
		}
		res.Schedule = resf6
	}

	return res
}

func compareInventoryConfiguration(
	a *svcapitypes.InventoryConfiguration,
	b *svcapitypes.InventoryConfiguration,
) *ackcompare.Delta {
	delta := ackcompare.NewDelta()
	if ackcompare.HasNilDifference(a.Destination, b.Destination) {
		delta.Add("InventoryConfiguration.Destination", a.Destination, b.Destination)
	} else if a.Destination != nil && b.Destination != nil {
		if ackcompare.HasNilDifference(a.Destination.S3BucketDestination, b.Destination.S3BucketDestination) {
			delta.Add("InventoryConfiguration.Destination.S3BucketDestination", a.Destination.S3BucketDestination, b.Destination.S3BucketDestination)
		} else if a.Destination.S3BucketDestination != nil && b.Destination.S3BucketDestination != nil {
			if ackcompare.HasNilDifference(a.Destination.S3BucketDestination.AccountID, b.Destination.S3BucketDestination.AccountID) {
				delta.Add("InventoryConfiguration.Destination.S3BucketDestination.AccountID", a.Destination.S3BucketDestination.AccountID, b.Destination.S3BucketDestination.AccountID)
			} else if a.Destination.S3BucketDestination.AccountID != nil && b.Destination.S3BucketDestination.AccountID != nil {
				if *a.Destination.S3BucketDestination.AccountID != *b.Destination.S3BucketDestination.AccountID {
					delta.Add("InventoryConfiguration.Destination.S3BucketDestination.AccountID", a.Destination.S3BucketDestination.AccountID, b.Destination.S3BucketDestination.AccountID)
				}
			}
			if ackcompare.HasNilDifference(a.Destination.S3BucketDestination.Bucket, b.Destination.S3BucketDestination.Bucket) {
				delta.Add("InventoryConfiguration.Destination.S3BucketDestination.Bucket", a.Destination.S3BucketDestination.Bucket, b.Destination.S3BucketDestination.Bucket)
			} else if a.Destination.S3BucketDestination.Bucket != nil && b.Destination.S3BucketDestination.Bucket != nil {
				if *a.Destination.S3BucketDestination.Bucket != *b.Destination.S3BucketDestination.Bucket {
					delta.Add("InventoryConfiguration.Destination.S3BucketDestination.Bucket", a.Destination.S3BucketDestination.Bucket, b.Destination.S3BucketDestination.Bucket)
				}
			}
			if ackcompare.HasNilDifference(a.Destination.S3BucketDestination.Encryption, b.Destination.S3BucketDestination.Encryption) {
				delta.Add("InventoryConfiguration.Destination.S3BucketDestination.Encryption", a.Destination.S3BucketDestination.Encryption, b.Destination.S3BucketDestination.Encryption)
			} else if a.Destination.S3BucketDestination.Encryption != nil && b.Destination.S3BucketDestination.Encryption != nil {
				if ackcompare.HasNilDifference(a.Destination.S3BucketDestination.Encryption.SSEKMS, b.Destination.S3BucketDestination.Encryption.SSEKMS) {
					delta.Add("InventoryConfiguration.Destination.S3BucketDestination.Encryption.SSEKMS", a.Destination.S3BucketDestination.Encryption.SSEKMS, b.Destination.S3BucketDestination.Encryption.SSEKMS)
				} else if a.Destination.S3BucketDestination.Encryption.SSEKMS != nil && b.Destination.S3BucketDestination.Encryption.SSEKMS != nil {
					if ackcompare.HasNilDifference(a.Destination.S3BucketDestination.Encryption.SSEKMS.KeyID, b.Destination.S3BucketDestination.Encryption.SSEKMS.KeyID) {
						delta.Add("InventoryConfiguration.Destination.S3BucketDestination.Encryption.SSEKMS.KeyID", a.Destination.S3BucketDestination.Encryption.SSEKMS.KeyID, b.Destination.S3BucketDestination.Encryption.SSEKMS.KeyID)
					} else if a.Destination.S3BucketDestination.Encryption.SSEKMS.KeyID != nil && b.Destination.S3BucketDestination.Encryption.SSEKMS.KeyID != nil {
						if *a.Destination.S3BucketDestination.Encryption.SSEKMS.KeyID != *b.Destination.S3BucketDestination.Encryption.SSEKMS.KeyID {
							delta.Add("InventoryConfiguration.Destination.S3BucketDestination.Encryption.SSEKMS.KeyID", a.Destination.S3BucketDestination.Encryption.SSEKMS.KeyID, b.Destination.S3BucketDestination.Encryption.SSEKMS.KeyID)
						}
					}
				}
			}
			if ackcompare.HasNilDifference(a.Destination.S3BucketDestination.Format, b.Destination.S3BucketDestination.Format) {
				delta.Add("InventoryConfiguration.Destination.S3BucketDestination.Format", a.Destination.S3BucketDestination.Format, b.Destination.S3BucketDestination.Format)
			} else if a.Destination.S3BucketDestination.Format != nil && b.Destination.S3BucketDestination.Format != nil {
				if *a.Destination.S3BucketDestination.Format != *b.Destination.S3BucketDestination.Format {
					delta.Add("InventoryConfiguration.Destination.S3BucketDestination.Format", a.Destination.S3BucketDestination.Format, b.Destination.S3BucketDestination.Format)
				}
			}
			if ackcompare.HasNilDifference(a.Destination.S3BucketDestination.Prefix, b.Destination.S3BucketDestination.Prefix) {
				delta.Add("InventoryConfiguration.Destination.S3BucketDestination.Prefix", a.Destination.S3BucketDestination.Prefix, b.Destination.S3BucketDestination.Prefix)
			} else if a.Destination.S3BucketDestination.Prefix != nil && b.Destination.S3BucketDestination.Prefix != nil {
				if *a.Destination.S3BucketDestination.Prefix != *b.Destination.S3BucketDestination.Prefix {
					delta.Add("InventoryConfiguration.Destination.S3BucketDestination.Prefix", a.Destination.S3BucketDestination.Prefix, b.Destination.S3BucketDestination.Prefix)
				}
			}
		}
	}
	if ackcompare.HasNilDifference(a.Filter, b.Filter) {
		delta.Add("InventoryConfiguration.Filter", a.Filter, b.Filter)
	} else if a.Filter != nil && b.Filter != nil {
		if ackcompare.HasNilDifference(a.Filter.Prefix, b.Filter.Prefix) {
			delta.Add("InventoryConfiguration.Filter.Prefix", a.Filter.Prefix, b.Filter.Prefix)
		} else if a.Filter.Prefix != nil && b.Filter.Prefix != nil {
			if *a.Filter.Prefix != *b.Filter.Prefix {
				delta.Add("InventoryConfiguration.Filter.Prefix", a.Filter.Prefix, b.Filter.Prefix)
			}
		}
	}
	if ackcompare.HasNilDifference(a.ID, b.ID) {
		delta.Add("InventoryConfiguration.ID", a.ID, b.ID)
	} else if a.ID != nil && b.ID != nil {
		if *a.ID != *b.ID {
			delta.Add("InventoryConfiguration.ID", a.ID, b.ID)
		}
	}
	if ackcompare.HasNilDifference(a.IncludedObjectVersions, b.IncludedObjectVersions) {
		delta.Add("InventoryConfiguration.IncludedObjectVersions", a.IncludedObjectVersions, b.IncludedObjectVersions)
	} else if a.IncludedObjectVersions != nil && b.IncludedObjectVersions != nil {
		if *a.IncludedObjectVersions != *b.IncludedObjectVersions {
			delta.Add("InventoryConfiguration.IncludedObjectVersions", a.IncludedObjectVersions, b.IncludedObjectVersions)
		}
	}
	if ackcompare.HasNilDifference(a.IsEnabled, b.IsEnabled) {
		delta.Add("InventoryConfiguration.IsEnabled", a.IsEnabled, b.IsEnabled)
	} else if a.IsEnabled != nil && b.IsEnabled != nil {
		if *a.IsEnabled != *b.IsEnabled {
			delta.Add("InventoryConfiguration.IsEnabled", a.IsEnabled, b.IsEnabled)
		}
	}
	if len(a.OptionalFields) != len(b.OptionalFields) {
		delta.Add("InventoryConfiguration.OptionalFields", a.OptionalFields, b.OptionalFields)
	} else if len(a.OptionalFields) > 0 {
		if !ackcompare.SliceStringPEqual(a.OptionalFields, b.OptionalFields) {
			delta.Add("InventoryConfiguration.OptionalFields", a.OptionalFields, b.OptionalFields)
		}
	}
	if ackcompare.HasNilDifference(a.Schedule, b.Schedule) {
		delta.Add("InventoryConfiguration.Schedule", a.Schedule, b.Schedule)
	} else if a.Schedule != nil && b.Schedule != nil {
		if ackcompare.HasNilDifference(a.Schedule.Frequency, b.Schedule.Frequency) {
			delta.Add("InventoryConfiguration.Schedule.Frequency", a.Schedule.Frequency, b.Schedule.Frequency)
		} else if a.Schedule.Frequency != nil && b.Schedule.Frequency != nil {
			if *a.Schedule.Frequency != *b.Schedule.Frequency {
				delta.Add("InventoryConfiguration.Schedule.Frequency", a.Schedule.Frequency, b.Schedule.Frequency)
			}
		}
	}

	return delta
}

// getInventoryConfigurationAction returns the determined action for a given
// configuration object, depending on the desired and latest values
func getInventoryConfigurationAction(
	c *svcapitypes.InventoryConfiguration,
	latest *resource,
) ConfigurationAction {
	action := ConfigurationActionPut
	if latest != nil {
		for _, l := range latest.ko.Spec.Inventory {
			if *l.ID != *c.ID {
				continue
			}

			// Don't perform any action if they are identical
			delta := compareInventoryConfiguration(l, c)
			if len(delta.Differences) > 0 {
				action = ConfigurationActionUpdate
			} else {
				action = ConfigurationActionNone
			}
			break
		}
	}
	return action
}

func (rm *resourceManager) newListBucketInventoryPayload(
	r *resource,
) *svcsdk.ListBucketInventoryConfigurationsInput {
	res := &svcsdk.ListBucketInventoryConfigurationsInput{}
	res.SetBucket(*r.ko.Spec.Name)
	return res
}

func (rm *resourceManager) newPutBucketInventoryPayload(
	r *resource,
	c svcapitypes.InventoryConfiguration,
) *svcsdk.PutBucketInventoryConfigurationInput {
	res := &svcsdk.PutBucketInventoryConfigurationInput{}
	res.SetBucket(*r.ko.Spec.Name)
	res.SetId(*c.ID)
	res.SetInventoryConfiguration(rm.newInventoryConfiguration(&c))

	return res
}

func (rm *resourceManager) newDeleteBucketInventoryPayload(
	r *resource,
	c svcapitypes.InventoryConfiguration,
) *svcsdk.DeleteBucketInventoryConfigurationInput {
	res := &svcsdk.DeleteBucketInventoryConfigurationInput{}
	res.SetBucket(*r.ko.Spec.Name)
	res.SetId(*c.ID)

	return res
}

func (rm *resourceManager) deleteInventoryConfiguration(
	ctx context.Context,
	r *resource,
	c svcapitypes.InventoryConfiguration,
) (err error) {
	rlog := ackrtlog.FromContext(ctx)
	exit := rlog.Trace("rm.deleteInventoryConfiguration")
	defer exit(err)

	input := rm.newDeleteBucketInventoryPayload(r, c)
	_, err = rm.sdkapi.DeleteBucketInventoryConfigurationWithContext(ctx, input)
	rm.metrics.RecordAPICall("DELETE", "DeleteBucketInventoryConfiguration", err)
	return err
}

func (rm *resourceManager) putInventoryConfiguration(
	ctx context.Context,
	r *resource,
	c svcapitypes.InventoryConfiguration,
) (err error) {
	rlog := ackrtlog.FromContext(ctx)
	exit := rlog.Trace("rm.putInventoryConfiguration")
	defer exit(err)

	input := rm.newPutBucketInventoryPayload(r, c)
	_, err = rm.sdkapi.PutBucketInventoryConfigurationWithContext(ctx, input)
	rm.metrics.RecordAPICall("UPDATE", "PutBucketInventoryConfiguration", err)
	return err
}

func (rm *resourceManager) syncInventory(
	ctx context.Context,
	desired *resource,
	latest *resource,
) (err error) {
	rlog := ackrtlog.FromContext(ctx)
	exit := rlog.Trace("rm.syncInventory")
	defer exit(err)

	for _, c := range desired.ko.Spec.Inventory {
		action := getInventoryConfigurationAction(c, latest)

		switch action {
		case ConfigurationActionUpdate:
			fallthrough
		case ConfigurationActionPut:
			if err = rm.putInventoryConfiguration(ctx, desired, *c); err != nil {
				return err
			}
		default:
		}
	}

	if latest != nil {
		// Find any configurations that are in the latest but not in desired
		for _, l := range latest.ko.Spec.Inventory {
			exists := false
			for _, c := range desired.ko.Spec.Inventory {
				if *c.ID != *l.ID {
					continue
				}
				exists = true
				break
			}

			if !exists {
				if err = rm.deleteInventoryConfiguration(ctx, desired, *l); err != nil {
					return err
				}
			}
		}
	}

	return nil
}

// newLifecycleConfiguration returns a LifecycleConfiguration object
// with each the field set by the resource's corresponding spec field.
func (rm *resourceManager) newLifecycleConfiguration(
	r *resource,
) *svcsdk.BucketLifecycleConfiguration {
	res := &svcsdk.BucketLifecycleConfiguration{}

	if r.ko.Spec.Lifecycle.Rules != nil {
		resf0 := []*svcsdk.LifecycleRule{}
		for _, resf0iter := range r.ko.Spec.Lifecycle.Rules {
			resf0elem := &svcsdk.LifecycleRule{}
			if resf0iter.AbortIncompleteMultipartUpload != nil {
				resf0elemf0 := &svcsdk.AbortIncompleteMultipartUpload{}
				if resf0iter.AbortIncompleteMultipartUpload.DaysAfterInitiation != nil {
					resf0elemf0.SetDaysAfterInitiation(*resf0iter.AbortIncompleteMultipartUpload.DaysAfterInitiation)
				}
				resf0elem.SetAbortIncompleteMultipartUpload(resf0elemf0)
			}
			if resf0iter.Expiration != nil {
				resf0elemf1 := &svcsdk.LifecycleExpiration{}
				if resf0iter.Expiration.Date != nil {
					resf0elemf1.SetDate(resf0iter.Expiration.Date.Time)
				}
				if resf0iter.Expiration.Days != nil {
					resf0elemf1.SetDays(*resf0iter.Expiration.Days)
				}
				if resf0iter.Expiration.ExpiredObjectDeleteMarker != nil {
					resf0elemf1.SetExpiredObjectDeleteMarker(*resf0iter.Expiration.ExpiredObjectDeleteMarker)
				}
				resf0elem.SetExpiration(resf0elemf1)
			}
			if resf0iter.Filter != nil {
				resf0elemf2 := &svcsdk.LifecycleRuleFilter{}
				if resf0iter.Filter.And != nil {
					resf0elemf2f0 := &svcsdk.LifecycleRuleAndOperator{}
					if resf0iter.Filter.And.ObjectSizeGreaterThan != nil {
						resf0elemf2f0.SetObjectSizeGreaterThan(*resf0iter.Filter.And.ObjectSizeGreaterThan)
					}
					if resf0iter.Filter.And.ObjectSizeLessThan != nil {
						resf0elemf2f0.SetObjectSizeLessThan(*resf0iter.Filter.And.ObjectSizeLessThan)
					}
					if resf0iter.Filter.And.Prefix != nil {
						resf0elemf2f0.SetPrefix(*resf0iter.Filter.And.Prefix)
					}
					if resf0iter.Filter.And.Tags != nil {
						resf0elemf2f0f3 := []*svcsdk.Tag{}
						for _, resf0elemf2f0f3iter := range resf0iter.Filter.And.Tags {
							resf0elemf2f0f3elem := &svcsdk.Tag{}
							if resf0elemf2f0f3iter.Key != nil {
								resf0elemf2f0f3elem.SetKey(*resf0elemf2f0f3iter.Key)
							}
							if resf0elemf2f0f3iter.Value != nil {
								resf0elemf2f0f3elem.SetValue(*resf0elemf2f0f3iter.Value)
							}
							resf0elemf2f0f3 = append(resf0elemf2f0f3, resf0elemf2f0f3elem)
						}
						resf0elemf2f0.SetTags(resf0elemf2f0f3)
					}
					resf0elemf2.SetAnd(resf0elemf2f0)
				}
				if resf0iter.Filter.ObjectSizeGreaterThan != nil {
					resf0elemf2.SetObjectSizeGreaterThan(*resf0iter.Filter.ObjectSizeGreaterThan)
				}
				if resf0iter.Filter.ObjectSizeLessThan != nil {
					resf0elemf2.SetObjectSizeLessThan(*resf0iter.Filter.ObjectSizeLessThan)
				}
				if resf0iter.Filter.Prefix != nil {
					resf0elemf2.SetPrefix(*resf0iter.Filter.Prefix)
				}
				if resf0iter.Filter.Tag != nil {
					resf0elemf2f4 := &svcsdk.Tag{}
					if resf0iter.Filter.Tag.Key != nil {
						resf0elemf2f4.SetKey(*resf0iter.Filter.Tag.Key)
					}
					if resf0iter.Filter.Tag.Value != nil {
						resf0elemf2f4.SetValue(*resf0iter.Filter.Tag.Value)
					}
					resf0elemf2.SetTag(resf0elemf2f4)
				}
				resf0elem.SetFilter(resf0elemf2)
			}
			if resf0iter.ID != nil {
				resf0elem.SetID(*resf0iter.ID)
			}
			if resf0iter.NoncurrentVersionExpiration != nil {
				resf0elemf4 := &svcsdk.NoncurrentVersionExpiration{}
				if resf0iter.NoncurrentVersionExpiration.NewerNoncurrentVersions != nil {
					resf0elemf4.SetNewerNoncurrentVersions(*resf0iter.NoncurrentVersionExpiration.NewerNoncurrentVersions)
				}
				if resf0iter.NoncurrentVersionExpiration.NoncurrentDays != nil {
					resf0elemf4.SetNoncurrentDays(*resf0iter.NoncurrentVersionExpiration.NoncurrentDays)
				}
				resf0elem.SetNoncurrentVersionExpiration(resf0elemf4)
			}
			if resf0iter.NoncurrentVersionTransitions != nil {
				resf0elemf5 := []*svcsdk.NoncurrentVersionTransition{}
				for _, resf0elemf5iter := range resf0iter.NoncurrentVersionTransitions {
					resf0elemf5elem := &svcsdk.NoncurrentVersionTransition{}
					if resf0elemf5iter.NewerNoncurrentVersions != nil {
						resf0elemf5elem.SetNewerNoncurrentVersions(*resf0elemf5iter.NewerNoncurrentVersions)
					}
					if resf0elemf5iter.NoncurrentDays != nil {
						resf0elemf5elem.SetNoncurrentDays(*resf0elemf5iter.NoncurrentDays)
					}
					if resf0elemf5iter.StorageClass != nil {
						resf0elemf5elem.SetStorageClass(*resf0elemf5iter.StorageClass)
					}
					resf0elemf5 = append(resf0elemf5, resf0elemf5elem)
				}
				resf0elem.SetNoncurrentVersionTransitions(resf0elemf5)
			}
			if resf0iter.Prefix != nil {
				resf0elem.SetPrefix(*resf0iter.Prefix)
			}
			if resf0iter.Status != nil {
				resf0elem.SetStatus(*resf0iter.Status)
			}
			if resf0iter.Transitions != nil {
				resf0elemf8 := []*svcsdk.Transition{}
				for _, resf0elemf8iter := range resf0iter.Transitions {
					resf0elemf8elem := &svcsdk.Transition{}
					if resf0elemf8iter.Date != nil {
						resf0elemf8elem.SetDate(resf0elemf8iter.Date.Time)
					}
					if resf0elemf8iter.Days != nil {
						resf0elemf8elem.SetDays(*resf0elemf8iter.Days)
					}
					if resf0elemf8iter.StorageClass != nil {
						resf0elemf8elem.SetStorageClass(*resf0elemf8iter.StorageClass)
					}
					resf0elemf8 = append(resf0elemf8, resf0elemf8elem)
				}
				resf0elem.SetTransitions(resf0elemf8)
			}
			resf0 = append(resf0, resf0elem)
		}
		res.SetRules(resf0)
	}

	return res
}

// setResourceLifecycle sets the `Lifecycle` spec field
// given the output of a `GetBucketLifecycleConfiguration` operation.
func (rm *resourceManager) setResourceLifecycle(
	r *resource,
	resp *svcsdk.GetBucketLifecycleConfigurationOutput,
) *svcapitypes.BucketLifecycleConfiguration {
	res := &svcapitypes.BucketLifecycleConfiguration{}

	if resp.Rules != nil {
		resf0 := []*svcapitypes.LifecycleRule{}
		for _, resf0iter := range resp.Rules {
			resf0elem := &svcapitypes.LifecycleRule{}
			if resf0iter.AbortIncompleteMultipartUpload != nil {
				resf0elemf0 := &svcapitypes.AbortIncompleteMultipartUpload{}
				if resf0iter.AbortIncompleteMultipartUpload.DaysAfterInitiation != nil {
					resf0elemf0.DaysAfterInitiation = resf0iter.AbortIncompleteMultipartUpload.DaysAfterInitiation
				}
				resf0elem.AbortIncompleteMultipartUpload = resf0elemf0
			}
			if resf0iter.Expiration != nil {
				resf0elemf1 := &svcapitypes.LifecycleExpiration{}
				if resf0iter.Expiration.Date != nil {
					resf0elemf1.Date = &metav1.Time{*resf0iter.Expiration.Date}
				}
				if resf0iter.Expiration.Days != nil {
					resf0elemf1.Days = resf0iter.Expiration.Days
				}
				if resf0iter.Expiration.ExpiredObjectDeleteMarker != nil {
					resf0elemf1.ExpiredObjectDeleteMarker = resf0iter.Expiration.ExpiredObjectDeleteMarker
				}
				resf0elem.Expiration = resf0elemf1
			}
			if resf0iter.Filter != nil {
				resf0elemf2 := &svcapitypes.LifecycleRuleFilter{}
				if resf0iter.Filter.And != nil {
					resf0elemf2f0 := &svcapitypes.LifecycleRuleAndOperator{}
					if resf0iter.Filter.And.ObjectSizeGreaterThan != nil {
						resf0elemf2f0.ObjectSizeGreaterThan = resf0iter.Filter.And.ObjectSizeGreaterThan
					}
					if resf0iter.Filter.And.ObjectSizeLessThan != nil {
						resf0elemf2f0.ObjectSizeLessThan = resf0iter.Filter.And.ObjectSizeLessThan
					}
					if resf0iter.Filter.And.Prefix != nil {
						resf0elemf2f0.Prefix = resf0iter.Filter.And.Prefix
					}
					if resf0iter.Filter.And.Tags != nil {
						resf0elemf2f0f3 := []*svcapitypes.Tag{}
						for _, resf0elemf2f0f3iter := range resf0iter.Filter.And.Tags {
							resf0elemf2f0f3elem := &svcapitypes.Tag{}
							if resf0elemf2f0f3iter.Key != nil {
								resf0elemf2f0f3elem.Key = resf0elemf2f0f3iter.Key
							}
							if resf0elemf2f0f3iter.Value != nil {
								resf0elemf2f0f3elem.Value = resf0elemf2f0f3iter.Value
							}
							resf0elemf2f0f3 = append(resf0elemf2f0f3, resf0elemf2f0f3elem)
						}
						resf0elemf2f0.Tags = resf0elemf2f0f3
					}
					resf0elemf2.And = resf0elemf2f0
				}
				if resf0iter.Filter.ObjectSizeGreaterThan != nil {
					resf0elemf2.ObjectSizeGreaterThan = resf0iter.Filter.ObjectSizeGreaterThan
				}
				if resf0iter.Filter.ObjectSizeLessThan != nil {
					resf0elemf2.ObjectSizeLessThan = resf0iter.Filter.ObjectSizeLessThan
				}
				if resf0iter.Filter.Prefix != nil {
					resf0elemf2.Prefix = resf0iter.Filter.Prefix
				}
				if resf0iter.Filter.Tag != nil {
					resf0elemf2f4 := &svcapitypes.Tag{}
					if resf0iter.Filter.Tag.Key != nil {
						resf0elemf2f4.Key = resf0iter.Filter.Tag.Key
					}
					if resf0iter.Filter.Tag.Value != nil {
						resf0elemf2f4.Value = resf0iter.Filter.Tag.Value
					}
					resf0elemf2.Tag = resf0elemf2f4
				}
				resf0elem.Filter = resf0elemf2
			}
			if resf0iter.ID != nil {
				resf0elem.ID = resf0iter.ID
			}
			if resf0iter.NoncurrentVersionExpiration != nil {
				resf0elemf4 := &svcapitypes.NoncurrentVersionExpiration{}
				if resf0iter.NoncurrentVersionExpiration.NewerNoncurrentVersions != nil {
					resf0elemf4.NewerNoncurrentVersions = resf0iter.NoncurrentVersionExpiration.NewerNoncurrentVersions
				}
				if resf0iter.NoncurrentVersionExpiration.NoncurrentDays != nil {
					resf0elemf4.NoncurrentDays = resf0iter.NoncurrentVersionExpiration.NoncurrentDays
				}
				resf0elem.NoncurrentVersionExpiration = resf0elemf4
			}
			if resf0iter.NoncurrentVersionTransitions != nil {
				resf0elemf5 := []*svcapitypes.NoncurrentVersionTransition{}
				for _, resf0elemf5iter := range resf0iter.NoncurrentVersionTransitions {
					resf0elemf5elem := &svcapitypes.NoncurrentVersionTransition{}
					if resf0elemf5iter.NewerNoncurrentVersions != nil {
						resf0elemf5elem.NewerNoncurrentVersions = resf0elemf5iter.NewerNoncurrentVersions
					}
					if resf0elemf5iter.NoncurrentDays != nil {
						resf0elemf5elem.NoncurrentDays = resf0elemf5iter.NoncurrentDays
					}
					if resf0elemf5iter.StorageClass != nil {
						resf0elemf5elem.StorageClass = resf0elemf5iter.StorageClass
					}
					resf0elemf5 = append(resf0elemf5, resf0elemf5elem)
				}
				resf0elem.NoncurrentVersionTransitions = resf0elemf5
			}
			if resf0iter.Prefix != nil {
				resf0elem.Prefix = resf0iter.Prefix
			}
			if resf0iter.Status != nil {
				resf0elem.Status = resf0iter.Status
			}
			if resf0iter.Transitions != nil {
				resf0elemf8 := []*svcapitypes.Transition{}
				for _, resf0elemf8iter := range resf0iter.Transitions {
					resf0elemf8elem := &svcapitypes.Transition{}
					if resf0elemf8iter.Date != nil {
						resf0elemf8elem.Date = &metav1.Time{*resf0elemf8iter.Date}
					}
					if resf0elemf8iter.Days != nil {
						resf0elemf8elem.Days = resf0elemf8iter.Days
					}
					if resf0elemf8iter.StorageClass != nil {
						resf0elemf8elem.StorageClass = resf0elemf8iter.StorageClass
					}
					resf0elemf8 = append(resf0elemf8, resf0elemf8elem)
				}
				resf0elem.Transitions = resf0elemf8
			}
			resf0 = append(resf0, resf0elem)
		}
		res.Rules = resf0
	}

	return res
}

// newBucketLoggingStatus returns a BucketLoggingStatus object
// with each the field set by the resource's corresponding spec field.
func (rm *resourceManager) newBucketLoggingStatus(
	r *resource,
) *svcsdk.BucketLoggingStatus {
	res := &svcsdk.BucketLoggingStatus{}

	if r.ko.Spec.Logging.LoggingEnabled != nil {
		resf0 := &svcsdk.LoggingEnabled{}
		if r.ko.Spec.Logging.LoggingEnabled.TargetBucket != nil {
			resf0.SetTargetBucket(*r.ko.Spec.Logging.LoggingEnabled.TargetBucket)
		}
		if r.ko.Spec.Logging.LoggingEnabled.TargetGrants != nil {
			resf0f1 := []*svcsdk.TargetGrant{}
			for _, resf0f1iter := range r.ko.Spec.Logging.LoggingEnabled.TargetGrants {
				resf0f1elem := &svcsdk.TargetGrant{}
				if resf0f1iter.Grantee != nil {
					resf0f1elemf0 := &svcsdk.Grantee{}
					if resf0f1iter.Grantee.DisplayName != nil {
						resf0f1elemf0.SetDisplayName(*resf0f1iter.Grantee.DisplayName)
					}
					if resf0f1iter.Grantee.EmailAddress != nil {
						resf0f1elemf0.SetEmailAddress(*resf0f1iter.Grantee.EmailAddress)
					}
					if resf0f1iter.Grantee.ID != nil {
						resf0f1elemf0.SetID(*resf0f1iter.Grantee.ID)
					}
					if resf0f1iter.Grantee.Type != nil {
						resf0f1elemf0.SetType(*resf0f1iter.Grantee.Type)
					}
					if resf0f1iter.Grantee.URI != nil {
						resf0f1elemf0.SetURI(*resf0f1iter.Grantee.URI)
					}
					resf0f1elem.SetGrantee(resf0f1elemf0)
				}
				if resf0f1iter.Permission != nil {
					resf0f1elem.SetPermission(*resf0f1iter.Permission)
				}
				resf0f1 = append(resf0f1, resf0f1elem)
			}
			resf0.SetTargetGrants(resf0f1)
		}
		if r.ko.Spec.Logging.LoggingEnabled.TargetPrefix != nil {
			resf0.SetTargetPrefix(*r.ko.Spec.Logging.LoggingEnabled.TargetPrefix)
		}
		res.SetLoggingEnabled(resf0)
	}

	return res
}

// setResourceLogging sets the `Logging` spec field
// given the output of a `GetBucketLogging` operation.
func (rm *resourceManager) setResourceLogging(
	r *resource,
	resp *svcsdk.GetBucketLoggingOutput,
) *svcapitypes.BucketLoggingStatus {
	res := &svcapitypes.BucketLoggingStatus{}

	if resp.LoggingEnabled != nil {
		resf0 := &svcapitypes.LoggingEnabled{}
		if resp.LoggingEnabled.TargetBucket != nil {
			resf0.TargetBucket = resp.LoggingEnabled.TargetBucket
		}
		if resp.LoggingEnabled.TargetGrants != nil {
			resf0f1 := []*svcapitypes.TargetGrant{}
			for _, resf0f1iter := range resp.LoggingEnabled.TargetGrants {
				resf0f1elem := &svcapitypes.TargetGrant{}
				if resf0f1iter.Grantee != nil {
					resf0f1elemf0 := &svcapitypes.Grantee{}
					if resf0f1iter.Grantee.DisplayName != nil {
						resf0f1elemf0.DisplayName = resf0f1iter.Grantee.DisplayName
					}
					if resf0f1iter.Grantee.EmailAddress != nil {
						resf0f1elemf0.EmailAddress = resf0f1iter.Grantee.EmailAddress
					}
					if resf0f1iter.Grantee.ID != nil {
						resf0f1elemf0.ID = resf0f1iter.Grantee.ID
					}
					if resf0f1iter.Grantee.Type != nil {
						resf0f1elemf0.Type = resf0f1iter.Grantee.Type
					}
					if resf0f1iter.Grantee.URI != nil {
						resf0f1elemf0.URI = resf0f1iter.Grantee.URI
					}
					resf0f1elem.Grantee = resf0f1elemf0
				}
				if resf0f1iter.Permission != nil {
					resf0f1elem.Permission = resf0f1iter.Permission
				}
				resf0f1 = append(resf0f1, resf0f1elem)
			}
			resf0.TargetGrants = resf0f1
		}
		if resp.LoggingEnabled.TargetPrefix != nil {
			resf0.TargetPrefix = resp.LoggingEnabled.TargetPrefix
		}
		res.LoggingEnabled = resf0
	}

	return res
}

// newMetricsConfiguration returns a MetricsConfiguration object
// with each the field set by the corresponding configuration's fields.
func (rm *resourceManager) newMetricsConfiguration(
	c *svcapitypes.MetricsConfiguration,
) *svcsdk.MetricsConfiguration {
	res := &svcsdk.MetricsConfiguration{}

	if c.Filter != nil {
		resf0 := &svcsdk.MetricsFilter{}
		if c.Filter.AccessPointARN != nil {
			resf0.SetAccessPointArn(*c.Filter.AccessPointARN)
		}
		if c.Filter.And != nil {
			resf0f1 := &svcsdk.MetricsAndOperator{}
			if c.Filter.And.AccessPointARN != nil {
				resf0f1.SetAccessPointArn(*c.Filter.And.AccessPointARN)
			}
			if c.Filter.And.Prefix != nil {
				resf0f1.SetPrefix(*c.Filter.And.Prefix)
			}
			if c.Filter.And.Tags != nil {
				resf0f1f2 := []*svcsdk.Tag{}
				for _, resf0f1f2iter := range c.Filter.And.Tags {
					resf0f1f2elem := &svcsdk.Tag{}
					if resf0f1f2iter.Key != nil {
						resf0f1f2elem.SetKey(*resf0f1f2iter.Key)
					}
					if resf0f1f2iter.Value != nil {
						resf0f1f2elem.SetValue(*resf0f1f2iter.Value)
					}
					resf0f1f2 = append(resf0f1f2, resf0f1f2elem)
				}
				resf0f1.SetTags(resf0f1f2)
			}
			resf0.SetAnd(resf0f1)
		}
		if c.Filter.Prefix != nil {
			resf0.SetPrefix(*c.Filter.Prefix)
		}
		if c.Filter.Tag != nil {
			resf0f3 := &svcsdk.Tag{}
			if c.Filter.Tag.Key != nil {
				resf0f3.SetKey(*c.Filter.Tag.Key)
			}
			if c.Filter.Tag.Value != nil {
				resf0f3.SetValue(*c.Filter.Tag.Value)
			}
			resf0.SetTag(resf0f3)
		}
		res.SetFilter(resf0)
	}
	if c.ID != nil {
		res.SetId(*c.ID)
	}

	return res
}

// setMetricsConfiguration sets a resource MetricsConfiguration type
// given the SDK type.
func (rm *resourceManager) setResourceMetricsConfiguration(
	r *resource,
	resp *svcsdk.MetricsConfiguration,
) *svcapitypes.MetricsConfiguration {
	res := &svcapitypes.MetricsConfiguration{}

	if resp.Filter != nil {
		resf0 := &svcapitypes.MetricsFilter{}
		if resp.Filter.AccessPointArn != nil {
			resf0.AccessPointARN = resp.Filter.AccessPointArn
		}
		if resp.Filter.And != nil {
			resf0f1 := &svcapitypes.MetricsAndOperator{}
			if resp.Filter.And.AccessPointArn != nil {
				resf0f1.AccessPointARN = resp.Filter.And.AccessPointArn
			}
			if resp.Filter.And.Prefix != nil {
				resf0f1.Prefix = resp.Filter.And.Prefix
			}
			if resp.Filter.And.Tags != nil {
				resf0f1f2 := []*svcapitypes.Tag{}
				for _, resf0f1f2iter := range resp.Filter.And.Tags {
					resf0f1f2elem := &svcapitypes.Tag{}
					if resf0f1f2iter.Key != nil {
						resf0f1f2elem.Key = resf0f1f2iter.Key
					}
					if resf0f1f2iter.Value != nil {
						resf0f1f2elem.Value = resf0f1f2iter.Value
					}
					resf0f1f2 = append(resf0f1f2, resf0f1f2elem)
				}
				resf0f1.Tags = resf0f1f2
			}
			resf0.And = resf0f1
		}
		if resp.Filter.Prefix != nil {
			resf0.Prefix = resp.Filter.Prefix
		}
		if resp.Filter.Tag != nil {
			resf0f3 := &svcapitypes.Tag{}
			if resp.Filter.Tag.Key != nil {
				resf0f3.Key = resp.Filter.Tag.Key
			}
			if resp.Filter.Tag.Value != nil {
				resf0f3.Value = resp.Filter.Tag.Value
			}
			resf0.Tag = resf0f3
		}
		res.Filter = resf0
	}
	if resp.Id != nil {
		res.ID = resp.Id
	}

	return res
}

func compareMetricsConfiguration(
	a *svcapitypes.MetricsConfiguration,
	b *svcapitypes.MetricsConfiguration,
) *ackcompare.Delta {
	delta := ackcompare.NewDelta()
	if ackcompare.HasNilDifference(a.Filter, b.Filter) {
		delta.Add("MetricsConfiguration.Filter", a.Filter, b.Filter)
	} else if a.Filter != nil && b.Filter != nil {
		if ackcompare.HasNilDifference(a.Filter.AccessPointARN, b.Filter.AccessPointARN) {
			delta.Add("MetricsConfiguration.Filter.AccessPointARN", a.Filter.AccessPointARN, b.Filter.AccessPointARN)
		} else if a.Filter.AccessPointARN != nil && b.Filter.AccessPointARN != nil {
			if *a.Filter.AccessPointARN != *b.Filter.AccessPointARN {
				delta.Add("MetricsConfiguration.Filter.AccessPointARN", a.Filter.AccessPointARN, b.Filter.AccessPointARN)
			}
		}
		if ackcompare.HasNilDifference(a.Filter.And, b.Filter.And) {
			delta.Add("MetricsConfiguration.Filter.And", a.Filter.And, b.Filter.And)
		} else if a.Filter.And != nil && b.Filter.And != nil {
			if ackcompare.HasNilDifference(a.Filter.And.AccessPointARN, b.Filter.And.AccessPointARN) {
				delta.Add("MetricsConfiguration.Filter.And.AccessPointARN", a.Filter.And.AccessPointARN, b.Filter.And.AccessPointARN)
			} else if a.Filter.And.AccessPointARN != nil && b.Filter.And.AccessPointARN != nil {
				if *a.Filter.And.AccessPointARN != *b.Filter.And.AccessPointARN {
					delta.Add("MetricsConfiguration.Filter.And.AccessPointARN", a.Filter.And.AccessPointARN, b.Filter.And.AccessPointARN)
				}
			}
			if ackcompare.HasNilDifference(a.Filter.And.Prefix, b.Filter.And.Prefix) {
				delta.Add("MetricsConfiguration.Filter.And.Prefix", a.Filter.And.Prefix, b.Filter.And.Prefix)
			} else if a.Filter.And.Prefix != nil && b.Filter.And.Prefix != nil {
				if *a.Filter.And.Prefix != *b.Filter.And.Prefix {
					delta.Add("MetricsConfiguration.Filter.And.Prefix", a.Filter.And.Prefix, b.Filter.And.Prefix)
				}
			}
			if len(a.Filter.And.Tags) != len(b.Filter.And.Tags) {
				delta.Add("MetricsConfiguration.Filter.And.Tags", a.Filter.And.Tags, b.Filter.And.Tags)
			} else if len(a.Filter.And.Tags) > 0 {
				if !reflect.DeepEqual(a.Filter.And.Tags, b.Filter.And.Tags) {
					delta.Add("MetricsConfiguration.Filter.And.Tags", a.Filter.And.Tags, b.Filter.And.Tags)
				}
			}
		}
		if ackcompare.HasNilDifference(a.Filter.Prefix, b.Filter.Prefix) {
			delta.Add("MetricsConfiguration.Filter.Prefix", a.Filter.Prefix, b.Filter.Prefix)
		} else if a.Filter.Prefix != nil && b.Filter.Prefix != nil {
			if *a.Filter.Prefix != *b.Filter.Prefix {
				delta.Add("MetricsConfiguration.Filter.Prefix", a.Filter.Prefix, b.Filter.Prefix)
			}
		}
		if ackcompare.HasNilDifference(a.Filter.Tag, b.Filter.Tag) {
			delta.Add("MetricsConfiguration.Filter.Tag", a.Filter.Tag, b.Filter.Tag)
		} else if a.Filter.Tag != nil && b.Filter.Tag != nil {
			if ackcompare.HasNilDifference(a.Filter.Tag.Key, b.Filter.Tag.Key) {
				delta.Add("MetricsConfiguration.Filter.Tag.Key", a.Filter.Tag.Key, b.Filter.Tag.Key)
			} else if a.Filter.Tag.Key != nil && b.Filter.Tag.Key != nil {
				if *a.Filter.Tag.Key != *b.Filter.Tag.Key {
					delta.Add("MetricsConfiguration.Filter.Tag.Key", a.Filter.Tag.Key, b.Filter.Tag.Key)
				}
			}
			if ackcompare.HasNilDifference(a.Filter.Tag.Value, b.Filter.Tag.Value) {
				delta.Add("MetricsConfiguration.Filter.Tag.Value", a.Filter.Tag.Value, b.Filter.Tag.Value)
			} else if a.Filter.Tag.Value != nil && b.Filter.Tag.Value != nil {
				if *a.Filter.Tag.Value != *b.Filter.Tag.Value {
					delta.Add("MetricsConfiguration.Filter.Tag.Value", a.Filter.Tag.Value, b.Filter.Tag.Value)
				}
			}
		}
	}
	if ackcompare.HasNilDifference(a.ID, b.ID) {
		delta.Add("MetricsConfiguration.ID", a.ID, b.ID)
	} else if a.ID != nil && b.ID != nil {
		if *a.ID != *b.ID {
			delta.Add("MetricsConfiguration.ID", a.ID, b.ID)
		}
	}

	return delta
}

// getMetricsConfigurationAction returns the determined action for a given
// configuration object, depending on the desired and latest values
func getMetricsConfigurationAction(
	c *svcapitypes.MetricsConfiguration,
	latest *resource,
) ConfigurationAction {
	action := ConfigurationActionPut
	if latest != nil {
		for _, l := range latest.ko.Spec.Metrics {
			if *l.ID != *c.ID {
				continue
			}

			// Don't perform any action if they are identical
			delta := compareMetricsConfiguration(l, c)
			if len(delta.Differences) > 0 {
				action = ConfigurationActionUpdate
			} else {
				action = ConfigurationActionNone
			}
			break
		}
	}
	return action
}

func (rm *resourceManager) newListBucketMetricsPayload(
	r *resource,
) *svcsdk.ListBucketMetricsConfigurationsInput {
	res := &svcsdk.ListBucketMetricsConfigurationsInput{}
	res.SetBucket(*r.ko.Spec.Name)
	return res
}

func (rm *resourceManager) newPutBucketMetricsPayload(
	r *resource,
	c svcapitypes.MetricsConfiguration,
) *svcsdk.PutBucketMetricsConfigurationInput {
	res := &svcsdk.PutBucketMetricsConfigurationInput{}
	res.SetBucket(*r.ko.Spec.Name)
	res.SetId(*c.ID)
	res.SetMetricsConfiguration(rm.newMetricsConfiguration(&c))

	return res
}

func (rm *resourceManager) newDeleteBucketMetricsPayload(
	r *resource,
	c svcapitypes.MetricsConfiguration,
) *svcsdk.DeleteBucketMetricsConfigurationInput {
	res := &svcsdk.DeleteBucketMetricsConfigurationInput{}
	res.SetBucket(*r.ko.Spec.Name)
	res.SetId(*c.ID)

	return res
}

func (rm *resourceManager) deleteMetricsConfiguration(
	ctx context.Context,
	r *resource,
	c svcapitypes.MetricsConfiguration,
) (err error) {
	rlog := ackrtlog.FromContext(ctx)
	exit := rlog.Trace("rm.deleteMetricsConfiguration")
	defer exit(err)

	input := rm.newDeleteBucketMetricsPayload(r, c)
	_, err = rm.sdkapi.DeleteBucketMetricsConfigurationWithContext(ctx, input)
	rm.metrics.RecordAPICall("DELETE", "DeleteBucketMetricsConfiguration", err)
	return err
}

func (rm *resourceManager) putMetricsConfiguration(
	ctx context.Context,
	r *resource,
	c svcapitypes.MetricsConfiguration,
) (err error) {
	rlog := ackrtlog.FromContext(ctx)
	exit := rlog.Trace("rm.putMetricsConfiguration")
	defer exit(err)

	input := rm.newPutBucketMetricsPayload(r, c)
	_, err = rm.sdkapi.PutBucketMetricsConfigurationWithContext(ctx, input)
	rm.metrics.RecordAPICall("UPDATE", "PutBucketMetricsConfiguration", err)
	return err
}

func (rm *resourceManager) syncMetrics(
	ctx context.Context,
	desired *resource,
	latest *resource,
) (err error) {
	rlog := ackrtlog.FromContext(ctx)
	exit := rlog.Trace("rm.syncMetrics")
	defer exit(err)

	for _, c := range desired.ko.Spec.Metrics {
		action := getMetricsConfigurationAction(c, latest)

		switch action {
		case ConfigurationActionUpdate:
			fallthrough
		case ConfigurationActionPut:
			if err = rm.putMetricsConfiguration(ctx, desired, *c); err != nil {
				return err
			}
		default:
		}
	}

	if latest != nil {
		// Find any configurations that are in the latest but not in desired
		for _, l := range latest.ko.Spec.Metrics {
			exists := false
			for _, c := range desired.ko.Spec.Metrics {
				if *c.ID != *l.ID {
					continue
				}
				exists = true
				break
			}

			if !exists {
				if err = rm.deleteMetricsConfiguration(ctx, desired, *l); err != nil {
					return err
				}
			}
		}
	}

	return nil
}

// newNotificationConfiguration returns a NotificationConfiguration object
// with each the field set by the resource's corresponding spec field.
func (rm *resourceManager) newNotificationConfiguration(
	r *resource,
) *svcsdk.NotificationConfiguration {
	res := &svcsdk.NotificationConfiguration{}

	if r.ko.Spec.Notification.LambdaFunctionConfigurations != nil {
		resf0 := []*svcsdk.LambdaFunctionConfiguration{}
		for _, resf0iter := range r.ko.Spec.Notification.LambdaFunctionConfigurations {
			resf0elem := &svcsdk.LambdaFunctionConfiguration{}
			if resf0iter.Events != nil {
				resf0elemf0 := []*string{}
				for _, resf0elemf0iter := range resf0iter.Events {
					var resf0elemf0elem string
					resf0elemf0elem = *resf0elemf0iter
					resf0elemf0 = append(resf0elemf0, &resf0elemf0elem)
				}
				resf0elem.SetEvents(resf0elemf0)
			}
			if resf0iter.Filter != nil {
				resf0elemf1 := &svcsdk.NotificationConfigurationFilter{}
				if resf0iter.Filter.Key != nil {
					resf0elemf1f0 := &svcsdk.KeyFilter{}
					if resf0iter.Filter.Key.FilterRules != nil {
						resf0elemf1f0f0 := []*svcsdk.FilterRule{}
						for _, resf0elemf1f0f0iter := range resf0iter.Filter.Key.FilterRules {
							resf0elemf1f0f0elem := &svcsdk.FilterRule{}
							if resf0elemf1f0f0iter.Name != nil {
								resf0elemf1f0f0elem.SetName(*resf0elemf1f0f0iter.Name)
							}
							if resf0elemf1f0f0iter.Value != nil {
								resf0elemf1f0f0elem.SetValue(*resf0elemf1f0f0iter.Value)
							}
							resf0elemf1f0f0 = append(resf0elemf1f0f0, resf0elemf1f0f0elem)
						}
						resf0elemf1f0.SetFilterRules(resf0elemf1f0f0)
					}
					resf0elemf1.SetKey(resf0elemf1f0)
				}
				resf0elem.SetFilter(resf0elemf1)
			}
			if resf0iter.ID != nil {
				resf0elem.SetId(*resf0iter.ID)
			}
			if resf0iter.LambdaFunctionARN != nil {
				resf0elem.SetLambdaFunctionArn(*resf0iter.LambdaFunctionARN)
			}
			resf0 = append(resf0, resf0elem)
		}
		res.SetLambdaFunctionConfigurations(resf0)
	}
	if r.ko.Spec.Notification.QueueConfigurations != nil {
		resf1 := []*svcsdk.QueueConfiguration{}
		for _, resf1iter := range r.ko.Spec.Notification.QueueConfigurations {
			resf1elem := &svcsdk.QueueConfiguration{}
			if resf1iter.Events != nil {
				resf1elemf0 := []*string{}
				for _, resf1elemf0iter := range resf1iter.Events {
					var resf1elemf0elem string
					resf1elemf0elem = *resf1elemf0iter
					resf1elemf0 = append(resf1elemf0, &resf1elemf0elem)
				}
				resf1elem.SetEvents(resf1elemf0)
			}
			if resf1iter.Filter != nil {
				resf1elemf1 := &svcsdk.NotificationConfigurationFilter{}
				if resf1iter.Filter.Key != nil {
					resf1elemf1f0 := &svcsdk.KeyFilter{}
					if resf1iter.Filter.Key.FilterRules != nil {
						resf1elemf1f0f0 := []*svcsdk.FilterRule{}
						for _, resf1elemf1f0f0iter := range resf1iter.Filter.Key.FilterRules {
							resf1elemf1f0f0elem := &svcsdk.FilterRule{}
							if resf1elemf1f0f0iter.Name != nil {
								resf1elemf1f0f0elem.SetName(*resf1elemf1f0f0iter.Name)
							}
							if resf1elemf1f0f0iter.Value != nil {
								resf1elemf1f0f0elem.SetValue(*resf1elemf1f0f0iter.Value)
							}
							resf1elemf1f0f0 = append(resf1elemf1f0f0, resf1elemf1f0f0elem)
						}
						resf1elemf1f0.SetFilterRules(resf1elemf1f0f0)
					}
					resf1elemf1.SetKey(resf1elemf1f0)
				}
				resf1elem.SetFilter(resf1elemf1)
			}
			if resf1iter.ID != nil {
				resf1elem.SetId(*resf1iter.ID)
			}
			if resf1iter.QueueARN != nil {
				resf1elem.SetQueueArn(*resf1iter.QueueARN)
			}
			resf1 = append(resf1, resf1elem)
		}
		res.SetQueueConfigurations(resf1)
	}
	if r.ko.Spec.Notification.TopicConfigurations != nil {
		resf2 := []*svcsdk.TopicConfiguration{}
		for _, resf2iter := range r.ko.Spec.Notification.TopicConfigurations {
			resf2elem := &svcsdk.TopicConfiguration{}
			if resf2iter.Events != nil {
				resf2elemf0 := []*string{}
				for _, resf2elemf0iter := range resf2iter.Events {
					var resf2elemf0elem string
					resf2elemf0elem = *resf2elemf0iter
					resf2elemf0 = append(resf2elemf0, &resf2elemf0elem)
				}
				resf2elem.SetEvents(resf2elemf0)
			}
			if resf2iter.Filter != nil {
				resf2elemf1 := &svcsdk.NotificationConfigurationFilter{}
				if resf2iter.Filter.Key != nil {
					resf2elemf1f0 := &svcsdk.KeyFilter{}
					if resf2iter.Filter.Key.FilterRules != nil {
						resf2elemf1f0f0 := []*svcsdk.FilterRule{}
						for _, resf2elemf1f0f0iter := range resf2iter.Filter.Key.FilterRules {
							resf2elemf1f0f0elem := &svcsdk.FilterRule{}
							if resf2elemf1f0f0iter.Name != nil {
								resf2elemf1f0f0elem.SetName(*resf2elemf1f0f0iter.Name)
							}
							if resf2elemf1f0f0iter.Value != nil {
								resf2elemf1f0f0elem.SetValue(*resf2elemf1f0f0iter.Value)
							}
							resf2elemf1f0f0 = append(resf2elemf1f0f0, resf2elemf1f0f0elem)
						}
						resf2elemf1f0.SetFilterRules(resf2elemf1f0f0)
					}
					resf2elemf1.SetKey(resf2elemf1f0)
				}
				resf2elem.SetFilter(resf2elemf1)
			}
			if resf2iter.ID != nil {
				resf2elem.SetId(*resf2iter.ID)
			}
			if resf2iter.TopicARN != nil {
				resf2elem.SetTopicArn(*resf2iter.TopicARN)
			}
			resf2 = append(resf2, resf2elem)
		}
		res.SetTopicConfigurations(resf2)
	}

	return res
}

// setResourceNotification sets the `Notification` spec field
// given the output of a `GetBucketNotificationConfiguration` operation.
func (rm *resourceManager) setResourceNotification(
	r *resource,
	resp *svcsdk.NotificationConfiguration,
) *svcapitypes.NotificationConfiguration {
	res := &svcapitypes.NotificationConfiguration{}

	if resp.LambdaFunctionConfigurations != nil {
		resf0 := []*svcapitypes.LambdaFunctionConfiguration{}
		for _, resf0iter := range resp.LambdaFunctionConfigurations {
			resf0elem := &svcapitypes.LambdaFunctionConfiguration{}
			if resf0iter.Events != nil {
				resf0elemf0 := []*string{}
				for _, resf0elemf0iter := range resf0iter.Events {
					var resf0elemf0elem string
					resf0elemf0elem = *resf0elemf0iter
					resf0elemf0 = append(resf0elemf0, &resf0elemf0elem)
				}
				resf0elem.Events = resf0elemf0
			}
			if resf0iter.Filter != nil {
				resf0elemf1 := &svcapitypes.NotificationConfigurationFilter{}
				if resf0iter.Filter.Key != nil {
					resf0elemf1f0 := &svcapitypes.KeyFilter{}
					if resf0iter.Filter.Key.FilterRules != nil {
						resf0elemf1f0f0 := []*svcapitypes.FilterRule{}
						for _, resf0elemf1f0f0iter := range resf0iter.Filter.Key.FilterRules {
							resf0elemf1f0f0elem := &svcapitypes.FilterRule{}
							if resf0elemf1f0f0iter.Name != nil {
								resf0elemf1f0f0elem.Name = resf0elemf1f0f0iter.Name
							}
							if resf0elemf1f0f0iter.Value != nil {
								resf0elemf1f0f0elem.Value = resf0elemf1f0f0iter.Value
							}
							resf0elemf1f0f0 = append(resf0elemf1f0f0, resf0elemf1f0f0elem)
						}
						resf0elemf1f0.FilterRules = resf0elemf1f0f0
					}
					resf0elemf1.Key = resf0elemf1f0
				}
				resf0elem.Filter = resf0elemf1
			}
			if resf0iter.Id != nil {
				resf0elem.ID = resf0iter.Id
			}
			if resf0iter.LambdaFunctionArn != nil {
				resf0elem.LambdaFunctionARN = resf0iter.LambdaFunctionArn
			}
			resf0 = append(resf0, resf0elem)
		}
		res.LambdaFunctionConfigurations = resf0
	}
	if resp.QueueConfigurations != nil {
		resf1 := []*svcapitypes.QueueConfiguration{}
		for _, resf1iter := range resp.QueueConfigurations {
			resf1elem := &svcapitypes.QueueConfiguration{}
			if resf1iter.Events != nil {
				resf1elemf0 := []*string{}
				for _, resf1elemf0iter := range resf1iter.Events {
					var resf1elemf0elem string
					resf1elemf0elem = *resf1elemf0iter
					resf1elemf0 = append(resf1elemf0, &resf1elemf0elem)
				}
				resf1elem.Events = resf1elemf0
			}
			if resf1iter.Filter != nil {
				resf1elemf1 := &svcapitypes.NotificationConfigurationFilter{}
				if resf1iter.Filter.Key != nil {
					resf1elemf1f0 := &svcapitypes.KeyFilter{}
					if resf1iter.Filter.Key.FilterRules != nil {
						resf1elemf1f0f0 := []*svcapitypes.FilterRule{}
						for _, resf1elemf1f0f0iter := range resf1iter.Filter.Key.FilterRules {
							resf1elemf1f0f0elem := &svcapitypes.FilterRule{}
							if resf1elemf1f0f0iter.Name != nil {
								resf1elemf1f0f0elem.Name = resf1elemf1f0f0iter.Name
							}
							if resf1elemf1f0f0iter.Value != nil {
								resf1elemf1f0f0elem.Value = resf1elemf1f0f0iter.Value
							}
							resf1elemf1f0f0 = append(resf1elemf1f0f0, resf1elemf1f0f0elem)
						}
						resf1elemf1f0.FilterRules = resf1elemf1f0f0
					}
					resf1elemf1.Key = resf1elemf1f0
				}
				resf1elem.Filter = resf1elemf1
			}
			if resf1iter.Id != nil {
				resf1elem.ID = resf1iter.Id
			}
			if resf1iter.QueueArn != nil {
				resf1elem.QueueARN = resf1iter.QueueArn
			}
			resf1 = append(resf1, resf1elem)
		}
		res.QueueConfigurations = resf1
	}
	if resp.TopicConfigurations != nil {
		resf2 := []*svcapitypes.TopicConfiguration{}
		for _, resf2iter := range resp.TopicConfigurations {
			resf2elem := &svcapitypes.TopicConfiguration{}
			if resf2iter.Events != nil {
				resf2elemf0 := []*string{}
				for _, resf2elemf0iter := range resf2iter.Events {
					var resf2elemf0elem string
					resf2elemf0elem = *resf2elemf0iter
					resf2elemf0 = append(resf2elemf0, &resf2elemf0elem)
				}
				resf2elem.Events = resf2elemf0
			}
			if resf2iter.Filter != nil {
				resf2elemf1 := &svcapitypes.NotificationConfigurationFilter{}
				if resf2iter.Filter.Key != nil {
					resf2elemf1f0 := &svcapitypes.KeyFilter{}
					if resf2iter.Filter.Key.FilterRules != nil {
						resf2elemf1f0f0 := []*svcapitypes.FilterRule{}
						for _, resf2elemf1f0f0iter := range resf2iter.Filter.Key.FilterRules {
							resf2elemf1f0f0elem := &svcapitypes.FilterRule{}
							if resf2elemf1f0f0iter.Name != nil {
								resf2elemf1f0f0elem.Name = resf2elemf1f0f0iter.Name
							}
							if resf2elemf1f0f0iter.Value != nil {
								resf2elemf1f0f0elem.Value = resf2elemf1f0f0iter.Value
							}
							resf2elemf1f0f0 = append(resf2elemf1f0f0, resf2elemf1f0f0elem)
						}
						resf2elemf1f0.FilterRules = resf2elemf1f0f0
					}
					resf2elemf1.Key = resf2elemf1f0
				}
				resf2elem.Filter = resf2elemf1
			}
			if resf2iter.Id != nil {
				resf2elem.ID = resf2iter.Id
			}
			if resf2iter.TopicArn != nil {
				resf2elem.TopicARN = resf2iter.TopicArn
			}
			resf2 = append(resf2, resf2elem)
		}
		res.TopicConfigurations = resf2
	}

	return res
}

// newOwnershipControls returns a OwnershipControls object
// with each the field set by the resource's corresponding spec field.
func (rm *resourceManager) newOwnershipControls(
	r *resource,
) *svcsdk.OwnershipControls {
	res := &svcsdk.OwnershipControls{}

	if r.ko.Spec.OwnershipControls.Rules != nil {
		resf0 := []*svcsdk.OwnershipControlsRule{}
		for _, resf0iter := range r.ko.Spec.OwnershipControls.Rules {
			resf0elem := &svcsdk.OwnershipControlsRule{}
			if resf0iter.ObjectOwnership != nil {
				resf0elem.SetObjectOwnership(*resf0iter.ObjectOwnership)
			}
			resf0 = append(resf0, resf0elem)
		}
		res.SetRules(resf0)
	}

	return res
}

// setResourceOwnershipControls sets the `OwnershipControls` spec field
// given the output of a `GetBucketOwnershipControls` operation.
func (rm *resourceManager) setResourceOwnershipControls(
	r *resource,
	resp *svcsdk.GetBucketOwnershipControlsOutput,
) *svcapitypes.OwnershipControls {
	res := &svcapitypes.OwnershipControls{}

	if resp.OwnershipControls.Rules != nil {
		resf0 := []*svcapitypes.OwnershipControlsRule{}
		for _, resf0iter := range resp.OwnershipControls.Rules {
			resf0elem := &svcapitypes.OwnershipControlsRule{}
			if resf0iter.ObjectOwnership != nil {
				resf0elem.ObjectOwnership = resf0iter.ObjectOwnership
			}
			resf0 = append(resf0, resf0elem)
		}
		res.Rules = resf0
	}

	return res
}

// newPublicAccessBlockConfiguration returns a PublicAccessBlockConfiguration object
// with each the field set by the resource's corresponding spec field.
func (rm *resourceManager) newPublicAccessBlockConfiguration(
	r *resource,
) *svcsdk.PublicAccessBlockConfiguration {
	res := &svcsdk.PublicAccessBlockConfiguration{}

	if r.ko.Spec.PublicAccessBlock.BlockPublicACLs != nil {
		res.SetBlockPublicAcls(*r.ko.Spec.PublicAccessBlock.BlockPublicACLs)
	}
	if r.ko.Spec.PublicAccessBlock.BlockPublicPolicy != nil {
		res.SetBlockPublicPolicy(*r.ko.Spec.PublicAccessBlock.BlockPublicPolicy)
	}
	if r.ko.Spec.PublicAccessBlock.IgnorePublicACLs != nil {
		res.SetIgnorePublicAcls(*r.ko.Spec.PublicAccessBlock.IgnorePublicACLs)
	}
	if r.ko.Spec.PublicAccessBlock.RestrictPublicBuckets != nil {
		res.SetRestrictPublicBuckets(*r.ko.Spec.PublicAccessBlock.RestrictPublicBuckets)
	}

	return res
}

// setResourcePublicAccessBlock sets the `PublicAccessBlock` spec field
// given the output of a `GetPublicAccessBlock` operation.
func (rm *resourceManager) setResourcePublicAccessBlock(
	r *resource,
	resp *svcsdk.GetPublicAccessBlockOutput,
) *svcapitypes.PublicAccessBlockConfiguration {
	res := &svcapitypes.PublicAccessBlockConfiguration{}

	if resp.PublicAccessBlockConfiguration.BlockPublicAcls != nil {
		res.BlockPublicACLs = resp.PublicAccessBlockConfiguration.BlockPublicAcls
	}
	if resp.PublicAccessBlockConfiguration.BlockPublicPolicy != nil {
		res.BlockPublicPolicy = resp.PublicAccessBlockConfiguration.BlockPublicPolicy
	}
	if resp.PublicAccessBlockConfiguration.IgnorePublicAcls != nil {
		res.IgnorePublicACLs = resp.PublicAccessBlockConfiguration.IgnorePublicAcls
	}
	if resp.PublicAccessBlockConfiguration.RestrictPublicBuckets != nil {
		res.RestrictPublicBuckets = resp.PublicAccessBlockConfiguration.RestrictPublicBuckets
	}

	return res
}

// newReplicationConfiguration returns a ReplicationConfiguration object
// with each the field set by the resource's corresponding spec field.
func (rm *resourceManager) newReplicationConfiguration(
	r *resource,
) *svcsdk.ReplicationConfiguration {
	res := &svcsdk.ReplicationConfiguration{}

	if r.ko.Spec.Replication.Role != nil {
		res.SetRole(*r.ko.Spec.Replication.Role)
	}
	if r.ko.Spec.Replication.Rules != nil {
		resf1 := []*svcsdk.ReplicationRule{}
		for _, resf1iter := range r.ko.Spec.Replication.Rules {
			resf1elem := &svcsdk.ReplicationRule{}
			if resf1iter.DeleteMarkerReplication != nil {
				resf1elemf0 := &svcsdk.DeleteMarkerReplication{}
				if resf1iter.DeleteMarkerReplication.Status != nil {
					resf1elemf0.SetStatus(*resf1iter.DeleteMarkerReplication.Status)
				}
				resf1elem.SetDeleteMarkerReplication(resf1elemf0)
			}
			if resf1iter.Destination != nil {
				resf1elemf1 := &svcsdk.Destination{}
				if resf1iter.Destination.AccessControlTranslation != nil {
					resf1elemf1f0 := &svcsdk.AccessControlTranslation{}
					if resf1iter.Destination.AccessControlTranslation.Owner != nil {
						resf1elemf1f0.SetOwner(*resf1iter.Destination.AccessControlTranslation.Owner)
					}
					resf1elemf1.SetAccessControlTranslation(resf1elemf1f0)
				}
				if resf1iter.Destination.Account != nil {
					resf1elemf1.SetAccount(*resf1iter.Destination.Account)
				}
				if resf1iter.Destination.Bucket != nil {
					resf1elemf1.SetBucket(*resf1iter.Destination.Bucket)
				}
				if resf1iter.Destination.EncryptionConfiguration != nil {
					resf1elemf1f3 := &svcsdk.EncryptionConfiguration{}
					if resf1iter.Destination.EncryptionConfiguration.ReplicaKMSKeyID != nil {
						resf1elemf1f3.SetReplicaKmsKeyID(*resf1iter.Destination.EncryptionConfiguration.ReplicaKMSKeyID)
					}
					resf1elemf1.SetEncryptionConfiguration(resf1elemf1f3)
				}
				if resf1iter.Destination.Metrics != nil {
					resf1elemf1f4 := &svcsdk.Metrics{}
					if resf1iter.Destination.Metrics.EventThreshold != nil {
						resf1elemf1f4f0 := &svcsdk.ReplicationTimeValue{}
						if resf1iter.Destination.Metrics.EventThreshold.Minutes != nil {
							resf1elemf1f4f0.SetMinutes(*resf1iter.Destination.Metrics.EventThreshold.Minutes)
						}
						resf1elemf1f4.SetEventThreshold(resf1elemf1f4f0)
					}
					if resf1iter.Destination.Metrics.Status != nil {
						resf1elemf1f4.SetStatus(*resf1iter.Destination.Metrics.Status)
					}
					resf1elemf1.SetMetrics(resf1elemf1f4)
				}
				if resf1iter.Destination.ReplicationTime != nil {
					resf1elemf1f5 := &svcsdk.ReplicationTime{}
					if resf1iter.Destination.ReplicationTime.Status != nil {
						resf1elemf1f5.SetStatus(*resf1iter.Destination.ReplicationTime.Status)
					}
					if resf1iter.Destination.ReplicationTime.Time != nil {
						resf1elemf1f5f1 := &svcsdk.ReplicationTimeValue{}
						if resf1iter.Destination.ReplicationTime.Time.Minutes != nil {
							resf1elemf1f5f1.SetMinutes(*resf1iter.Destination.ReplicationTime.Time.Minutes)
						}
						resf1elemf1f5.SetTime(resf1elemf1f5f1)
					}
					resf1elemf1.SetReplicationTime(resf1elemf1f5)
				}
				if resf1iter.Destination.StorageClass != nil {
					resf1elemf1.SetStorageClass(*resf1iter.Destination.StorageClass)
				}
				resf1elem.SetDestination(resf1elemf1)
			}
			if resf1iter.ExistingObjectReplication != nil {
				resf1elemf2 := &svcsdk.ExistingObjectReplication{}
				if resf1iter.ExistingObjectReplication.Status != nil {
					resf1elemf2.SetStatus(*resf1iter.ExistingObjectReplication.Status)
				}
				resf1elem.SetExistingObjectReplication(resf1elemf2)
			}
			if resf1iter.Filter != nil {
				resf1elemf3 := &svcsdk.ReplicationRuleFilter{}
				if resf1iter.Filter.And != nil {
					resf1elemf3f0 := &svcsdk.ReplicationRuleAndOperator{}
					if resf1iter.Filter.And.Prefix != nil {
						resf1elemf3f0.SetPrefix(*resf1iter.Filter.And.Prefix)
					}
					if resf1iter.Filter.And.Tags != nil {
						resf1elemf3f0f1 := []*svcsdk.Tag{}
						for _, resf1elemf3f0f1iter := range resf1iter.Filter.And.Tags {
							resf1elemf3f0f1elem := &svcsdk.Tag{}
							if resf1elemf3f0f1iter.Key != nil {
								resf1elemf3f0f1elem.SetKey(*resf1elemf3f0f1iter.Key)
							}
							if resf1elemf3f0f1iter.Value != nil {
								resf1elemf3f0f1elem.SetValue(*resf1elemf3f0f1iter.Value)
							}
							resf1elemf3f0f1 = append(resf1elemf3f0f1, resf1elemf3f0f1elem)
						}
						resf1elemf3f0.SetTags(resf1elemf3f0f1)
					}
					resf1elemf3.SetAnd(resf1elemf3f0)
				}
				if resf1iter.Filter.Prefix != nil {
					resf1elemf3.SetPrefix(*resf1iter.Filter.Prefix)
				}
				if resf1iter.Filter.Tag != nil {
					resf1elemf3f2 := &svcsdk.Tag{}
					if resf1iter.Filter.Tag.Key != nil {
						resf1elemf3f2.SetKey(*resf1iter.Filter.Tag.Key)
					}
					if resf1iter.Filter.Tag.Value != nil {
						resf1elemf3f2.SetValue(*resf1iter.Filter.Tag.Value)
					}
					resf1elemf3.SetTag(resf1elemf3f2)
				}
				resf1elem.SetFilter(resf1elemf3)
			}
			if resf1iter.ID != nil {
				resf1elem.SetID(*resf1iter.ID)
			}
			if resf1iter.Prefix != nil {
				resf1elem.SetPrefix(*resf1iter.Prefix)
			}
			if resf1iter.Priority != nil {
				resf1elem.SetPriority(*resf1iter.Priority)
			}
			if resf1iter.SourceSelectionCriteria != nil {
				resf1elemf7 := &svcsdk.SourceSelectionCriteria{}
				if resf1iter.SourceSelectionCriteria.ReplicaModifications != nil {
					resf1elemf7f0 := &svcsdk.ReplicaModifications{}
					if resf1iter.SourceSelectionCriteria.ReplicaModifications.Status != nil {
						resf1elemf7f0.SetStatus(*resf1iter.SourceSelectionCriteria.ReplicaModifications.Status)
					}
					resf1elemf7.SetReplicaModifications(resf1elemf7f0)
				}
				if resf1iter.SourceSelectionCriteria.SSEKMSEncryptedObjects != nil {
					resf1elemf7f1 := &svcsdk.SseKmsEncryptedObjects{}
					if resf1iter.SourceSelectionCriteria.SSEKMSEncryptedObjects.Status != nil {
						resf1elemf7f1.SetStatus(*resf1iter.SourceSelectionCriteria.SSEKMSEncryptedObjects.Status)
					}
					resf1elemf7.SetSseKmsEncryptedObjects(resf1elemf7f1)
				}
				resf1elem.SetSourceSelectionCriteria(resf1elemf7)
			}
			if resf1iter.Status != nil {
				resf1elem.SetStatus(*resf1iter.Status)
			}
			resf1 = append(resf1, resf1elem)
		}
		res.SetRules(resf1)
	}

	return res
}

// setResourceReplication sets the `Replication` spec field
// given the output of a `GetBucketReplication` operation.
func (rm *resourceManager) setResourceReplication(
	r *resource,
	resp *svcsdk.GetBucketReplicationOutput,
) *svcapitypes.ReplicationConfiguration {
	res := &svcapitypes.ReplicationConfiguration{}

	if resp.ReplicationConfiguration.Role != nil {
		res.Role = resp.ReplicationConfiguration.Role
	}
	if resp.ReplicationConfiguration.Rules != nil {
		resf1 := []*svcapitypes.ReplicationRule{}
		for _, resf1iter := range resp.ReplicationConfiguration.Rules {
			resf1elem := &svcapitypes.ReplicationRule{}
			if resf1iter.DeleteMarkerReplication != nil {
				resf1elemf0 := &svcapitypes.DeleteMarkerReplication{}
				if resf1iter.DeleteMarkerReplication.Status != nil {
					resf1elemf0.Status = resf1iter.DeleteMarkerReplication.Status
				}
				resf1elem.DeleteMarkerReplication = resf1elemf0
			}
			if resf1iter.Destination != nil {
				resf1elemf1 := &svcapitypes.Destination{}
				if resf1iter.Destination.AccessControlTranslation != nil {
					resf1elemf1f0 := &svcapitypes.AccessControlTranslation{}
					if resf1iter.Destination.AccessControlTranslation.Owner != nil {
						resf1elemf1f0.Owner = resf1iter.Destination.AccessControlTranslation.Owner
					}
					resf1elemf1.AccessControlTranslation = resf1elemf1f0
				}
				if resf1iter.Destination.Account != nil {
					resf1elemf1.Account = resf1iter.Destination.Account
				}
				if resf1iter.Destination.Bucket != nil {
					resf1elemf1.Bucket = resf1iter.Destination.Bucket
				}
				if resf1iter.Destination.EncryptionConfiguration != nil {
					resf1elemf1f3 := &svcapitypes.EncryptionConfiguration{}
					if resf1iter.Destination.EncryptionConfiguration.ReplicaKmsKeyID != nil {
						resf1elemf1f3.ReplicaKMSKeyID = resf1iter.Destination.EncryptionConfiguration.ReplicaKmsKeyID
					}
					resf1elemf1.EncryptionConfiguration = resf1elemf1f3
				}
				if resf1iter.Destination.Metrics != nil {
					resf1elemf1f4 := &svcapitypes.Metrics{}
					if resf1iter.Destination.Metrics.EventThreshold != nil {
						resf1elemf1f4f0 := &svcapitypes.ReplicationTimeValue{}
						if resf1iter.Destination.Metrics.EventThreshold.Minutes != nil {
							resf1elemf1f4f0.Minutes = resf1iter.Destination.Metrics.EventThreshold.Minutes
						}
						resf1elemf1f4.EventThreshold = resf1elemf1f4f0
					}
					if resf1iter.Destination.Metrics.Status != nil {
						resf1elemf1f4.Status = resf1iter.Destination.Metrics.Status
					}
					resf1elemf1.Metrics = resf1elemf1f4
				}
				if resf1iter.Destination.ReplicationTime != nil {
					resf1elemf1f5 := &svcapitypes.ReplicationTime{}
					if resf1iter.Destination.ReplicationTime.Status != nil {
						resf1elemf1f5.Status = resf1iter.Destination.ReplicationTime.Status
					}
					if resf1iter.Destination.ReplicationTime.Time != nil {
						resf1elemf1f5f1 := &svcapitypes.ReplicationTimeValue{}
						if resf1iter.Destination.ReplicationTime.Time.Minutes != nil {
							resf1elemf1f5f1.Minutes = resf1iter.Destination.ReplicationTime.Time.Minutes
						}
						resf1elemf1f5.Time = resf1elemf1f5f1
					}
					resf1elemf1.ReplicationTime = resf1elemf1f5
				}
				if resf1iter.Destination.StorageClass != nil {
					resf1elemf1.StorageClass = resf1iter.Destination.StorageClass
				}
				resf1elem.Destination = resf1elemf1
			}
			if resf1iter.ExistingObjectReplication != nil {
				resf1elemf2 := &svcapitypes.ExistingObjectReplication{}
				if resf1iter.ExistingObjectReplication.Status != nil {
					resf1elemf2.Status = resf1iter.ExistingObjectReplication.Status
				}
				resf1elem.ExistingObjectReplication = resf1elemf2
			}
			if resf1iter.Filter != nil {
				resf1elemf3 := &svcapitypes.ReplicationRuleFilter{}
				if resf1iter.Filter.And != nil {
					resf1elemf3f0 := &svcapitypes.ReplicationRuleAndOperator{}
					if resf1iter.Filter.And.Prefix != nil {
						resf1elemf3f0.Prefix = resf1iter.Filter.And.Prefix
					}
					if resf1iter.Filter.And.Tags != nil {
						resf1elemf3f0f1 := []*svcapitypes.Tag{}
						for _, resf1elemf3f0f1iter := range resf1iter.Filter.And.Tags {
							resf1elemf3f0f1elem := &svcapitypes.Tag{}
							if resf1elemf3f0f1iter.Key != nil {
								resf1elemf3f0f1elem.Key = resf1elemf3f0f1iter.Key
							}
							if resf1elemf3f0f1iter.Value != nil {
								resf1elemf3f0f1elem.Value = resf1elemf3f0f1iter.Value
							}
							resf1elemf3f0f1 = append(resf1elemf3f0f1, resf1elemf3f0f1elem)
						}
						resf1elemf3f0.Tags = resf1elemf3f0f1
					}
					resf1elemf3.And = resf1elemf3f0
				}
				if resf1iter.Filter.Prefix != nil {
					resf1elemf3.Prefix = resf1iter.Filter.Prefix
				}
				if resf1iter.Filter.Tag != nil {
					resf1elemf3f2 := &svcapitypes.Tag{}
					if resf1iter.Filter.Tag.Key != nil {
						resf1elemf3f2.Key = resf1iter.Filter.Tag.Key
					}
					if resf1iter.Filter.Tag.Value != nil {
						resf1elemf3f2.Value = resf1iter.Filter.Tag.Value
					}
					resf1elemf3.Tag = resf1elemf3f2
				}
				resf1elem.Filter = resf1elemf3
			}
			if resf1iter.ID != nil {
				resf1elem.ID = resf1iter.ID
			}
			if resf1iter.Prefix != nil {
				resf1elem.Prefix = resf1iter.Prefix
			}
			if resf1iter.Priority != nil {
				resf1elem.Priority = resf1iter.Priority
			}
			if resf1iter.SourceSelectionCriteria != nil {
				resf1elemf7 := &svcapitypes.SourceSelectionCriteria{}
				if resf1iter.SourceSelectionCriteria.ReplicaModifications != nil {
					resf1elemf7f0 := &svcapitypes.ReplicaModifications{}
					if resf1iter.SourceSelectionCriteria.ReplicaModifications.Status != nil {
						resf1elemf7f0.Status = resf1iter.SourceSelectionCriteria.ReplicaModifications.Status
					}
					resf1elemf7.ReplicaModifications = resf1elemf7f0
				}
				if resf1iter.SourceSelectionCriteria.SseKmsEncryptedObjects != nil {
					resf1elemf7f1 := &svcapitypes.SSEKMSEncryptedObjects{}
					if resf1iter.SourceSelectionCriteria.SseKmsEncryptedObjects.Status != nil {
						resf1elemf7f1.Status = resf1iter.SourceSelectionCriteria.SseKmsEncryptedObjects.Status
					}
					resf1elemf7.SSEKMSEncryptedObjects = resf1elemf7f1
				}
				resf1elem.SourceSelectionCriteria = resf1elemf7
			}
			if resf1iter.Status != nil {
				resf1elem.Status = resf1iter.Status
			}
			resf1 = append(resf1, resf1elem)
		}
		res.Rules = resf1
	}

	return res
}

// newRequestPaymentConfiguration returns a RequestPaymentConfiguration object
// with each the field set by the resource's corresponding spec field.
func (rm *resourceManager) newRequestPaymentConfiguration(
	r *resource,
) *svcsdk.RequestPaymentConfiguration {
	res := &svcsdk.RequestPaymentConfiguration{}

	if r.ko.Spec.RequestPayment.Payer != nil {
		res.SetPayer(*r.ko.Spec.RequestPayment.Payer)
	}

	return res
}

// setResourceRequestPayment sets the `RequestPayment` spec field
// given the output of a `GetBucketRequestPayment` operation.
func (rm *resourceManager) setResourceRequestPayment(
	r *resource,
	resp *svcsdk.GetBucketRequestPaymentOutput,
) *svcapitypes.RequestPaymentConfiguration {
	res := &svcapitypes.RequestPaymentConfiguration{}

	if resp.Payer != nil {
		res.Payer = resp.Payer
	}

	return res
}

// newTagging returns a Tagging object
// with each the field set by the resource's corresponding spec field.
func (rm *resourceManager) newTagging(
	r *resource,
) *svcsdk.Tagging {
	res := &svcsdk.Tagging{}

	if r.ko.Spec.Tagging.TagSet != nil {
		resf0 := []*svcsdk.Tag{}
		for _, resf0iter := range r.ko.Spec.Tagging.TagSet {
			resf0elem := &svcsdk.Tag{}
			if resf0iter.Key != nil {
				resf0elem.SetKey(*resf0iter.Key)
			}
			if resf0iter.Value != nil {
				resf0elem.SetValue(*resf0iter.Value)
			}
			resf0 = append(resf0, resf0elem)
		}
		res.SetTagSet(resf0)
	}

	return res
}

// setResourceTagging sets the `Tagging` spec field
// given the output of a `GetBucketTagging` operation.
func (rm *resourceManager) setResourceTagging(
	r *resource,
	resp *svcsdk.GetBucketTaggingOutput,
) *svcapitypes.Tagging {
	res := &svcapitypes.Tagging{}

	if resp.TagSet != nil {
		resf0 := []*svcapitypes.Tag{}
		for _, resf0iter := range resp.TagSet {
			resf0elem := &svcapitypes.Tag{}
			if resf0iter.Key != nil {
				resf0elem.Key = resf0iter.Key
			}
			if resf0iter.Value != nil {
				resf0elem.Value = resf0iter.Value
			}
			resf0 = append(resf0, resf0elem)
		}
		res.TagSet = resf0
	}

	return res
}

// newVersioningConfiguration returns a VersioningConfiguration object
// with each the field set by the resource's corresponding spec field.
func (rm *resourceManager) newVersioningConfiguration(
	r *resource,
) *svcsdk.VersioningConfiguration {
	res := &svcsdk.VersioningConfiguration{}

	if r.ko.Spec.Versioning.Status != nil {
		res.SetStatus(*r.ko.Spec.Versioning.Status)
	}

	return res
}

// setResourceVersioning sets the `Versioning` spec field
// given the output of a `GetBucketVersioning` operation.
func (rm *resourceManager) setResourceVersioning(
	r *resource,
	resp *svcsdk.GetBucketVersioningOutput,
) *svcapitypes.VersioningConfiguration {
	res := &svcapitypes.VersioningConfiguration{}

	if resp.Status != nil {
		res.Status = resp.Status
	}

	return res
}

// newWebsiteConfiguration returns a WebsiteConfiguration object
// with each the field set by the resource's corresponding spec field.
func (rm *resourceManager) newWebsiteConfiguration(
	r *resource,
) *svcsdk.WebsiteConfiguration {
	res := &svcsdk.WebsiteConfiguration{}

	if r.ko.Spec.Website.ErrorDocument != nil {
		resf0 := &svcsdk.ErrorDocument{}
		if r.ko.Spec.Website.ErrorDocument.Key != nil {
			resf0.SetKey(*r.ko.Spec.Website.ErrorDocument.Key)
		}
		res.SetErrorDocument(resf0)
	}
	if r.ko.Spec.Website.IndexDocument != nil {
		resf1 := &svcsdk.IndexDocument{}
		if r.ko.Spec.Website.IndexDocument.Suffix != nil {
			resf1.SetSuffix(*r.ko.Spec.Website.IndexDocument.Suffix)
		}
		res.SetIndexDocument(resf1)
	}
	if r.ko.Spec.Website.RedirectAllRequestsTo != nil {
		resf2 := &svcsdk.RedirectAllRequestsTo{}
		if r.ko.Spec.Website.RedirectAllRequestsTo.HostName != nil {
			resf2.SetHostName(*r.ko.Spec.Website.RedirectAllRequestsTo.HostName)
		}
		if r.ko.Spec.Website.RedirectAllRequestsTo.Protocol != nil {
			resf2.SetProtocol(*r.ko.Spec.Website.RedirectAllRequestsTo.Protocol)
		}
		res.SetRedirectAllRequestsTo(resf2)
	}
	if r.ko.Spec.Website.RoutingRules != nil {
		resf3 := []*svcsdk.RoutingRule{}
		for _, resf3iter := range r.ko.Spec.Website.RoutingRules {
			resf3elem := &svcsdk.RoutingRule{}
			if resf3iter.Condition != nil {
				resf3elemf0 := &svcsdk.Condition{}
				if resf3iter.Condition.HTTPErrorCodeReturnedEquals != nil {
					resf3elemf0.SetHttpErrorCodeReturnedEquals(*resf3iter.Condition.HTTPErrorCodeReturnedEquals)
				}
				if resf3iter.Condition.KeyPrefixEquals != nil {
					resf3elemf0.SetKeyPrefixEquals(*resf3iter.Condition.KeyPrefixEquals)
				}
				resf3elem.SetCondition(resf3elemf0)
			}
			if resf3iter.Redirect != nil {
				resf3elemf1 := &svcsdk.Redirect{}
				if resf3iter.Redirect.HostName != nil {
					resf3elemf1.SetHostName(*resf3iter.Redirect.HostName)
				}
				if resf3iter.Redirect.HTTPRedirectCode != nil {
					resf3elemf1.SetHttpRedirectCode(*resf3iter.Redirect.HTTPRedirectCode)
				}
				if resf3iter.Redirect.Protocol != nil {
					resf3elemf1.SetProtocol(*resf3iter.Redirect.Protocol)
				}
				if resf3iter.Redirect.ReplaceKeyPrefixWith != nil {
					resf3elemf1.SetReplaceKeyPrefixWith(*resf3iter.Redirect.ReplaceKeyPrefixWith)
				}
				if resf3iter.Redirect.ReplaceKeyWith != nil {
					resf3elemf1.SetReplaceKeyWith(*resf3iter.Redirect.ReplaceKeyWith)
				}
				resf3elem.SetRedirect(resf3elemf1)
			}
			resf3 = append(resf3, resf3elem)
		}
		res.SetRoutingRules(resf3)
	}

	return res
}

// setResourceWebsite sets the `Website` spec field
// given the output of a `GetBucketWebsite` operation.
func (rm *resourceManager) setResourceWebsite(
	r *resource,
	resp *svcsdk.GetBucketWebsiteOutput,
) *svcapitypes.WebsiteConfiguration {
	res := &svcapitypes.WebsiteConfiguration{}

	if resp.ErrorDocument != nil {
		resf0 := &svcapitypes.ErrorDocument{}
		if resp.ErrorDocument.Key != nil {
			resf0.Key = resp.ErrorDocument.Key
		}
		res.ErrorDocument = resf0
	}
	if resp.IndexDocument != nil {
		resf1 := &svcapitypes.IndexDocument{}
		if resp.IndexDocument.Suffix != nil {
			resf1.Suffix = resp.IndexDocument.Suffix
		}
		res.IndexDocument = resf1
	}
	if resp.RedirectAllRequestsTo != nil {
		resf2 := &svcapitypes.RedirectAllRequestsTo{}
		if resp.RedirectAllRequestsTo.HostName != nil {
			resf2.HostName = resp.RedirectAllRequestsTo.HostName
		}
		if resp.RedirectAllRequestsTo.Protocol != nil {
			resf2.Protocol = resp.RedirectAllRequestsTo.Protocol
		}
		res.RedirectAllRequestsTo = resf2
	}
	if resp.RoutingRules != nil {
		resf3 := []*svcapitypes.RoutingRule{}
		for _, resf3iter := range resp.RoutingRules {
			resf3elem := &svcapitypes.RoutingRule{}
			if resf3iter.Condition != nil {
				resf3elemf0 := &svcapitypes.Condition{}
				if resf3iter.Condition.HttpErrorCodeReturnedEquals != nil {
					resf3elemf0.HTTPErrorCodeReturnedEquals = resf3iter.Condition.HttpErrorCodeReturnedEquals
				}
				if resf3iter.Condition.KeyPrefixEquals != nil {
					resf3elemf0.KeyPrefixEquals = resf3iter.Condition.KeyPrefixEquals
				}
				resf3elem.Condition = resf3elemf0
			}
			if resf3iter.Redirect != nil {
				resf3elemf1 := &svcapitypes.Redirect{}
				if resf3iter.Redirect.HostName != nil {
					resf3elemf1.HostName = resf3iter.Redirect.HostName
				}
				if resf3iter.Redirect.HttpRedirectCode != nil {
					resf3elemf1.HTTPRedirectCode = resf3iter.Redirect.HttpRedirectCode
				}
				if resf3iter.Redirect.Protocol != nil {
					resf3elemf1.Protocol = resf3iter.Redirect.Protocol
				}
				if resf3iter.Redirect.ReplaceKeyPrefixWith != nil {
					resf3elemf1.ReplaceKeyPrefixWith = resf3iter.Redirect.ReplaceKeyPrefixWith
				}
				if resf3iter.Redirect.ReplaceKeyWith != nil {
					resf3elemf1.ReplaceKeyWith = resf3iter.Redirect.ReplaceKeyWith
				}
				resf3elem.Redirect = resf3elemf1
			}
			resf3 = append(resf3, resf3elem)
		}
		res.RoutingRules = resf3
	}

	return res
}