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 endpoint

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/sagemaker"
	corev1 "k8s.io/api/core/v1"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"

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

// Hack to avoid import errors during build...
var (
	_ = &metav1.Time{}
	_ = strings.ToLower("")
	_ = &aws.JSONValue{}
	_ = &svcsdk.SageMaker{}
	_ = &svcapitypes.Endpoint{}
	_ = 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.requiredFieldsMissingFromReadOneInput(r) {
		return nil, ackerr.NotFound
	}

	input, err := rm.newDescribeRequestPayload(r)
	if err != nil {
		return nil, err
	}

	var resp *svcsdk.DescribeEndpointOutput
	resp, err = rm.sdkapi.DescribeEndpointWithContext(ctx, input)
	rm.metrics.RecordAPICall("READ_ONE", "DescribeEndpoint", err)
	if err != nil {
		if reqErr, ok := ackerr.AWSRequestFailure(err); ok && reqErr.StatusCode() == 404 {
			return nil, ackerr.NotFound
		}
		if awsErr, ok := ackerr.AWSError(err); ok && awsErr.Code() == "ValidationException" && strings.HasPrefix(awsErr.Message(), "Could not find endpoint") {
			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()

	if resp.CreationTime != nil {
		ko.Status.CreationTime = &metav1.Time{*resp.CreationTime}
	} else {
		ko.Status.CreationTime = nil
	}
	if ko.Status.ACKResourceMetadata == nil {
		ko.Status.ACKResourceMetadata = &ackv1alpha1.ResourceMetadata{}
	}
	if resp.EndpointArn != nil {
		arn := ackv1alpha1.AWSResourceName(*resp.EndpointArn)
		ko.Status.ACKResourceMetadata.ARN = &arn
	}
	if resp.EndpointConfigName != nil {
		ko.Spec.EndpointConfigName = resp.EndpointConfigName
	} else {
		ko.Spec.EndpointConfigName = nil
	}
	if resp.EndpointName != nil {
		ko.Spec.EndpointName = resp.EndpointName
	} else {
		ko.Spec.EndpointName = nil
	}
	if resp.EndpointStatus != nil {
		ko.Status.EndpointStatus = resp.EndpointStatus
	} else {
		ko.Status.EndpointStatus = nil
	}
	if resp.FailureReason != nil {
		ko.Status.FailureReason = resp.FailureReason
	} else {
		ko.Status.FailureReason = nil
	}
	if resp.LastDeploymentConfig != nil {
		f8 := &svcapitypes.DeploymentConfig{}
		if resp.LastDeploymentConfig.AutoRollbackConfiguration != nil {
			f8f0 := &svcapitypes.AutoRollbackConfig{}
			if resp.LastDeploymentConfig.AutoRollbackConfiguration.Alarms != nil {
				f8f0f0 := []*svcapitypes.Alarm{}
				for _, f8f0f0iter := range resp.LastDeploymentConfig.AutoRollbackConfiguration.Alarms {
					f8f0f0elem := &svcapitypes.Alarm{}
					if f8f0f0iter.AlarmName != nil {
						f8f0f0elem.AlarmName = f8f0f0iter.AlarmName
					}
					f8f0f0 = append(f8f0f0, f8f0f0elem)
				}
				f8f0.Alarms = f8f0f0
			}
			f8.AutoRollbackConfiguration = f8f0
		}
		if resp.LastDeploymentConfig.BlueGreenUpdatePolicy != nil {
			f8f1 := &svcapitypes.BlueGreenUpdatePolicy{}
			if resp.LastDeploymentConfig.BlueGreenUpdatePolicy.MaximumExecutionTimeoutInSeconds != nil {
				f8f1.MaximumExecutionTimeoutInSeconds = resp.LastDeploymentConfig.BlueGreenUpdatePolicy.MaximumExecutionTimeoutInSeconds
			}
			if resp.LastDeploymentConfig.BlueGreenUpdatePolicy.TerminationWaitInSeconds != nil {
				f8f1.TerminationWaitInSeconds = resp.LastDeploymentConfig.BlueGreenUpdatePolicy.TerminationWaitInSeconds
			}
			if resp.LastDeploymentConfig.BlueGreenUpdatePolicy.TrafficRoutingConfiguration != nil {
				f8f1f2 := &svcapitypes.TrafficRoutingConfig{}
				if resp.LastDeploymentConfig.BlueGreenUpdatePolicy.TrafficRoutingConfiguration.CanarySize != nil {
					f8f1f2f0 := &svcapitypes.CapacitySize{}
					if resp.LastDeploymentConfig.BlueGreenUpdatePolicy.TrafficRoutingConfiguration.CanarySize.Type != nil {
						f8f1f2f0.Type = resp.LastDeploymentConfig.BlueGreenUpdatePolicy.TrafficRoutingConfiguration.CanarySize.Type
					}
					if resp.LastDeploymentConfig.BlueGreenUpdatePolicy.TrafficRoutingConfiguration.CanarySize.Value != nil {
						f8f1f2f0.Value = resp.LastDeploymentConfig.BlueGreenUpdatePolicy.TrafficRoutingConfiguration.CanarySize.Value
					}
					f8f1f2.CanarySize = f8f1f2f0
				}
				if resp.LastDeploymentConfig.BlueGreenUpdatePolicy.TrafficRoutingConfiguration.LinearStepSize != nil {
					f8f1f2f1 := &svcapitypes.CapacitySize{}
					if resp.LastDeploymentConfig.BlueGreenUpdatePolicy.TrafficRoutingConfiguration.LinearStepSize.Type != nil {
						f8f1f2f1.Type = resp.LastDeploymentConfig.BlueGreenUpdatePolicy.TrafficRoutingConfiguration.LinearStepSize.Type
					}
					if resp.LastDeploymentConfig.BlueGreenUpdatePolicy.TrafficRoutingConfiguration.LinearStepSize.Value != nil {
						f8f1f2f1.Value = resp.LastDeploymentConfig.BlueGreenUpdatePolicy.TrafficRoutingConfiguration.LinearStepSize.Value
					}
					f8f1f2.LinearStepSize = f8f1f2f1
				}
				if resp.LastDeploymentConfig.BlueGreenUpdatePolicy.TrafficRoutingConfiguration.Type != nil {
					f8f1f2.Type = resp.LastDeploymentConfig.BlueGreenUpdatePolicy.TrafficRoutingConfiguration.Type
				}
				if resp.LastDeploymentConfig.BlueGreenUpdatePolicy.TrafficRoutingConfiguration.WaitIntervalInSeconds != nil {
					f8f1f2.WaitIntervalInSeconds = resp.LastDeploymentConfig.BlueGreenUpdatePolicy.TrafficRoutingConfiguration.WaitIntervalInSeconds
				}
				f8f1.TrafficRoutingConfiguration = f8f1f2
			}
			f8.BlueGreenUpdatePolicy = f8f1
		}
		if resp.LastDeploymentConfig.RollingUpdatePolicy != nil {
			f8f2 := &svcapitypes.RollingUpdatePolicy{}
			if resp.LastDeploymentConfig.RollingUpdatePolicy.MaximumBatchSize != nil {
				f8f2f0 := &svcapitypes.CapacitySize{}
				if resp.LastDeploymentConfig.RollingUpdatePolicy.MaximumBatchSize.Type != nil {
					f8f2f0.Type = resp.LastDeploymentConfig.RollingUpdatePolicy.MaximumBatchSize.Type
				}
				if resp.LastDeploymentConfig.RollingUpdatePolicy.MaximumBatchSize.Value != nil {
					f8f2f0.Value = resp.LastDeploymentConfig.RollingUpdatePolicy.MaximumBatchSize.Value
				}
				f8f2.MaximumBatchSize = f8f2f0
			}
			if resp.LastDeploymentConfig.RollingUpdatePolicy.MaximumExecutionTimeoutInSeconds != nil {
				f8f2.MaximumExecutionTimeoutInSeconds = resp.LastDeploymentConfig.RollingUpdatePolicy.MaximumExecutionTimeoutInSeconds
			}
			if resp.LastDeploymentConfig.RollingUpdatePolicy.RollbackMaximumBatchSize != nil {
				f8f2f2 := &svcapitypes.CapacitySize{}
				if resp.LastDeploymentConfig.RollingUpdatePolicy.RollbackMaximumBatchSize.Type != nil {
					f8f2f2.Type = resp.LastDeploymentConfig.RollingUpdatePolicy.RollbackMaximumBatchSize.Type
				}
				if resp.LastDeploymentConfig.RollingUpdatePolicy.RollbackMaximumBatchSize.Value != nil {
					f8f2f2.Value = resp.LastDeploymentConfig.RollingUpdatePolicy.RollbackMaximumBatchSize.Value
				}
				f8f2.RollbackMaximumBatchSize = f8f2f2
			}
			if resp.LastDeploymentConfig.RollingUpdatePolicy.WaitIntervalInSeconds != nil {
				f8f2.WaitIntervalInSeconds = resp.LastDeploymentConfig.RollingUpdatePolicy.WaitIntervalInSeconds
			}
			f8.RollingUpdatePolicy = f8f2
		}
		ko.Spec.DeploymentConfig = f8
	} else {
		ko.Spec.DeploymentConfig = nil
	}
	if resp.LastModifiedTime != nil {
		ko.Status.LastModifiedTime = &metav1.Time{*resp.LastModifiedTime}
	} else {
		ko.Status.LastModifiedTime = nil
	}
	if resp.PendingDeploymentSummary != nil {
		f10 := &svcapitypes.PendingDeploymentSummary{}
		if resp.PendingDeploymentSummary.EndpointConfigName != nil {
			f10.EndpointConfigName = resp.PendingDeploymentSummary.EndpointConfigName
		}
		if resp.PendingDeploymentSummary.ProductionVariants != nil {
			f10f1 := []*svcapitypes.PendingProductionVariantSummary{}
			for _, f10f1iter := range resp.PendingDeploymentSummary.ProductionVariants {
				f10f1elem := &svcapitypes.PendingProductionVariantSummary{}
				if f10f1iter.AcceleratorType != nil {
					f10f1elem.AcceleratorType = f10f1iter.AcceleratorType
				}
				if f10f1iter.CurrentInstanceCount != nil {
					f10f1elem.CurrentInstanceCount = f10f1iter.CurrentInstanceCount
				}
				if f10f1iter.CurrentServerlessConfig != nil {
					f10f1elemf2 := &svcapitypes.ProductionVariantServerlessConfig{}
					if f10f1iter.CurrentServerlessConfig.MaxConcurrency != nil {
						f10f1elemf2.MaxConcurrency = f10f1iter.CurrentServerlessConfig.MaxConcurrency
					}
					if f10f1iter.CurrentServerlessConfig.MemorySizeInMB != nil {
						f10f1elemf2.MemorySizeInMB = f10f1iter.CurrentServerlessConfig.MemorySizeInMB
					}
					if f10f1iter.CurrentServerlessConfig.ProvisionedConcurrency != nil {
						f10f1elemf2.ProvisionedConcurrency = f10f1iter.CurrentServerlessConfig.ProvisionedConcurrency
					}
					f10f1elem.CurrentServerlessConfig = f10f1elemf2
				}
				if f10f1iter.CurrentWeight != nil {
					f10f1elem.CurrentWeight = f10f1iter.CurrentWeight
				}
				if f10f1iter.DeployedImages != nil {
					f10f1elemf4 := []*svcapitypes.DeployedImage{}
					for _, f10f1elemf4iter := range f10f1iter.DeployedImages {
						f10f1elemf4elem := &svcapitypes.DeployedImage{}
						if f10f1elemf4iter.ResolutionTime != nil {
							f10f1elemf4elem.ResolutionTime = &metav1.Time{*f10f1elemf4iter.ResolutionTime}
						}
						if f10f1elemf4iter.ResolvedImage != nil {
							f10f1elemf4elem.ResolvedImage = f10f1elemf4iter.ResolvedImage
						}
						if f10f1elemf4iter.SpecifiedImage != nil {
							f10f1elemf4elem.SpecifiedImage = f10f1elemf4iter.SpecifiedImage
						}
						f10f1elemf4 = append(f10f1elemf4, f10f1elemf4elem)
					}
					f10f1elem.DeployedImages = f10f1elemf4
				}
				if f10f1iter.DesiredInstanceCount != nil {
					f10f1elem.DesiredInstanceCount = f10f1iter.DesiredInstanceCount
				}
				if f10f1iter.DesiredServerlessConfig != nil {
					f10f1elemf6 := &svcapitypes.ProductionVariantServerlessConfig{}
					if f10f1iter.DesiredServerlessConfig.MaxConcurrency != nil {
						f10f1elemf6.MaxConcurrency = f10f1iter.DesiredServerlessConfig.MaxConcurrency
					}
					if f10f1iter.DesiredServerlessConfig.MemorySizeInMB != nil {
						f10f1elemf6.MemorySizeInMB = f10f1iter.DesiredServerlessConfig.MemorySizeInMB
					}
					if f10f1iter.DesiredServerlessConfig.ProvisionedConcurrency != nil {
						f10f1elemf6.ProvisionedConcurrency = f10f1iter.DesiredServerlessConfig.ProvisionedConcurrency
					}
					f10f1elem.DesiredServerlessConfig = f10f1elemf6
				}
				if f10f1iter.DesiredWeight != nil {
					f10f1elem.DesiredWeight = f10f1iter.DesiredWeight
				}
				if f10f1iter.InstanceType != nil {
					f10f1elem.InstanceType = f10f1iter.InstanceType
				}
				if f10f1iter.ManagedInstanceScaling != nil {
					f10f1elemf9 := &svcapitypes.ProductionVariantManagedInstanceScaling{}
					if f10f1iter.ManagedInstanceScaling.MaxInstanceCount != nil {
						f10f1elemf9.MaxInstanceCount = f10f1iter.ManagedInstanceScaling.MaxInstanceCount
					}
					if f10f1iter.ManagedInstanceScaling.MinInstanceCount != nil {
						f10f1elemf9.MinInstanceCount = f10f1iter.ManagedInstanceScaling.MinInstanceCount
					}
					if f10f1iter.ManagedInstanceScaling.Status != nil {
						f10f1elemf9.Status = f10f1iter.ManagedInstanceScaling.Status
					}
					f10f1elem.ManagedInstanceScaling = f10f1elemf9
				}
				if f10f1iter.RoutingConfig != nil {
					f10f1elemf10 := &svcapitypes.ProductionVariantRoutingConfig{}
					if f10f1iter.RoutingConfig.RoutingStrategy != nil {
						f10f1elemf10.RoutingStrategy = f10f1iter.RoutingConfig.RoutingStrategy
					}
					f10f1elem.RoutingConfig = f10f1elemf10
				}
				if f10f1iter.VariantName != nil {
					f10f1elem.VariantName = f10f1iter.VariantName
				}
				if f10f1iter.VariantStatus != nil {
					f10f1elemf12 := []*svcapitypes.ProductionVariantStatus{}
					for _, f10f1elemf12iter := range f10f1iter.VariantStatus {
						f10f1elemf12elem := &svcapitypes.ProductionVariantStatus{}
						if f10f1elemf12iter.StartTime != nil {
							f10f1elemf12elem.StartTime = &metav1.Time{*f10f1elemf12iter.StartTime}
						}
						if f10f1elemf12iter.Status != nil {
							f10f1elemf12elem.Status = f10f1elemf12iter.Status
						}
						if f10f1elemf12iter.StatusMessage != nil {
							f10f1elemf12elem.StatusMessage = f10f1elemf12iter.StatusMessage
						}
						f10f1elemf12 = append(f10f1elemf12, f10f1elemf12elem)
					}
					f10f1elem.VariantStatus = f10f1elemf12
				}
				f10f1 = append(f10f1, f10f1elem)
			}
			f10.ProductionVariants = f10f1
		}
		if resp.PendingDeploymentSummary.StartTime != nil {
			f10.StartTime = &metav1.Time{*resp.PendingDeploymentSummary.StartTime}
		}
		ko.Status.PendingDeploymentSummary = f10
	} else {
		ko.Status.PendingDeploymentSummary = nil
	}
	if resp.ProductionVariants != nil {
		f11 := []*svcapitypes.ProductionVariantSummary{}
		for _, f11iter := range resp.ProductionVariants {
			f11elem := &svcapitypes.ProductionVariantSummary{}
			if f11iter.CurrentInstanceCount != nil {
				f11elem.CurrentInstanceCount = f11iter.CurrentInstanceCount
			}
			if f11iter.CurrentServerlessConfig != nil {
				f11elemf1 := &svcapitypes.ProductionVariantServerlessConfig{}
				if f11iter.CurrentServerlessConfig.MaxConcurrency != nil {
					f11elemf1.MaxConcurrency = f11iter.CurrentServerlessConfig.MaxConcurrency
				}
				if f11iter.CurrentServerlessConfig.MemorySizeInMB != nil {
					f11elemf1.MemorySizeInMB = f11iter.CurrentServerlessConfig.MemorySizeInMB
				}
				if f11iter.CurrentServerlessConfig.ProvisionedConcurrency != nil {
					f11elemf1.ProvisionedConcurrency = f11iter.CurrentServerlessConfig.ProvisionedConcurrency
				}
				f11elem.CurrentServerlessConfig = f11elemf1
			}
			if f11iter.CurrentWeight != nil {
				f11elem.CurrentWeight = f11iter.CurrentWeight
			}
			if f11iter.DeployedImages != nil {
				f11elemf3 := []*svcapitypes.DeployedImage{}
				for _, f11elemf3iter := range f11iter.DeployedImages {
					f11elemf3elem := &svcapitypes.DeployedImage{}
					if f11elemf3iter.ResolutionTime != nil {
						f11elemf3elem.ResolutionTime = &metav1.Time{*f11elemf3iter.ResolutionTime}
					}
					if f11elemf3iter.ResolvedImage != nil {
						f11elemf3elem.ResolvedImage = f11elemf3iter.ResolvedImage
					}
					if f11elemf3iter.SpecifiedImage != nil {
						f11elemf3elem.SpecifiedImage = f11elemf3iter.SpecifiedImage
					}
					f11elemf3 = append(f11elemf3, f11elemf3elem)
				}
				f11elem.DeployedImages = f11elemf3
			}
			if f11iter.DesiredInstanceCount != nil {
				f11elem.DesiredInstanceCount = f11iter.DesiredInstanceCount
			}
			if f11iter.DesiredServerlessConfig != nil {
				f11elemf5 := &svcapitypes.ProductionVariantServerlessConfig{}
				if f11iter.DesiredServerlessConfig.MaxConcurrency != nil {
					f11elemf5.MaxConcurrency = f11iter.DesiredServerlessConfig.MaxConcurrency
				}
				if f11iter.DesiredServerlessConfig.MemorySizeInMB != nil {
					f11elemf5.MemorySizeInMB = f11iter.DesiredServerlessConfig.MemorySizeInMB
				}
				if f11iter.DesiredServerlessConfig.ProvisionedConcurrency != nil {
					f11elemf5.ProvisionedConcurrency = f11iter.DesiredServerlessConfig.ProvisionedConcurrency
				}
				f11elem.DesiredServerlessConfig = f11elemf5
			}
			if f11iter.DesiredWeight != nil {
				f11elem.DesiredWeight = f11iter.DesiredWeight
			}
			if f11iter.ManagedInstanceScaling != nil {
				f11elemf7 := &svcapitypes.ProductionVariantManagedInstanceScaling{}
				if f11iter.ManagedInstanceScaling.MaxInstanceCount != nil {
					f11elemf7.MaxInstanceCount = f11iter.ManagedInstanceScaling.MaxInstanceCount
				}
				if f11iter.ManagedInstanceScaling.MinInstanceCount != nil {
					f11elemf7.MinInstanceCount = f11iter.ManagedInstanceScaling.MinInstanceCount
				}
				if f11iter.ManagedInstanceScaling.Status != nil {
					f11elemf7.Status = f11iter.ManagedInstanceScaling.Status
				}
				f11elem.ManagedInstanceScaling = f11elemf7
			}
			if f11iter.RoutingConfig != nil {
				f11elemf8 := &svcapitypes.ProductionVariantRoutingConfig{}
				if f11iter.RoutingConfig.RoutingStrategy != nil {
					f11elemf8.RoutingStrategy = f11iter.RoutingConfig.RoutingStrategy
				}
				f11elem.RoutingConfig = f11elemf8
			}
			if f11iter.VariantName != nil {
				f11elem.VariantName = f11iter.VariantName
			}
			if f11iter.VariantStatus != nil {
				f11elemf10 := []*svcapitypes.ProductionVariantStatus{}
				for _, f11elemf10iter := range f11iter.VariantStatus {
					f11elemf10elem := &svcapitypes.ProductionVariantStatus{}
					if f11elemf10iter.StartTime != nil {
						f11elemf10elem.StartTime = &metav1.Time{*f11elemf10iter.StartTime}
					}
					if f11elemf10iter.Status != nil {
						f11elemf10elem.Status = f11elemf10iter.Status
					}
					if f11elemf10iter.StatusMessage != nil {
						f11elemf10elem.StatusMessage = f11elemf10iter.StatusMessage
					}
					f11elemf10 = append(f11elemf10, f11elemf10elem)
				}
				f11elem.VariantStatus = f11elemf10
			}
			f11 = append(f11, f11elem)
		}
		ko.Status.ProductionVariants = f11
	} else {
		ko.Status.ProductionVariants = nil
	}

	rm.setStatusDefaults(ko)
	rm.customDescribeEndpointSetOutput(ko)
	return &resource{ko}, nil
}

// requiredFieldsMissingFromReadOneInput returns true if there are any fields
// for the ReadOne Input shape that are required but not present in the
// resource's Spec or Status
func (rm *resourceManager) requiredFieldsMissingFromReadOneInput(
	r *resource,
) bool {
	return r.ko.Spec.EndpointName == nil

}

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

	if r.ko.Spec.EndpointName != nil {
		res.SetEndpointName(*r.ko.Spec.EndpointName)
	}

	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.CreateEndpointOutput
	_ = resp
	resp, err = rm.sdkapi.CreateEndpointWithContext(ctx, input)
	rm.metrics.RecordAPICall("CREATE", "CreateEndpoint", 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 ko.Status.ACKResourceMetadata == nil {
		ko.Status.ACKResourceMetadata = &ackv1alpha1.ResourceMetadata{}
	}
	if resp.EndpointArn != nil {
		arn := ackv1alpha1.AWSResourceName(*resp.EndpointArn)
		ko.Status.ACKResourceMetadata.ARN = &arn
	}

	rm.setStatusDefaults(ko)
	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.CreateEndpointInput, error) {
	res := &svcsdk.CreateEndpointInput{}

	if r.ko.Spec.DeploymentConfig != nil {
		f0 := &svcsdk.DeploymentConfig{}
		if r.ko.Spec.DeploymentConfig.AutoRollbackConfiguration != nil {
			f0f0 := &svcsdk.AutoRollbackConfig{}
			if r.ko.Spec.DeploymentConfig.AutoRollbackConfiguration.Alarms != nil {
				f0f0f0 := []*svcsdk.Alarm{}
				for _, f0f0f0iter := range r.ko.Spec.DeploymentConfig.AutoRollbackConfiguration.Alarms {
					f0f0f0elem := &svcsdk.Alarm{}
					if f0f0f0iter.AlarmName != nil {
						f0f0f0elem.SetAlarmName(*f0f0f0iter.AlarmName)
					}
					f0f0f0 = append(f0f0f0, f0f0f0elem)
				}
				f0f0.SetAlarms(f0f0f0)
			}
			f0.SetAutoRollbackConfiguration(f0f0)
		}
		if r.ko.Spec.DeploymentConfig.BlueGreenUpdatePolicy != nil {
			f0f1 := &svcsdk.BlueGreenUpdatePolicy{}
			if r.ko.Spec.DeploymentConfig.BlueGreenUpdatePolicy.MaximumExecutionTimeoutInSeconds != nil {
				f0f1.SetMaximumExecutionTimeoutInSeconds(*r.ko.Spec.DeploymentConfig.BlueGreenUpdatePolicy.MaximumExecutionTimeoutInSeconds)
			}
			if r.ko.Spec.DeploymentConfig.BlueGreenUpdatePolicy.TerminationWaitInSeconds != nil {
				f0f1.SetTerminationWaitInSeconds(*r.ko.Spec.DeploymentConfig.BlueGreenUpdatePolicy.TerminationWaitInSeconds)
			}
			if r.ko.Spec.DeploymentConfig.BlueGreenUpdatePolicy.TrafficRoutingConfiguration != nil {
				f0f1f2 := &svcsdk.TrafficRoutingConfig{}
				if r.ko.Spec.DeploymentConfig.BlueGreenUpdatePolicy.TrafficRoutingConfiguration.CanarySize != nil {
					f0f1f2f0 := &svcsdk.CapacitySize{}
					if r.ko.Spec.DeploymentConfig.BlueGreenUpdatePolicy.TrafficRoutingConfiguration.CanarySize.Type != nil {
						f0f1f2f0.SetType(*r.ko.Spec.DeploymentConfig.BlueGreenUpdatePolicy.TrafficRoutingConfiguration.CanarySize.Type)
					}
					if r.ko.Spec.DeploymentConfig.BlueGreenUpdatePolicy.TrafficRoutingConfiguration.CanarySize.Value != nil {
						f0f1f2f0.SetValue(*r.ko.Spec.DeploymentConfig.BlueGreenUpdatePolicy.TrafficRoutingConfiguration.CanarySize.Value)
					}
					f0f1f2.SetCanarySize(f0f1f2f0)
				}
				if r.ko.Spec.DeploymentConfig.BlueGreenUpdatePolicy.TrafficRoutingConfiguration.LinearStepSize != nil {
					f0f1f2f1 := &svcsdk.CapacitySize{}
					if r.ko.Spec.DeploymentConfig.BlueGreenUpdatePolicy.TrafficRoutingConfiguration.LinearStepSize.Type != nil {
						f0f1f2f1.SetType(*r.ko.Spec.DeploymentConfig.BlueGreenUpdatePolicy.TrafficRoutingConfiguration.LinearStepSize.Type)
					}
					if r.ko.Spec.DeploymentConfig.BlueGreenUpdatePolicy.TrafficRoutingConfiguration.LinearStepSize.Value != nil {
						f0f1f2f1.SetValue(*r.ko.Spec.DeploymentConfig.BlueGreenUpdatePolicy.TrafficRoutingConfiguration.LinearStepSize.Value)
					}
					f0f1f2.SetLinearStepSize(f0f1f2f1)
				}
				if r.ko.Spec.DeploymentConfig.BlueGreenUpdatePolicy.TrafficRoutingConfiguration.Type != nil {
					f0f1f2.SetType(*r.ko.Spec.DeploymentConfig.BlueGreenUpdatePolicy.TrafficRoutingConfiguration.Type)
				}
				if r.ko.Spec.DeploymentConfig.BlueGreenUpdatePolicy.TrafficRoutingConfiguration.WaitIntervalInSeconds != nil {
					f0f1f2.SetWaitIntervalInSeconds(*r.ko.Spec.DeploymentConfig.BlueGreenUpdatePolicy.TrafficRoutingConfiguration.WaitIntervalInSeconds)
				}
				f0f1.SetTrafficRoutingConfiguration(f0f1f2)
			}
			f0.SetBlueGreenUpdatePolicy(f0f1)
		}
		if r.ko.Spec.DeploymentConfig.RollingUpdatePolicy != nil {
			f0f2 := &svcsdk.RollingUpdatePolicy{}
			if r.ko.Spec.DeploymentConfig.RollingUpdatePolicy.MaximumBatchSize != nil {
				f0f2f0 := &svcsdk.CapacitySize{}
				if r.ko.Spec.DeploymentConfig.RollingUpdatePolicy.MaximumBatchSize.Type != nil {
					f0f2f0.SetType(*r.ko.Spec.DeploymentConfig.RollingUpdatePolicy.MaximumBatchSize.Type)
				}
				if r.ko.Spec.DeploymentConfig.RollingUpdatePolicy.MaximumBatchSize.Value != nil {
					f0f2f0.SetValue(*r.ko.Spec.DeploymentConfig.RollingUpdatePolicy.MaximumBatchSize.Value)
				}
				f0f2.SetMaximumBatchSize(f0f2f0)
			}
			if r.ko.Spec.DeploymentConfig.RollingUpdatePolicy.MaximumExecutionTimeoutInSeconds != nil {
				f0f2.SetMaximumExecutionTimeoutInSeconds(*r.ko.Spec.DeploymentConfig.RollingUpdatePolicy.MaximumExecutionTimeoutInSeconds)
			}
			if r.ko.Spec.DeploymentConfig.RollingUpdatePolicy.RollbackMaximumBatchSize != nil {
				f0f2f2 := &svcsdk.CapacitySize{}
				if r.ko.Spec.DeploymentConfig.RollingUpdatePolicy.RollbackMaximumBatchSize.Type != nil {
					f0f2f2.SetType(*r.ko.Spec.DeploymentConfig.RollingUpdatePolicy.RollbackMaximumBatchSize.Type)
				}
				if r.ko.Spec.DeploymentConfig.RollingUpdatePolicy.RollbackMaximumBatchSize.Value != nil {
					f0f2f2.SetValue(*r.ko.Spec.DeploymentConfig.RollingUpdatePolicy.RollbackMaximumBatchSize.Value)
				}
				f0f2.SetRollbackMaximumBatchSize(f0f2f2)
			}
			if r.ko.Spec.DeploymentConfig.RollingUpdatePolicy.WaitIntervalInSeconds != nil {
				f0f2.SetWaitIntervalInSeconds(*r.ko.Spec.DeploymentConfig.RollingUpdatePolicy.WaitIntervalInSeconds)
			}
			f0.SetRollingUpdatePolicy(f0f2)
		}
		res.SetDeploymentConfig(f0)
	}
	if r.ko.Spec.EndpointConfigName != nil {
		res.SetEndpointConfigName(*r.ko.Spec.EndpointConfigName)
	}
	if r.ko.Spec.EndpointName != nil {
		res.SetEndpointName(*r.ko.Spec.EndpointName)
	}
	if r.ko.Spec.Tags != nil {
		f3 := []*svcsdk.Tag{}
		for _, f3iter := range r.ko.Spec.Tags {
			f3elem := &svcsdk.Tag{}
			if f3iter.Key != nil {
				f3elem.SetKey(*f3iter.Key)
			}
			if f3iter.Value != nil {
				f3elem.SetValue(*f3iter.Value)
			}
			f3 = append(f3, f3elem)
		}
		res.SetTags(f3)
	}

	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,
) (updated *resource, err error) {
	rlog := ackrtlog.FromContext(ctx)
	exit := rlog.Trace("rm.sdkUpdate")
	defer func() {
		exit(err)
	}()
	if err = rm.requeueUntilCanModify(ctx, latest); err != nil {
		return nil, err
	}

	if err = rm.customUpdateEndpointPreChecks(ctx, desired, latest, delta); err != nil {
		return nil, err
	}

	input, err := rm.newUpdateRequestPayload(ctx, desired, delta)
	if err != nil {
		return nil, err
	}

	var resp *svcsdk.UpdateEndpointOutput
	_ = resp
	resp, err = rm.sdkapi.UpdateEndpointWithContext(ctx, input)
	rm.metrics.RecordAPICall("UPDATE", "UpdateEndpoint", 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 ko.Status.ACKResourceMetadata == nil {
		ko.Status.ACKResourceMetadata = &ackv1alpha1.ResourceMetadata{}
	}
	if resp.EndpointArn != nil {
		arn := ackv1alpha1.AWSResourceName(*resp.EndpointArn)
		ko.Status.ACKResourceMetadata.ARN = &arn
	}

	rm.setStatusDefaults(ko)
	rm.customUpdateEndpointSetOutput(ko)
	return &resource{ko}, nil
}

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

	if r.ko.Spec.DeploymentConfig != nil {
		f0 := &svcsdk.DeploymentConfig{}
		if r.ko.Spec.DeploymentConfig.AutoRollbackConfiguration != nil {
			f0f0 := &svcsdk.AutoRollbackConfig{}
			if r.ko.Spec.DeploymentConfig.AutoRollbackConfiguration.Alarms != nil {
				f0f0f0 := []*svcsdk.Alarm{}
				for _, f0f0f0iter := range r.ko.Spec.DeploymentConfig.AutoRollbackConfiguration.Alarms {
					f0f0f0elem := &svcsdk.Alarm{}
					if f0f0f0iter.AlarmName != nil {
						f0f0f0elem.SetAlarmName(*f0f0f0iter.AlarmName)
					}
					f0f0f0 = append(f0f0f0, f0f0f0elem)
				}
				f0f0.SetAlarms(f0f0f0)
			}
			f0.SetAutoRollbackConfiguration(f0f0)
		}
		if r.ko.Spec.DeploymentConfig.BlueGreenUpdatePolicy != nil {
			f0f1 := &svcsdk.BlueGreenUpdatePolicy{}
			if r.ko.Spec.DeploymentConfig.BlueGreenUpdatePolicy.MaximumExecutionTimeoutInSeconds != nil {
				f0f1.SetMaximumExecutionTimeoutInSeconds(*r.ko.Spec.DeploymentConfig.BlueGreenUpdatePolicy.MaximumExecutionTimeoutInSeconds)
			}
			if r.ko.Spec.DeploymentConfig.BlueGreenUpdatePolicy.TerminationWaitInSeconds != nil {
				f0f1.SetTerminationWaitInSeconds(*r.ko.Spec.DeploymentConfig.BlueGreenUpdatePolicy.TerminationWaitInSeconds)
			}
			if r.ko.Spec.DeploymentConfig.BlueGreenUpdatePolicy.TrafficRoutingConfiguration != nil {
				f0f1f2 := &svcsdk.TrafficRoutingConfig{}
				if r.ko.Spec.DeploymentConfig.BlueGreenUpdatePolicy.TrafficRoutingConfiguration.CanarySize != nil {
					f0f1f2f0 := &svcsdk.CapacitySize{}
					if r.ko.Spec.DeploymentConfig.BlueGreenUpdatePolicy.TrafficRoutingConfiguration.CanarySize.Type != nil {
						f0f1f2f0.SetType(*r.ko.Spec.DeploymentConfig.BlueGreenUpdatePolicy.TrafficRoutingConfiguration.CanarySize.Type)
					}
					if r.ko.Spec.DeploymentConfig.BlueGreenUpdatePolicy.TrafficRoutingConfiguration.CanarySize.Value != nil {
						f0f1f2f0.SetValue(*r.ko.Spec.DeploymentConfig.BlueGreenUpdatePolicy.TrafficRoutingConfiguration.CanarySize.Value)
					}
					f0f1f2.SetCanarySize(f0f1f2f0)
				}
				if r.ko.Spec.DeploymentConfig.BlueGreenUpdatePolicy.TrafficRoutingConfiguration.LinearStepSize != nil {
					f0f1f2f1 := &svcsdk.CapacitySize{}
					if r.ko.Spec.DeploymentConfig.BlueGreenUpdatePolicy.TrafficRoutingConfiguration.LinearStepSize.Type != nil {
						f0f1f2f1.SetType(*r.ko.Spec.DeploymentConfig.BlueGreenUpdatePolicy.TrafficRoutingConfiguration.LinearStepSize.Type)
					}
					if r.ko.Spec.DeploymentConfig.BlueGreenUpdatePolicy.TrafficRoutingConfiguration.LinearStepSize.Value != nil {
						f0f1f2f1.SetValue(*r.ko.Spec.DeploymentConfig.BlueGreenUpdatePolicy.TrafficRoutingConfiguration.LinearStepSize.Value)
					}
					f0f1f2.SetLinearStepSize(f0f1f2f1)
				}
				if r.ko.Spec.DeploymentConfig.BlueGreenUpdatePolicy.TrafficRoutingConfiguration.Type != nil {
					f0f1f2.SetType(*r.ko.Spec.DeploymentConfig.BlueGreenUpdatePolicy.TrafficRoutingConfiguration.Type)
				}
				if r.ko.Spec.DeploymentConfig.BlueGreenUpdatePolicy.TrafficRoutingConfiguration.WaitIntervalInSeconds != nil {
					f0f1f2.SetWaitIntervalInSeconds(*r.ko.Spec.DeploymentConfig.BlueGreenUpdatePolicy.TrafficRoutingConfiguration.WaitIntervalInSeconds)
				}
				f0f1.SetTrafficRoutingConfiguration(f0f1f2)
			}
			f0.SetBlueGreenUpdatePolicy(f0f1)
		}
		if r.ko.Spec.DeploymentConfig.RollingUpdatePolicy != nil {
			f0f2 := &svcsdk.RollingUpdatePolicy{}
			if r.ko.Spec.DeploymentConfig.RollingUpdatePolicy.MaximumBatchSize != nil {
				f0f2f0 := &svcsdk.CapacitySize{}
				if r.ko.Spec.DeploymentConfig.RollingUpdatePolicy.MaximumBatchSize.Type != nil {
					f0f2f0.SetType(*r.ko.Spec.DeploymentConfig.RollingUpdatePolicy.MaximumBatchSize.Type)
				}
				if r.ko.Spec.DeploymentConfig.RollingUpdatePolicy.MaximumBatchSize.Value != nil {
					f0f2f0.SetValue(*r.ko.Spec.DeploymentConfig.RollingUpdatePolicy.MaximumBatchSize.Value)
				}
				f0f2.SetMaximumBatchSize(f0f2f0)
			}
			if r.ko.Spec.DeploymentConfig.RollingUpdatePolicy.MaximumExecutionTimeoutInSeconds != nil {
				f0f2.SetMaximumExecutionTimeoutInSeconds(*r.ko.Spec.DeploymentConfig.RollingUpdatePolicy.MaximumExecutionTimeoutInSeconds)
			}
			if r.ko.Spec.DeploymentConfig.RollingUpdatePolicy.RollbackMaximumBatchSize != nil {
				f0f2f2 := &svcsdk.CapacitySize{}
				if r.ko.Spec.DeploymentConfig.RollingUpdatePolicy.RollbackMaximumBatchSize.Type != nil {
					f0f2f2.SetType(*r.ko.Spec.DeploymentConfig.RollingUpdatePolicy.RollbackMaximumBatchSize.Type)
				}
				if r.ko.Spec.DeploymentConfig.RollingUpdatePolicy.RollbackMaximumBatchSize.Value != nil {
					f0f2f2.SetValue(*r.ko.Spec.DeploymentConfig.RollingUpdatePolicy.RollbackMaximumBatchSize.Value)
				}
				f0f2.SetRollbackMaximumBatchSize(f0f2f2)
			}
			if r.ko.Spec.DeploymentConfig.RollingUpdatePolicy.WaitIntervalInSeconds != nil {
				f0f2.SetWaitIntervalInSeconds(*r.ko.Spec.DeploymentConfig.RollingUpdatePolicy.WaitIntervalInSeconds)
			}
			f0.SetRollingUpdatePolicy(f0f2)
		}
		res.SetDeploymentConfig(f0)
	}
	if r.ko.Spec.EndpointConfigName != nil {
		res.SetEndpointConfigName(*r.ko.Spec.EndpointConfigName)
	}
	if r.ko.Spec.EndpointName != nil {
		res.SetEndpointName(*r.ko.Spec.EndpointName)
	}
	res.SetRetainAllVariantProperties(true)

	return res, nil
}

// 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)
	}()
	if err = rm.requeueUntilCanModify(ctx, r); err != nil {
		return r, err
	}

	input, err := rm.newDeleteRequestPayload(r)
	if err != nil {
		return nil, err
	}
	var resp *svcsdk.DeleteEndpointOutput
	_ = resp
	resp, err = rm.sdkapi.DeleteEndpointWithContext(ctx, input)
	rm.metrics.RecordAPICall("DELETE", "DeleteEndpoint", err)

	if err == nil {
		if observed, err := rm.sdkFind(ctx, r); err != ackerr.NotFound {
			if err != nil {
				return nil, err
			}
			r.SetStatus(observed)
			return r, requeueWaitWhileDeleting
		}
	}

	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.DeleteEndpointInput, error) {
	res := &svcsdk.DeleteEndpointInput{}

	if r.ko.Spec.EndpointName != nil {
		res.SetEndpointName(*r.ko.Spec.EndpointName)
	}

	return res, nil
}

// setStatusDefaults sets default properties into supplied custom resource
func (rm *resourceManager) setStatusDefaults(
	ko *svcapitypes.Endpoint,
) {
	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
		}
	}
	if syncCondition == nil && onSuccess {
		syncCondition = &ackv1alpha1.Condition{
			Type:   ackv1alpha1.ConditionTypeResourceSynced,
			Status: corev1.ConditionTrue,
		}
		ko.Status.Conditions = append(ko.Status.Conditions, syncCondition)
	}
	// custom update conditions
	customUpdate := rm.CustomUpdateConditions(ko, r, err)
	if terminalCondition != nil || recoverableCondition != nil || syncCondition != nil || customUpdate {
		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 {
	if err == nil {
		return false
	}
	awsErr, ok := ackerr.AWSError(err)
	if !ok {
		return false
	}
	switch awsErr.Code() {
	case "InvalidParameterCombination",
		"InvalidParameterValue",
		"MissingParameter",
		"EndpointUpdateError":
		return true
	default:
		return false
	}
}