From 2f9541504c2559fcb7b7a89219052290e9494fa5 Mon Sep 17 00:00:00 2001 From: AWS SDK for Go v2 automation user Date: Tue, 20 Jun 2023 19:47:41 +0000 Subject: [PATCH] Regenerated Clients --- .../20f2e68d0da24448ab85e344d9a98908.json | 8 + .../57dd8bdb626a4f169159595dc98c7ff0.json | 8 + .../68e0f755a60c4d9882d07cf1bb5f9a9e.json | 8 + .../b03034941f4f4cc99735ceb2de5c3ac8.json | 8 + .../c61109e9e0c3477e8a2c0b388bd1dc86.json | 8 + .../api_op_ResetConnectorMetadataCache.go | 163 ++ service/appflow/deserializers.go | 92 + service/appflow/generated.json | 1 + service/appflow/serializers.go | 88 + service/configservice/types/enums.go | 42 + service/ec2/api_op_AllocateHosts.go | 26 +- service/ec2/api_op_CreateFleet.go | 8 +- service/ec2/api_op_DescribeInstanceTypes.go | 7 + service/ec2/api_op_ModifyInstancePlacement.go | 10 +- service/ec2/api_op_RunInstances.go | 5 + service/ec2/deserializers.go | 13 + service/ec2/serializers.go | 17 + service/ec2/types/types.go | 26 +- service/ec2/validators.go | 3 - service/lambda/deserializers.go | 91 + service/lambda/types/errors.go | 29 + .../nimble/internal/endpoints/endpoints.go | 15 + .../api_op_AuthorizeSnapshotAccess.go | 4 +- .../redshift/api_op_CopyClusterSnapshot.go | 6 +- service/redshift/api_op_CreateCluster.go | 8 +- .../api_op_CreateCustomDomainAssociation.go | 146 ++ .../redshift/api_op_DeleteClusterSnapshot.go | 6 +- .../api_op_DeleteCustomDomainAssociation.go | 119 + .../api_op_DescribeClusterSnapshots.go | 4 +- ...api_op_DescribeCustomDomainAssociations.go | 225 ++ .../redshift/api_op_GetClusterCredentials.go | 13 +- .../api_op_GetClusterCredentialsWithIAM.go | 8 +- service/redshift/api_op_ModifyCluster.go | 4 +- .../api_op_ModifyCustomDomainAssociation.go | 143 ++ .../api_op_RestoreFromClusterSnapshot.go | 4 +- .../redshift/api_op_RevokeSnapshotAccess.go | 4 +- service/redshift/deserializers.go | 1984 +++++++++++++---- service/redshift/generated.json | 4 + service/redshift/serializers.go | 349 +++ service/redshift/types/errors.go | 55 + service/redshift/types/types.go | 45 +- service/redshift/validators.go | 165 +- 42 files changed, 3459 insertions(+), 513 deletions(-) create mode 100644 .changelog/20f2e68d0da24448ab85e344d9a98908.json create mode 100644 .changelog/57dd8bdb626a4f169159595dc98c7ff0.json create mode 100644 .changelog/68e0f755a60c4d9882d07cf1bb5f9a9e.json create mode 100644 .changelog/b03034941f4f4cc99735ceb2de5c3ac8.json create mode 100644 .changelog/c61109e9e0c3477e8a2c0b388bd1dc86.json create mode 100644 service/appflow/api_op_ResetConnectorMetadataCache.go create mode 100644 service/redshift/api_op_CreateCustomDomainAssociation.go create mode 100644 service/redshift/api_op_DeleteCustomDomainAssociation.go create mode 100644 service/redshift/api_op_DescribeCustomDomainAssociations.go create mode 100644 service/redshift/api_op_ModifyCustomDomainAssociation.go diff --git a/.changelog/20f2e68d0da24448ab85e344d9a98908.json b/.changelog/20f2e68d0da24448ab85e344d9a98908.json new file mode 100644 index 00000000000..3fa262f859b --- /dev/null +++ b/.changelog/20f2e68d0da24448ab85e344d9a98908.json @@ -0,0 +1,8 @@ +{ + "id": "20f2e68d-0da2-4448-ab85-e344d9a98908", + "type": "feature", + "description": "Updated ResourceType enum with new resource types onboarded by AWS Config in May 2023.", + "modules": [ + "service/configservice" + ] +} \ No newline at end of file diff --git a/.changelog/57dd8bdb626a4f169159595dc98c7ff0.json b/.changelog/57dd8bdb626a4f169159595dc98c7ff0.json new file mode 100644 index 00000000000..2040c41f8cd --- /dev/null +++ b/.changelog/57dd8bdb626a4f169159595dc98c7ff0.json @@ -0,0 +1,8 @@ +{ + "id": "57dd8bdb-626a-4f16-9159-595dc98c7ff0", + "type": "feature", + "description": "This release adds new API to reset connector metadata cache", + "modules": [ + "service/appflow" + ] +} \ No newline at end of file diff --git a/.changelog/68e0f755a60c4d9882d07cf1bb5f9a9e.json b/.changelog/68e0f755a60c4d9882d07cf1bb5f9a9e.json new file mode 100644 index 00000000000..3cdb0991b7e --- /dev/null +++ b/.changelog/68e0f755a60c4d9882d07cf1bb5f9a9e.json @@ -0,0 +1,8 @@ +{ + "id": "68e0f755-a60c-4d98-82d0-7cf1bb5f9a9e", + "type": "feature", + "description": "Added support for custom domain names for Redshift Provisioned clusters. This feature enables customers to create a custom domain name and use ACM to generate fully secure connections to it.", + "modules": [ + "service/redshift" + ] +} \ No newline at end of file diff --git a/.changelog/b03034941f4f4cc99735ceb2de5c3ac8.json b/.changelog/b03034941f4f4cc99735ceb2de5c3ac8.json new file mode 100644 index 00000000000..82237a6412e --- /dev/null +++ b/.changelog/b03034941f4f4cc99735ceb2de5c3ac8.json @@ -0,0 +1,8 @@ +{ + "id": "b0303494-1f4f-4cc9-9735-ceb2de5c3ac8", + "type": "feature", + "description": "Adds support for targeting Dedicated Host allocations by assetIds in AWS Outposts", + "modules": [ + "service/ec2" + ] +} \ No newline at end of file diff --git a/.changelog/c61109e9e0c3477e8a2c0b388bd1dc86.json b/.changelog/c61109e9e0c3477e8a2c0b388bd1dc86.json new file mode 100644 index 00000000000..af31e3a43ac --- /dev/null +++ b/.changelog/c61109e9e0c3477e8a2c0b388bd1dc86.json @@ -0,0 +1,8 @@ +{ + "id": "c61109e9-e0c3-477e-8a2c-0b388bd1dc86", + "type": "feature", + "description": "This release adds RecursiveInvocationException to the Invoke API and InvokeWithResponseStream API.", + "modules": [ + "service/lambda" + ] +} \ No newline at end of file diff --git a/service/appflow/api_op_ResetConnectorMetadataCache.go b/service/appflow/api_op_ResetConnectorMetadataCache.go new file mode 100644 index 00000000000..09569b88556 --- /dev/null +++ b/service/appflow/api_op_ResetConnectorMetadataCache.go @@ -0,0 +1,163 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package appflow + +import ( + "context" + awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" + "github.com/aws/aws-sdk-go-v2/aws/signer/v4" + "github.com/aws/aws-sdk-go-v2/service/appflow/types" + "github.com/aws/smithy-go/middleware" + smithyhttp "github.com/aws/smithy-go/transport/http" +) + +// Resets metadata about your connector entities that Amazon AppFlow stored in its +// cache. Use this action when you want Amazon AppFlow to return the latest +// information about the data that you have in a source application. Amazon AppFlow +// returns metadata about your entities when you use the ListConnectorEntities or +// DescribeConnectorEntities actions. Following these actions, Amazon AppFlow +// caches the metadata to reduce the number of API requests that it must send to +// the source application. Amazon AppFlow automatically resets the cache once every +// hour, but you can use this action when you want to get the latest metadata right +// away. +func (c *Client) ResetConnectorMetadataCache(ctx context.Context, params *ResetConnectorMetadataCacheInput, optFns ...func(*Options)) (*ResetConnectorMetadataCacheOutput, error) { + if params == nil { + params = &ResetConnectorMetadataCacheInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "ResetConnectorMetadataCache", params, optFns, c.addOperationResetConnectorMetadataCacheMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*ResetConnectorMetadataCacheOutput) + out.ResultMetadata = metadata + return out, nil +} + +type ResetConnectorMetadataCacheInput struct { + + // The API version that you specified in the connector profile that you’re + // resetting cached metadata for. You must use this parameter only if the connector + // supports multiple API versions or if the connector type is CustomConnector. To + // look up how many versions a connector supports, use the DescribeConnectors + // action. In the response, find the value that Amazon AppFlow returns for the + // connectorVersion parameter. To look up the connector type, use the + // DescribeConnectorProfiles action. In the response, find the value that Amazon + // AppFlow returns for the connectorType parameter. To look up the API version that + // you specified in a connector profile, use the DescribeConnectorProfiles action. + ApiVersion *string + + // Use this parameter if you want to reset cached metadata about the details for + // an individual entity. If you don't include this parameter in your request, + // Amazon AppFlow only resets cached metadata about entity names, not entity + // details. + ConnectorEntityName *string + + // The name of the connector profile that you want to reset cached metadata for. + // You can omit this parameter if you're resetting the cache for any of the + // following connectors: Amazon Connect, Amazon EventBridge, Amazon Lookout for + // Metrics, Amazon S3, or Upsolver. If you're resetting the cache for any other + // connector, you must include this parameter in your request. + ConnectorProfileName *string + + // The type of connector to reset cached metadata for. You must include this + // parameter in your request if you're resetting the cache for any of the following + // connectors: Amazon Connect, Amazon EventBridge, Amazon Lookout for Metrics, + // Amazon S3, or Upsolver. If you're resetting the cache for any other connector, + // you can omit this parameter from your request. + ConnectorType types.ConnectorType + + // Use this parameter only if you’re resetting the cached metadata about a nested + // entity. Only some connectors support nested entities. A nested entity is one + // that has another entity as a parent. To use this parameter, specify the name of + // the parent entity. To look up the parent-child relationship of entities, you can + // send a ListConnectorEntities request that omits the entitiesPath parameter. + // Amazon AppFlow will return a list of top-level entities. For each one, it + // indicates whether the entity has nested entities. Then, in a subsequent + // ListConnectorEntities request, you can specify a parent entity name for the + // entitiesPath parameter. Amazon AppFlow will return a list of the child entities + // for that parent. + EntitiesPath *string + + noSmithyDocumentSerde +} + +type ResetConnectorMetadataCacheOutput struct { + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (c *Client) addOperationResetConnectorMetadataCacheMiddlewares(stack *middleware.Stack, options Options) (err error) { + err = stack.Serialize.Add(&awsRestjson1_serializeOpResetConnectorMetadataCache{}, middleware.After) + if err != nil { + return err + } + err = stack.Deserialize.Add(&awsRestjson1_deserializeOpResetConnectorMetadataCache{}, middleware.After) + if err != nil { + return err + } + if err = addSetLoggerMiddleware(stack, options); err != nil { + return err + } + if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil { + return err + } + if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil { + return err + } + if err = addResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil { + return err + } + if err = addRetryMiddlewares(stack, options); err != nil { + return err + } + if err = addHTTPSignerV4Middleware(stack, options); err != nil { + return err + } + if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil { + return err + } + if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil { + return err + } + if err = addClientUserAgent(stack); err != nil { + return err + } + if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil { + return err + } + if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { + return err + } + if err = stack.Initialize.Add(newServiceMetadataMiddleware_opResetConnectorMetadataCache(options.Region), middleware.Before); err != nil { + return err + } + if err = awsmiddleware.AddRecursionDetection(stack); err != nil { + return err + } + if err = addRequestIDRetrieverMiddleware(stack); err != nil { + return err + } + if err = addResponseErrorMiddleware(stack); err != nil { + return err + } + if err = addRequestResponseLogging(stack, options); err != nil { + return err + } + return nil +} + +func newServiceMetadataMiddleware_opResetConnectorMetadataCache(region string) *awsmiddleware.RegisterServiceMetadata { + return &awsmiddleware.RegisterServiceMetadata{ + Region: region, + ServiceID: ServiceID, + SigningName: "appflow", + OperationName: "ResetConnectorMetadataCache", + } +} diff --git a/service/appflow/deserializers.go b/service/appflow/deserializers.go index c11a3f23c15..f117c79cd43 100644 --- a/service/appflow/deserializers.go +++ b/service/appflow/deserializers.go @@ -2611,6 +2611,98 @@ func awsRestjson1_deserializeOpDocumentRegisterConnectorOutput(v **RegisterConne return nil } +type awsRestjson1_deserializeOpResetConnectorMetadataCache struct { +} + +func (*awsRestjson1_deserializeOpResetConnectorMetadataCache) ID() string { + return "OperationDeserializer" +} + +func (m *awsRestjson1_deserializeOpResetConnectorMetadataCache) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( + out middleware.DeserializeOutput, metadata middleware.Metadata, err error, +) { + out, metadata, err = next.HandleDeserialize(ctx, in) + if err != nil { + return out, metadata, err + } + + response, ok := out.RawResponse.(*smithyhttp.Response) + if !ok { + return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} + } + + if response.StatusCode < 200 || response.StatusCode >= 300 { + return out, metadata, awsRestjson1_deserializeOpErrorResetConnectorMetadataCache(response, &metadata) + } + output := &ResetConnectorMetadataCacheOutput{} + out.Result = output + + return out, metadata, err +} + +func awsRestjson1_deserializeOpErrorResetConnectorMetadataCache(response *smithyhttp.Response, metadata *middleware.Metadata) error { + var errorBuffer bytes.Buffer + if _, err := io.Copy(&errorBuffer, response.Body); err != nil { + return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} + } + errorBody := bytes.NewReader(errorBuffer.Bytes()) + + errorCode := "UnknownError" + errorMessage := errorCode + + headerCode := response.Header.Get("X-Amzn-ErrorType") + if len(headerCode) != 0 { + errorCode = restjson.SanitizeErrorCode(headerCode) + } + + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + + body := io.TeeReader(errorBody, ringBuffer) + decoder := json.NewDecoder(body) + decoder.UseNumber() + jsonCode, message, err := restjson.GetErrorInfo(decoder) + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return err + } + + errorBody.Seek(0, io.SeekStart) + if len(headerCode) == 0 && len(jsonCode) != 0 { + errorCode = restjson.SanitizeErrorCode(jsonCode) + } + if len(message) != 0 { + errorMessage = message + } + + switch { + case strings.EqualFold("ConflictException", errorCode): + return awsRestjson1_deserializeErrorConflictException(response, errorBody) + + case strings.EqualFold("InternalServerException", errorCode): + return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) + + case strings.EqualFold("ResourceNotFoundException", errorCode): + return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) + + case strings.EqualFold("ValidationException", errorCode): + return awsRestjson1_deserializeErrorValidationException(response, errorBody) + + default: + genericError := &smithy.GenericAPIError{ + Code: errorCode, + Message: errorMessage, + } + return genericError + + } +} + type awsRestjson1_deserializeOpStartFlow struct { } diff --git a/service/appflow/generated.json b/service/appflow/generated.json index 20f11fd7e56..b002bc898c8 100644 --- a/service/appflow/generated.json +++ b/service/appflow/generated.json @@ -24,6 +24,7 @@ "api_op_ListFlows.go", "api_op_ListTagsForResource.go", "api_op_RegisterConnector.go", + "api_op_ResetConnectorMetadataCache.go", "api_op_StartFlow.go", "api_op_StopFlow.go", "api_op_TagResource.go", diff --git a/service/appflow/serializers.go b/service/appflow/serializers.go index 8e70bbaf607..8d3dfd8a3a7 100644 --- a/service/appflow/serializers.go +++ b/service/appflow/serializers.go @@ -1320,6 +1320,94 @@ func awsRestjson1_serializeOpDocumentRegisterConnectorInput(v *RegisterConnector return nil } +type awsRestjson1_serializeOpResetConnectorMetadataCache struct { +} + +func (*awsRestjson1_serializeOpResetConnectorMetadataCache) ID() string { + return "OperationSerializer" +} + +func (m *awsRestjson1_serializeOpResetConnectorMetadataCache) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( + out middleware.SerializeOutput, metadata middleware.Metadata, err error, +) { + request, ok := in.Request.(*smithyhttp.Request) + if !ok { + return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} + } + + input, ok := in.Parameters.(*ResetConnectorMetadataCacheInput) + _ = input + if !ok { + return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} + } + + opPath, opQuery := httpbinding.SplitURI("/reset-connector-metadata-cache") + request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) + request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) + request.Method = "POST" + restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) + if err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + restEncoder.SetHeader("Content-Type").String("application/json") + + jsonEncoder := smithyjson.NewEncoder() + if err := awsRestjson1_serializeOpDocumentResetConnectorMetadataCacheInput(input, jsonEncoder.Value); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + if request.Request, err = restEncoder.Encode(request.Request); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + in.Request = request + + return next.HandleSerialize(ctx, in) +} +func awsRestjson1_serializeOpHttpBindingsResetConnectorMetadataCacheInput(v *ResetConnectorMetadataCacheInput, encoder *httpbinding.Encoder) error { + if v == nil { + return fmt.Errorf("unsupported serialization of nil %T", v) + } + + return nil +} + +func awsRestjson1_serializeOpDocumentResetConnectorMetadataCacheInput(v *ResetConnectorMetadataCacheInput, value smithyjson.Value) error { + object := value.Object() + defer object.Close() + + if v.ApiVersion != nil { + ok := object.Key("apiVersion") + ok.String(*v.ApiVersion) + } + + if v.ConnectorEntityName != nil { + ok := object.Key("connectorEntityName") + ok.String(*v.ConnectorEntityName) + } + + if v.ConnectorProfileName != nil { + ok := object.Key("connectorProfileName") + ok.String(*v.ConnectorProfileName) + } + + if len(v.ConnectorType) > 0 { + ok := object.Key("connectorType") + ok.String(string(v.ConnectorType)) + } + + if v.EntitiesPath != nil { + ok := object.Key("entitiesPath") + ok.String(*v.EntitiesPath) + } + + return nil +} + type awsRestjson1_serializeOpStartFlow struct { } diff --git a/service/configservice/types/enums.go b/service/configservice/types/enums.go index ef1e5422f6f..5b0180a8438 100644 --- a/service/configservice/types/enums.go +++ b/service/configservice/types/enums.go @@ -955,6 +955,27 @@ const ( ResourceTypeRoute53ResolverFirewallRuleGroupAssociation ResourceType = "AWS::Route53Resolver::FirewallRuleGroupAssociation" ResourceTypeSageMakerAppImageConfig ResourceType = "AWS::SageMaker::AppImageConfig" ResourceTypeSageMakerImage ResourceType = "AWS::SageMaker::Image" + ResourceTypeECSTaskSet ResourceType = "AWS::ECS::TaskSet" + ResourceTypeCassandraKeyspace ResourceType = "AWS::Cassandra::Keyspace" + ResourceTypeSignerSigningProfile ResourceType = "AWS::Signer::SigningProfile" + ResourceTypeAmplifyApp ResourceType = "AWS::Amplify::App" + ResourceTypeAppMeshVirtualNode ResourceType = "AWS::AppMesh::VirtualNode" + ResourceTypeAppMeshVirtualService ResourceType = "AWS::AppMesh::VirtualService" + ResourceTypeAppRunnerVpcConnector ResourceType = "AWS::AppRunner::VpcConnector" + ResourceTypeAppStreamApplication ResourceType = "AWS::AppStream::Application" + ResourceTypeCodeArtifactRepository ResourceType = "AWS::CodeArtifact::Repository" + ResourceTypeEC2PrefixList ResourceType = "AWS::EC2::PrefixList" + ResourceTypeEC2SpotFleet ResourceType = "AWS::EC2::SpotFleet" + ResourceTypeEvidentlyProject ResourceType = "AWS::Evidently::Project" + ResourceTypeForecastDataset ResourceType = "AWS::Forecast::Dataset" + ResourceTypeIAMSAMLProvider ResourceType = "AWS::IAM::SAMLProvider" + ResourceTypeIAMServerCertificate ResourceType = "AWS::IAM::ServerCertificate" + ResourceTypePinpointCampaign ResourceType = "AWS::Pinpoint::Campaign" + ResourceTypePinpointInAppTemplate ResourceType = "AWS::Pinpoint::InAppTemplate" + ResourceTypeSageMakerDomain ResourceType = "AWS::SageMaker::Domain" + ResourceTypeTransferAgreement ResourceType = "AWS::Transfer::Agreement" + ResourceTypeTransferConnector ResourceType = "AWS::Transfer::Connector" + ResourceTypeKinesisFirehoseDeliveryStream ResourceType = "AWS::KinesisFirehose::DeliveryStream" ) // Values returns all known values for ResourceType. Note that this can be @@ -1259,6 +1280,27 @@ func (ResourceType) Values() []ResourceType { "AWS::Route53Resolver::FirewallRuleGroupAssociation", "AWS::SageMaker::AppImageConfig", "AWS::SageMaker::Image", + "AWS::ECS::TaskSet", + "AWS::Cassandra::Keyspace", + "AWS::Signer::SigningProfile", + "AWS::Amplify::App", + "AWS::AppMesh::VirtualNode", + "AWS::AppMesh::VirtualService", + "AWS::AppRunner::VpcConnector", + "AWS::AppStream::Application", + "AWS::CodeArtifact::Repository", + "AWS::EC2::PrefixList", + "AWS::EC2::SpotFleet", + "AWS::Evidently::Project", + "AWS::Forecast::Dataset", + "AWS::IAM::SAMLProvider", + "AWS::IAM::ServerCertificate", + "AWS::Pinpoint::Campaign", + "AWS::Pinpoint::InAppTemplate", + "AWS::SageMaker::Domain", + "AWS::Transfer::Agreement", + "AWS::Transfer::Connector", + "AWS::KinesisFirehose::DeliveryStream", } } diff --git a/service/ec2/api_op_AllocateHosts.go b/service/ec2/api_op_AllocateHosts.go index f372406fd81..2714816e623 100644 --- a/service/ec2/api_op_AllocateHosts.go +++ b/service/ec2/api_op_AllocateHosts.go @@ -36,10 +36,16 @@ type AllocateHostsInput struct { // This member is required. AvailabilityZone *string - // The number of Dedicated Hosts to allocate to your account with these parameters. - // - // This member is required. - Quantity *int32 + // The IDs of the Outpost hardware assets on which to allocate the Dedicated + // Hosts. Targeting specific hardware assets on an Outpost can help to minimize + // latency between your workloads. This parameter is supported only if you specify + // OutpostArn. If you are allocating the Dedicated Hosts in a Region, omit this + // parameter. + // - If you specify this parameter, you can omit Quantity. In this case, Amazon + // EC2 allocates a Dedicated Host on each specified hardware asset. + // - If you specify both AssetIds and Quantity, then the value for Quantity must + // be equal to the number of asset IDs specified. + AssetIds []string // Indicates whether the host accepts any untargeted instance launches that match // its instance type configuration, or if it only accepts Host tenancy instance @@ -79,9 +85,19 @@ type AllocateHostsInput struct { InstanceType *string // The Amazon Resource Name (ARN) of the Amazon Web Services Outpost on which to - // allocate the Dedicated Host. + // allocate the Dedicated Host. If you specify OutpostArn, you can optionally + // specify AssetIds. If you are allocating the Dedicated Host in a Region, omit + // this parameter. OutpostArn *string + // The number of Dedicated Hosts to allocate to your account with these + // parameters. If you are allocating the Dedicated Hosts on an Outpost, and you + // specify AssetIds, you can omit this parameter. In this case, Amazon EC2 + // allocates a Dedicated Host on each specified hardware asset. If you specify both + // AssetIds and Quantity, then the value that you specify for Quantity must be + // equal to the number of asset IDs specified. + Quantity *int32 + // The tags to apply to the Dedicated Host during creation. TagSpecifications []types.TagSpecification diff --git a/service/ec2/api_op_CreateFleet.go b/service/ec2/api_op_CreateFleet.go index e45ca3db6b6..973ee573ea3 100644 --- a/service/ec2/api_op_CreateFleet.go +++ b/service/ec2/api_op_CreateFleet.go @@ -12,9 +12,11 @@ import ( "time" ) -// Launches an EC2 Fleet. You can create a single EC2 Fleet that includes multiple -// launch specifications that vary by instance type, AMI, Availability Zone, or -// subnet. For more information, see EC2 Fleet (https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-fleet.html) +// Creates an EC2 Fleet that contains the configuration information for On-Demand +// Instances and Spot Instances. Instances are launched immediately if there is +// available capacity. A single EC2 Fleet can include multiple launch +// specifications that vary by instance type, AMI, Availability Zone, or subnet. +// For more information, see EC2 Fleet (https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-fleet.html) // in the Amazon EC2 User Guide. func (c *Client) CreateFleet(ctx context.Context, params *CreateFleetInput, optFns ...func(*Options)) (*CreateFleetOutput, error) { if params == nil { diff --git a/service/ec2/api_op_DescribeInstanceTypes.go b/service/ec2/api_op_DescribeInstanceTypes.go index 761b023675e..a07c542468d 100644 --- a/service/ec2/api_op_DescribeInstanceTypes.go +++ b/service/ec2/api_op_DescribeInstanceTypes.go @@ -109,6 +109,8 @@ type DescribeInstanceTypesInput struct { // - processor-info.supported-architecture - The CPU architecture ( arm64 | i386 // | x86_64 ). // - processor-info.sustained-clock-speed-in-ghz - The CPU clock speed, in GHz. + // - processor-info.supported-features - The supported CPU features ( amd-sev-snp + // ). // - supported-boot-mode - The boot mode ( legacy-bios | uefi ). // - supported-root-device-type - The root device type ( ebs | instance-store ). // - supported-usage-class - The usage class ( on-demand | spot ). @@ -144,6 +146,11 @@ type DescribeInstanceTypesInput struct { type DescribeInstanceTypesOutput struct { // The instance type. For more information, see Instance types (https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-types.html) + // in the Amazon EC2 User Guide. When you change your EBS-backed instance type, + // instance restart or replacement behavior depends on the instance type + // compatibility between the old and new types. An instance that's backed by an + // instance store volume is always replaced. For more information, see Change the + // instance type (https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-resize.html) // in the Amazon EC2 User Guide. InstanceTypes []types.InstanceTypeInfo diff --git a/service/ec2/api_op_ModifyInstancePlacement.go b/service/ec2/api_op_ModifyInstancePlacement.go index 4aad7e417a0..1a40d18eac3 100644 --- a/service/ec2/api_op_ModifyInstancePlacement.go +++ b/service/ec2/api_op_ModifyInstancePlacement.go @@ -66,16 +66,18 @@ type ModifyInstancePlacementInput struct { // The ID of the Dedicated Host with which to associate the instance. HostId *string - // The ARN of the host resource group in which to place the instance. + // The ARN of the host resource group in which to place the instance. The instance + // must have a tenancy of host to specify this parameter. HostResourceGroupArn *string // The number of the partition in which to place the instance. Valid only if the // placement group strategy is set to partition . PartitionNumber *int32 - // The tenancy for the instance. For T3 instances, you can't change the tenancy - // from dedicated to host , or from host to dedicated . Attempting to make one of - // these unsupported tenancy changes results in the InvalidTenancy error code. + // The tenancy for the instance. For T3 instances, you must launch the instance on + // a Dedicated Host to use a tenancy of host . You can't change the tenancy from + // host to dedicated or default . Attempting to make one of these unsupported + // tenancy changes results in an InvalidRequest error code. Tenancy types.HostTenancy noSmithyDocumentSerde diff --git a/service/ec2/api_op_RunInstances.go b/service/ec2/api_op_RunInstances.go index 17d3078a9e4..e47358adb2e 100644 --- a/service/ec2/api_op_RunInstances.go +++ b/service/ec2/api_op_RunInstances.go @@ -197,6 +197,11 @@ type RunInstancesInput struct { InstanceMarketOptions *types.InstanceMarketOptionsRequest // The instance type. For more information, see Instance types (https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-types.html) + // in the Amazon EC2 User Guide. When you change your EBS-backed instance type, + // instance restart or replacement behavior depends on the instance type + // compatibility between the old and new types. An instance that's backed by an + // instance store volume is always replaced. For more information, see Change the + // instance type (https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-resize.html) // in the Amazon EC2 User Guide. Default: m1.small InstanceType types.InstanceType diff --git a/service/ec2/deserializers.go b/service/ec2/deserializers.go index 742875aa500..17fec485118 100644 --- a/service/ec2/deserializers.go +++ b/service/ec2/deserializers.go @@ -74732,6 +74732,19 @@ func awsEc2query_deserializeDocumentHost(v **types.Host, decoder smithyxml.NodeD sv.AllowsMultipleInstanceTypes = types.AllowsMultipleInstanceTypes(xtv) } + case strings.EqualFold("assetId", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.AssetId = ptr.String(xtv) + } + case strings.EqualFold("autoPlacement", t.Name.Local): val, err := decoder.Value() if err != nil { diff --git a/service/ec2/serializers.go b/service/ec2/serializers.go index 4fdde5ae76e..d01e6745cd2 100644 --- a/service/ec2/serializers.go +++ b/service/ec2/serializers.go @@ -38283,6 +38283,16 @@ func awsEc2query_serializeDocumentArnList(v []string, value query.Value) error { return nil } +func awsEc2query_serializeDocumentAssetIdList(v []string, value query.Value) error { + array := value.Array("Member") + + for i := range v { + av := array.Value() + av.String(v[i]) + } + return nil +} + func awsEc2query_serializeDocumentAssociationIdList(v []string, value query.Value) error { array := value.Array("AssociationId") @@ -47112,6 +47122,13 @@ func awsEc2query_serializeOpDocumentAllocateHostsInput(v *AllocateHostsInput, va object := value.Object() _ = object + if v.AssetIds != nil { + objectKey := object.FlatKey("AssetId") + if err := awsEc2query_serializeDocumentAssetIdList(v.AssetIds, objectKey); err != nil { + return err + } + } + if len(v.AutoPlacement) > 0 { objectKey := object.Key("AutoPlacement") objectKey.String(string(v.AutoPlacement)) diff --git a/service/ec2/types/types.go b/service/ec2/types/types.go index 183efbb4fa3..352df87d2ba 100644 --- a/service/ec2/types/types.go +++ b/service/ec2/types/types.go @@ -1991,7 +1991,9 @@ type ConversionTask struct { // The CPU options for the instance. type CpuOptions struct { - // Indicates whether the instance is enabled for AMD SEV-SNP. + // Indicates whether the instance is enabled for AMD SEV-SNP. For more + // information, see AMD SEV-SNP (https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/sev-snp.html) + // . AmdSevSnp AmdSevSnpSpecification // The number of CPU cores for the instance. @@ -2008,7 +2010,8 @@ type CpuOptions struct { type CpuOptionsRequest struct { // Indicates whether to enable the instance for AMD SEV-SNP. AMD SEV-SNP is - // supported with M6a, R6a, and C6a instance types only. + // supported with M6a, R6a, and C6a instance types only. For more information, see + // AMD SEV-SNP (https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/sev-snp.html) . AmdSevSnp AmdSevSnpSpecification // The number of CPU cores for the instance. @@ -4160,8 +4163,9 @@ type FleetLaunchTemplateOverrides struct { // The Availability Zone in which to launch the instances. AvailabilityZone *string - // The ID of the AMI. An AMI is required to launch an instance. The AMI ID must be - // specified here or in the launch template. + // The ID of the AMI. An AMI is required to launch an instance. This parameter is + // only available for fleets of type instant . For fleets of type maintain and + // request , you must specify the AMI ID in the launch template. ImageId *string // The attributes for the instance types. When you specify instance attributes, @@ -4210,8 +4214,9 @@ type FleetLaunchTemplateOverridesRequest struct { // The Availability Zone in which to launch the instances. AvailabilityZone *string - // The ID of the AMI. An AMI is required to launch an instance. The AMI ID must be - // specified here or in the launch template. + // The ID of the AMI. An AMI is required to launch an instance. This parameter is + // only available for fleets of type instant . For fleets of type maintain and + // request , you must specify the AMI ID in the launch template. ImageId *string // The attributes for the instance types. When you specify instance attributes, @@ -4705,6 +4710,9 @@ type Host struct { // supports a single instance type only. AllowsMultipleInstanceTypes AllowsMultipleInstanceTypes + // The ID of the Outpost hardware asset on which the Dedicated Host is allocated. + AssetId *string + // Whether auto-placement is on or off. AutoPlacement AutoPlacement @@ -8099,7 +8107,9 @@ type LaunchTemplateCapacityReservationSpecificationResponse struct { // Describes a launch template and overrides. type LaunchTemplateConfig struct { - // The launch template. + // The launch template to use. Make sure that the launch template does not contain + // the NetworkInterfaceId parameter because you can't specify a network interface + // ID in a Spot Fleet. LaunchTemplateSpecification *FleetLaunchTemplateSpecification // Any parameters that you specify override the same parameters in the launch @@ -11186,6 +11196,8 @@ type ProcessorInfo struct { // Indicates whether the instance type supports AMD SEV-SNP. If the request // returns amd-sev-snp , AMD SEV-SNP is supported. Otherwise, it is not supported. + // For more information, see AMD SEV-SNP (https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/sev-snp.html) + // . SupportedFeatures []SupportedAdditionalProcessorFeature // The speed of the processor, in GHz. diff --git a/service/ec2/validators.go b/service/ec2/validators.go index ed973b97a4f..6cb2b405382 100644 --- a/service/ec2/validators.go +++ b/service/ec2/validators.go @@ -11082,9 +11082,6 @@ func validateOpAllocateHostsInput(v *AllocateHostsInput) error { if v.AvailabilityZone == nil { invalidParams.Add(smithy.NewErrParamRequired("AvailabilityZone")) } - if v.Quantity == nil { - invalidParams.Add(smithy.NewErrParamRequired("Quantity")) - } if invalidParams.Len() > 0 { return invalidParams } else { diff --git a/service/lambda/deserializers.go b/service/lambda/deserializers.go index b34a17c73d5..b145c3e79c4 100644 --- a/service/lambda/deserializers.go +++ b/service/lambda/deserializers.go @@ -6617,6 +6617,9 @@ func awsRestjson1_deserializeOpErrorInvoke(response *smithyhttp.Response, metada case strings.EqualFold("KMSNotFoundException", errorCode): return awsRestjson1_deserializeErrorKMSNotFoundException(response, errorBody) + case strings.EqualFold("RecursiveInvocationException", errorCode): + return awsRestjson1_deserializeErrorRecursiveInvocationException(response, errorBody) + case strings.EqualFold("RequestTooLargeException", errorCode): return awsRestjson1_deserializeErrorRequestTooLargeException(response, errorBody) @@ -6945,6 +6948,9 @@ func awsRestjson1_deserializeOpErrorInvokeWithResponseStream(response *smithyhtt case strings.EqualFold("KMSNotFoundException", errorCode): return awsRestjson1_deserializeErrorKMSNotFoundException(response, errorBody) + case strings.EqualFold("RecursiveInvocationException", errorCode): + return awsRestjson1_deserializeErrorRecursiveInvocationException(response, errorBody) + case strings.EqualFold("RequestTooLargeException", errorCode): return awsRestjson1_deserializeErrorRequestTooLargeException(response, errorBody) @@ -14167,6 +14173,42 @@ func awsRestjson1_deserializeErrorProvisionedConcurrencyConfigNotFoundException( return output } +func awsRestjson1_deserializeErrorRecursiveInvocationException(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.RecursiveInvocationException{} + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + + body := io.TeeReader(errorBody, ringBuffer) + decoder := json.NewDecoder(body) + decoder.UseNumber() + var shape interface{} + if err := decoder.Decode(&shape); err != nil && err != io.EOF { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return err + } + + err := awsRestjson1_deserializeDocumentRecursiveInvocationException(&output, shape) + + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return err + } + + errorBody.Seek(0, io.SeekStart) + + return output +} + func awsRestjson1_deserializeErrorRequestTooLargeException(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.RequestTooLargeException{} var buff [1024]byte @@ -19161,6 +19203,55 @@ func awsRestjson1_deserializeDocumentQueues(v *[]string, value interface{}) erro return nil } +func awsRestjson1_deserializeDocumentRecursiveInvocationException(v **types.RecursiveInvocationException, value interface{}) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + if value == nil { + return nil + } + + shape, ok := value.(map[string]interface{}) + if !ok { + return fmt.Errorf("unexpected JSON type %v", value) + } + + var sv *types.RecursiveInvocationException + if *v == nil { + sv = &types.RecursiveInvocationException{} + } else { + sv = *v + } + + for key, value := range shape { + switch key { + case "Message": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected String to be of type string, got %T instead", value) + } + sv.Message = ptr.String(jtv) + } + + case "Type": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected String to be of type string, got %T instead", value) + } + sv.Type = ptr.String(jtv) + } + + default: + _, _ = key, value + + } + } + *v = sv + return nil +} + func awsRestjson1_deserializeDocumentRequestTooLargeException(v **types.RequestTooLargeException, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) diff --git a/service/lambda/types/errors.go b/service/lambda/types/errors.go index df9b0bbc117..763eabc98ce 100644 --- a/service/lambda/types/errors.go +++ b/service/lambda/types/errors.go @@ -734,6 +734,35 @@ func (e *ProvisionedConcurrencyConfigNotFoundException) ErrorFault() smithy.Erro return smithy.FaultClient } +// Lambda has detected your function being invoked in a recursive loop with other +// Amazon Web Services resources and stopped your function's invocation. +type RecursiveInvocationException struct { + Message *string + + ErrorCodeOverride *string + + Type *string + + noSmithyDocumentSerde +} + +func (e *RecursiveInvocationException) Error() string { + return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage()) +} +func (e *RecursiveInvocationException) ErrorMessage() string { + if e.Message == nil { + return "" + } + return *e.Message +} +func (e *RecursiveInvocationException) ErrorCode() string { + if e == nil || e.ErrorCodeOverride == nil { + return "RecursiveInvocationException" + } + return *e.ErrorCodeOverride +} +func (e *RecursiveInvocationException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient } + // The request payload exceeded the Invoke request body JSON input quota. For more // information, see Lambda quotas (https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-limits.html) // . diff --git a/service/nimble/internal/endpoints/endpoints.go b/service/nimble/internal/endpoints/endpoints.go index fdf7138fb49..c0defca7d2c 100644 --- a/service/nimble/internal/endpoints/endpoints.go +++ b/service/nimble/internal/endpoints/endpoints.go @@ -142,18 +142,33 @@ var defaultPartitions = endpoints.Partitions{ endpoints.EndpointKey{ Region: "ap-northeast-1", }: endpoints.Endpoint{}, + endpoints.EndpointKey{ + Region: "ap-southeast-1", + }: endpoints.Endpoint{}, endpoints.EndpointKey{ Region: "ap-southeast-2", }: endpoints.Endpoint{}, endpoints.EndpointKey{ Region: "ca-central-1", }: endpoints.Endpoint{}, + endpoints.EndpointKey{ + Region: "eu-central-1", + }: endpoints.Endpoint{}, + endpoints.EndpointKey{ + Region: "eu-north-1", + }: endpoints.Endpoint{}, + endpoints.EndpointKey{ + Region: "eu-west-1", + }: endpoints.Endpoint{}, endpoints.EndpointKey{ Region: "eu-west-2", }: endpoints.Endpoint{}, endpoints.EndpointKey{ Region: "us-east-1", }: endpoints.Endpoint{}, + endpoints.EndpointKey{ + Region: "us-east-2", + }: endpoints.Endpoint{}, endpoints.EndpointKey{ Region: "us-west-2", }: endpoints.Endpoint{}, diff --git a/service/redshift/api_op_AuthorizeSnapshotAccess.go b/service/redshift/api_op_AuthorizeSnapshotAccess.go index d4406c5c727..31757dd1871 100644 --- a/service/redshift/api_op_AuthorizeSnapshotAccess.go +++ b/service/redshift/api_op_AuthorizeSnapshotAccess.go @@ -43,8 +43,8 @@ type AuthorizeSnapshotAccessInput struct { SnapshotArn *string // The identifier of the cluster the snapshot was created from. This parameter is - // required if your IAM user or role has a policy containing a snapshot resource - // element that specifies anything other than * for the cluster name. + // required if your IAM user has a policy containing a snapshot resource element + // that specifies anything other than * for the cluster name. SnapshotClusterIdentifier *string // The identifier of the snapshot the account is authorized to restore. diff --git a/service/redshift/api_op_CopyClusterSnapshot.go b/service/redshift/api_op_CopyClusterSnapshot.go index 91ed9c679c4..2a5c0b949f6 100644 --- a/service/redshift/api_op_CopyClusterSnapshot.go +++ b/service/redshift/api_op_CopyClusterSnapshot.go @@ -61,9 +61,9 @@ type CopyClusterSnapshotInput struct { ManualSnapshotRetentionPeriod *int32 // The identifier of the cluster the source snapshot was created from. This - // parameter is required if your IAM user or role has a policy containing a - // snapshot resource element that specifies anything other than * for the cluster - // name. Constraints: + // parameter is required if your IAM user has a policy containing a snapshot + // resource element that specifies anything other than * for the cluster name. + // Constraints: // - Must be the identifier for a valid cluster. SourceSnapshotClusterIdentifier *string diff --git a/service/redshift/api_op_CreateCluster.go b/service/redshift/api_op_CreateCluster.go index 6ce3d8294b2..336b637df96 100644 --- a/service/redshift/api_op_CreateCluster.go +++ b/service/redshift/api_op_CreateCluster.go @@ -47,8 +47,8 @@ type CreateClusterInput struct { // This member is required. ClusterIdentifier *string - // The password associated with the admin user for the cluster that is being - // created. Constraints: + // The password associated with the admin user account for the cluster that is + // being created. Constraints: // - Must be between 8 and 64 characters in length. // - Must contain at least one uppercase letter. // - Must contain at least one lowercase letter. @@ -59,8 +59,8 @@ type CreateClusterInput struct { // This member is required. MasterUserPassword *string - // The user name associated with the admin user for the cluster that is being - // created. Constraints: + // The user name associated with the admin user account for the cluster that is + // being created. Constraints: // - Must be 1 - 128 alphanumeric characters or hyphens. The user name can't be // PUBLIC . // - Must contain only lowercase letters, numbers, underscore, plus sign, period diff --git a/service/redshift/api_op_CreateCustomDomainAssociation.go b/service/redshift/api_op_CreateCustomDomainAssociation.go new file mode 100644 index 00000000000..da41ddcd52f --- /dev/null +++ b/service/redshift/api_op_CreateCustomDomainAssociation.go @@ -0,0 +1,146 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package redshift + +import ( + "context" + awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" + "github.com/aws/aws-sdk-go-v2/aws/signer/v4" + "github.com/aws/smithy-go/middleware" + smithyhttp "github.com/aws/smithy-go/transport/http" +) + +// Used to create a custom domain name for a cluster. Properties include the +// custom domain name, the cluster the custom domain is associated with, and the +// certificate Amazon Resource Name (ARN). +func (c *Client) CreateCustomDomainAssociation(ctx context.Context, params *CreateCustomDomainAssociationInput, optFns ...func(*Options)) (*CreateCustomDomainAssociationOutput, error) { + if params == nil { + params = &CreateCustomDomainAssociationInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "CreateCustomDomainAssociation", params, optFns, c.addOperationCreateCustomDomainAssociationMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*CreateCustomDomainAssociationOutput) + out.ResultMetadata = metadata + return out, nil +} + +type CreateCustomDomainAssociationInput struct { + + // The cluster identifier that the custom domain is associated with. + // + // This member is required. + ClusterIdentifier *string + + // The certificate Amazon Resource Name (ARN) for the custom domain name + // association. + // + // This member is required. + CustomDomainCertificateArn *string + + // The custom domain name for a custom domain association. + // + // This member is required. + CustomDomainName *string + + noSmithyDocumentSerde +} + +type CreateCustomDomainAssociationOutput struct { + + // The identifier of the cluster that the custom domain is associated with. + ClusterIdentifier *string + + // The expiration time for the certificate for the custom domain. + CustomDomainCertExpiryTime *string + + // The Amazon Resource Name (ARN) for the certificate associated with the custom + // domain name. + CustomDomainCertificateArn *string + + // The custom domain name for the association result. + CustomDomainName *string + + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (c *Client) addOperationCreateCustomDomainAssociationMiddlewares(stack *middleware.Stack, options Options) (err error) { + err = stack.Serialize.Add(&awsAwsquery_serializeOpCreateCustomDomainAssociation{}, middleware.After) + if err != nil { + return err + } + err = stack.Deserialize.Add(&awsAwsquery_deserializeOpCreateCustomDomainAssociation{}, middleware.After) + if err != nil { + return err + } + if err = addSetLoggerMiddleware(stack, options); err != nil { + return err + } + if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil { + return err + } + if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil { + return err + } + if err = addResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil { + return err + } + if err = addRetryMiddlewares(stack, options); err != nil { + return err + } + if err = addHTTPSignerV4Middleware(stack, options); err != nil { + return err + } + if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil { + return err + } + if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil { + return err + } + if err = addClientUserAgent(stack); err != nil { + return err + } + if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil { + return err + } + if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { + return err + } + if err = addOpCreateCustomDomainAssociationValidationMiddleware(stack); err != nil { + return err + } + if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateCustomDomainAssociation(options.Region), middleware.Before); err != nil { + return err + } + if err = awsmiddleware.AddRecursionDetection(stack); err != nil { + return err + } + if err = addRequestIDRetrieverMiddleware(stack); err != nil { + return err + } + if err = addResponseErrorMiddleware(stack); err != nil { + return err + } + if err = addRequestResponseLogging(stack, options); err != nil { + return err + } + return nil +} + +func newServiceMetadataMiddleware_opCreateCustomDomainAssociation(region string) *awsmiddleware.RegisterServiceMetadata { + return &awsmiddleware.RegisterServiceMetadata{ + Region: region, + ServiceID: ServiceID, + SigningName: "redshift", + OperationName: "CreateCustomDomainAssociation", + } +} diff --git a/service/redshift/api_op_DeleteClusterSnapshot.go b/service/redshift/api_op_DeleteClusterSnapshot.go index c79aedf5789..7dd15a2cf06 100644 --- a/service/redshift/api_op_DeleteClusterSnapshot.go +++ b/service/redshift/api_op_DeleteClusterSnapshot.go @@ -43,9 +43,9 @@ type DeleteClusterSnapshotInput struct { SnapshotIdentifier *string // The unique identifier of the cluster the snapshot was created from. This - // parameter is required if your IAM user or role has a policy containing a - // snapshot resource element that specifies anything other than * for the cluster - // name. Constraints: Must be the name of valid cluster. + // parameter is required if your IAM user has a policy containing a snapshot + // resource element that specifies anything other than * for the cluster name. + // Constraints: Must be the name of valid cluster. SnapshotClusterIdentifier *string noSmithyDocumentSerde diff --git a/service/redshift/api_op_DeleteCustomDomainAssociation.go b/service/redshift/api_op_DeleteCustomDomainAssociation.go new file mode 100644 index 00000000000..cb31b08c92a --- /dev/null +++ b/service/redshift/api_op_DeleteCustomDomainAssociation.go @@ -0,0 +1,119 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package redshift + +import ( + "context" + awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" + "github.com/aws/aws-sdk-go-v2/aws/signer/v4" + "github.com/aws/smithy-go/middleware" + smithyhttp "github.com/aws/smithy-go/transport/http" +) + +// Contains information about deleting a custom domain association for a cluster. +func (c *Client) DeleteCustomDomainAssociation(ctx context.Context, params *DeleteCustomDomainAssociationInput, optFns ...func(*Options)) (*DeleteCustomDomainAssociationOutput, error) { + if params == nil { + params = &DeleteCustomDomainAssociationInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "DeleteCustomDomainAssociation", params, optFns, c.addOperationDeleteCustomDomainAssociationMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*DeleteCustomDomainAssociationOutput) + out.ResultMetadata = metadata + return out, nil +} + +type DeleteCustomDomainAssociationInput struct { + + // The identifier of the cluster to delete a custom domain association for. + // + // This member is required. + ClusterIdentifier *string + + noSmithyDocumentSerde +} + +type DeleteCustomDomainAssociationOutput struct { + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (c *Client) addOperationDeleteCustomDomainAssociationMiddlewares(stack *middleware.Stack, options Options) (err error) { + err = stack.Serialize.Add(&awsAwsquery_serializeOpDeleteCustomDomainAssociation{}, middleware.After) + if err != nil { + return err + } + err = stack.Deserialize.Add(&awsAwsquery_deserializeOpDeleteCustomDomainAssociation{}, middleware.After) + if err != nil { + return err + } + if err = addSetLoggerMiddleware(stack, options); err != nil { + return err + } + if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil { + return err + } + if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil { + return err + } + if err = addResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil { + return err + } + if err = addRetryMiddlewares(stack, options); err != nil { + return err + } + if err = addHTTPSignerV4Middleware(stack, options); err != nil { + return err + } + if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil { + return err + } + if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil { + return err + } + if err = addClientUserAgent(stack); err != nil { + return err + } + if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil { + return err + } + if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { + return err + } + if err = addOpDeleteCustomDomainAssociationValidationMiddleware(stack); err != nil { + return err + } + if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteCustomDomainAssociation(options.Region), middleware.Before); err != nil { + return err + } + if err = awsmiddleware.AddRecursionDetection(stack); err != nil { + return err + } + if err = addRequestIDRetrieverMiddleware(stack); err != nil { + return err + } + if err = addResponseErrorMiddleware(stack); err != nil { + return err + } + if err = addRequestResponseLogging(stack, options); err != nil { + return err + } + return nil +} + +func newServiceMetadataMiddleware_opDeleteCustomDomainAssociation(region string) *awsmiddleware.RegisterServiceMetadata { + return &awsmiddleware.RegisterServiceMetadata{ + Region: region, + ServiceID: ServiceID, + SigningName: "redshift", + OperationName: "DeleteCustomDomainAssociation", + } +} diff --git a/service/redshift/api_op_DescribeClusterSnapshots.go b/service/redshift/api_op_DescribeClusterSnapshots.go index 8946ba42908..654c785752b 100644 --- a/service/redshift/api_op_DescribeClusterSnapshots.go +++ b/service/redshift/api_op_DescribeClusterSnapshots.go @@ -80,7 +80,7 @@ type DescribeClusterSnapshotsInput struct { // remaining response records exceeds the specified MaxRecords value, a value is // returned in a marker field of the response. You can retrieve the next set of // records by retrying the command with the returned marker value. Default: 100 - // Constraints: minimum 20, maximum 500. + // Constraints: minimum 20, maximum 100. MaxRecords *int32 // The Amazon Web Services account used to create or copy the snapshot. Use this @@ -228,7 +228,7 @@ type DescribeClusterSnapshotsPaginatorOptions struct { // remaining response records exceeds the specified MaxRecords value, a value is // returned in a marker field of the response. You can retrieve the next set of // records by retrying the command with the returned marker value. Default: 100 - // Constraints: minimum 20, maximum 500. + // Constraints: minimum 20, maximum 100. Limit int32 // Set to true if pagination should stop if the service returns a pagination token diff --git a/service/redshift/api_op_DescribeCustomDomainAssociations.go b/service/redshift/api_op_DescribeCustomDomainAssociations.go new file mode 100644 index 00000000000..5274fe2d68a --- /dev/null +++ b/service/redshift/api_op_DescribeCustomDomainAssociations.go @@ -0,0 +1,225 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package redshift + +import ( + "context" + "fmt" + awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" + "github.com/aws/aws-sdk-go-v2/aws/signer/v4" + "github.com/aws/aws-sdk-go-v2/service/redshift/types" + "github.com/aws/smithy-go/middleware" + smithyhttp "github.com/aws/smithy-go/transport/http" +) + +// Contains information for custom domain associations for a cluster. +func (c *Client) DescribeCustomDomainAssociations(ctx context.Context, params *DescribeCustomDomainAssociationsInput, optFns ...func(*Options)) (*DescribeCustomDomainAssociationsOutput, error) { + if params == nil { + params = &DescribeCustomDomainAssociationsInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "DescribeCustomDomainAssociations", params, optFns, c.addOperationDescribeCustomDomainAssociationsMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*DescribeCustomDomainAssociationsOutput) + out.ResultMetadata = metadata + return out, nil +} + +type DescribeCustomDomainAssociationsInput struct { + + // The certificate Amazon Resource Name (ARN) for the custom domain association. + CustomDomainCertificateArn *string + + // The custom domain name for the custom domain association. + CustomDomainName *string + + // The marker for the custom domain association. + Marker *string + + // The maximum records setting for the associated custom domain. + MaxRecords *int32 + + noSmithyDocumentSerde +} + +type DescribeCustomDomainAssociationsOutput struct { + + // The associations for the custom domain. + Associations []types.Association + + // The marker for the custom domain association. + Marker *string + + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (c *Client) addOperationDescribeCustomDomainAssociationsMiddlewares(stack *middleware.Stack, options Options) (err error) { + err = stack.Serialize.Add(&awsAwsquery_serializeOpDescribeCustomDomainAssociations{}, middleware.After) + if err != nil { + return err + } + err = stack.Deserialize.Add(&awsAwsquery_deserializeOpDescribeCustomDomainAssociations{}, middleware.After) + if err != nil { + return err + } + if err = addSetLoggerMiddleware(stack, options); err != nil { + return err + } + if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil { + return err + } + if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil { + return err + } + if err = addResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil { + return err + } + if err = addRetryMiddlewares(stack, options); err != nil { + return err + } + if err = addHTTPSignerV4Middleware(stack, options); err != nil { + return err + } + if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil { + return err + } + if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil { + return err + } + if err = addClientUserAgent(stack); err != nil { + return err + } + if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil { + return err + } + if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { + return err + } + if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeCustomDomainAssociations(options.Region), middleware.Before); err != nil { + return err + } + if err = awsmiddleware.AddRecursionDetection(stack); err != nil { + return err + } + if err = addRequestIDRetrieverMiddleware(stack); err != nil { + return err + } + if err = addResponseErrorMiddleware(stack); err != nil { + return err + } + if err = addRequestResponseLogging(stack, options); err != nil { + return err + } + return nil +} + +// DescribeCustomDomainAssociationsAPIClient is a client that implements the +// DescribeCustomDomainAssociations operation. +type DescribeCustomDomainAssociationsAPIClient interface { + DescribeCustomDomainAssociations(context.Context, *DescribeCustomDomainAssociationsInput, ...func(*Options)) (*DescribeCustomDomainAssociationsOutput, error) +} + +var _ DescribeCustomDomainAssociationsAPIClient = (*Client)(nil) + +// DescribeCustomDomainAssociationsPaginatorOptions is the paginator options for +// DescribeCustomDomainAssociations +type DescribeCustomDomainAssociationsPaginatorOptions struct { + // The maximum records setting for the associated custom domain. + Limit int32 + + // Set to true if pagination should stop if the service returns a pagination token + // that matches the most recent token provided to the service. + StopOnDuplicateToken bool +} + +// DescribeCustomDomainAssociationsPaginator is a paginator for +// DescribeCustomDomainAssociations +type DescribeCustomDomainAssociationsPaginator struct { + options DescribeCustomDomainAssociationsPaginatorOptions + client DescribeCustomDomainAssociationsAPIClient + params *DescribeCustomDomainAssociationsInput + nextToken *string + firstPage bool +} + +// NewDescribeCustomDomainAssociationsPaginator returns a new +// DescribeCustomDomainAssociationsPaginator +func NewDescribeCustomDomainAssociationsPaginator(client DescribeCustomDomainAssociationsAPIClient, params *DescribeCustomDomainAssociationsInput, optFns ...func(*DescribeCustomDomainAssociationsPaginatorOptions)) *DescribeCustomDomainAssociationsPaginator { + if params == nil { + params = &DescribeCustomDomainAssociationsInput{} + } + + options := DescribeCustomDomainAssociationsPaginatorOptions{} + if params.MaxRecords != nil { + options.Limit = *params.MaxRecords + } + + for _, fn := range optFns { + fn(&options) + } + + return &DescribeCustomDomainAssociationsPaginator{ + options: options, + client: client, + params: params, + firstPage: true, + nextToken: params.Marker, + } +} + +// HasMorePages returns a boolean indicating whether more pages are available +func (p *DescribeCustomDomainAssociationsPaginator) HasMorePages() bool { + return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0) +} + +// NextPage retrieves the next DescribeCustomDomainAssociations page. +func (p *DescribeCustomDomainAssociationsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*DescribeCustomDomainAssociationsOutput, error) { + if !p.HasMorePages() { + return nil, fmt.Errorf("no more pages available") + } + + params := *p.params + params.Marker = p.nextToken + + var limit *int32 + if p.options.Limit > 0 { + limit = &p.options.Limit + } + params.MaxRecords = limit + + result, err := p.client.DescribeCustomDomainAssociations(ctx, ¶ms, optFns...) + if err != nil { + return nil, err + } + p.firstPage = false + + prevToken := p.nextToken + p.nextToken = result.Marker + + if p.options.StopOnDuplicateToken && + prevToken != nil && + p.nextToken != nil && + *prevToken == *p.nextToken { + p.nextToken = nil + } + + return result, nil +} + +func newServiceMetadataMiddleware_opDescribeCustomDomainAssociations(region string) *awsmiddleware.RegisterServiceMetadata { + return &awsmiddleware.RegisterServiceMetadata{ + Region: region, + ServiceID: ServiceID, + SigningName: "redshift", + OperationName: "DescribeCustomDomainAssociations", + } +} diff --git a/service/redshift/api_op_GetClusterCredentials.go b/service/redshift/api_op_GetClusterCredentials.go index b4c48f41be1..c689cc97979 100644 --- a/service/redshift/api_op_GetClusterCredentials.go +++ b/service/redshift/api_op_GetClusterCredentials.go @@ -48,12 +48,6 @@ func (c *Client) GetClusterCredentials(ctx context.Context, params *GetClusterCr // The request parameters to get cluster credentials. type GetClusterCredentialsInput struct { - // The unique identifier of the cluster that contains the database for which you - // are requesting credentials. This parameter is case sensitive. - // - // This member is required. - ClusterIdentifier *string - // The name of a database user. If a user name matching DbUser exists in the // database, the temporary user credentials have the same permissions as the // existing user. If DbUser doesn't exist in the database and Autocreate is True , @@ -79,6 +73,13 @@ type GetClusterCredentialsInput struct { // one does not exist. AutoCreate *bool + // The unique identifier of the cluster that contains the database for which you + // are requesting credentials. This parameter is case sensitive. + ClusterIdentifier *string + + // The custom domain name for the cluster credentials. + CustomDomainName *string + // A list of the names of existing database groups that the user named in DbUser // will join for the current session, in addition to any group memberships for an // existing user. If not specified, a new user is added only to PUBLIC. Database diff --git a/service/redshift/api_op_GetClusterCredentialsWithIAM.go b/service/redshift/api_op_GetClusterCredentialsWithIAM.go index d8bee2227e4..ac26e5c03fa 100644 --- a/service/redshift/api_op_GetClusterCredentialsWithIAM.go +++ b/service/redshift/api_op_GetClusterCredentialsWithIAM.go @@ -40,10 +40,11 @@ type GetClusterCredentialsWithIAMInput struct { // The unique identifier of the cluster that contains the database for which you // are requesting credentials. - // - // This member is required. ClusterIdentifier *string + // The custom domain name for the IAM message cluster credentials. + CustomDomainName *string + // The name of the database for which you are requesting credentials. If the // database name is specified, the IAM policy must allow access to the resource // dbname for the specified database name. If the database name is not specified, @@ -124,9 +125,6 @@ func (c *Client) addOperationGetClusterCredentialsWithIAMMiddlewares(stack *midd if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } - if err = addOpGetClusterCredentialsWithIAMValidationMiddleware(stack); err != nil { - return err - } if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetClusterCredentialsWithIAM(options.Region), middleware.Before); err != nil { return err } diff --git a/service/redshift/api_op_ModifyCluster.go b/service/redshift/api_op_ModifyCluster.go index 5080cd166f6..ce7d9e532f9 100644 --- a/service/redshift/api_op_ModifyCluster.go +++ b/service/redshift/api_op_ModifyCluster.go @@ -150,8 +150,8 @@ type ModifyClusterInput struct { // of the request, the MasterUserPassword element exists in the // PendingModifiedValues element of the operation response. Operations never return // the password, so this operation provides a way to regain access to the admin - // user for a cluster if the password is lost. Default: Uses existing setting. - // Constraints: + // user account for a cluster if the password is lost. Default: Uses existing + // setting. Constraints: // - Must be between 8 and 64 characters in length. // - Must contain at least one uppercase letter. // - Must contain at least one lowercase letter. diff --git a/service/redshift/api_op_ModifyCustomDomainAssociation.go b/service/redshift/api_op_ModifyCustomDomainAssociation.go new file mode 100644 index 00000000000..e4f90a57ffd --- /dev/null +++ b/service/redshift/api_op_ModifyCustomDomainAssociation.go @@ -0,0 +1,143 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package redshift + +import ( + "context" + awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" + "github.com/aws/aws-sdk-go-v2/aws/signer/v4" + "github.com/aws/smithy-go/middleware" + smithyhttp "github.com/aws/smithy-go/transport/http" +) + +// Contains information for changing a custom domain association. +func (c *Client) ModifyCustomDomainAssociation(ctx context.Context, params *ModifyCustomDomainAssociationInput, optFns ...func(*Options)) (*ModifyCustomDomainAssociationOutput, error) { + if params == nil { + params = &ModifyCustomDomainAssociationInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "ModifyCustomDomainAssociation", params, optFns, c.addOperationModifyCustomDomainAssociationMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*ModifyCustomDomainAssociationOutput) + out.ResultMetadata = metadata + return out, nil +} + +type ModifyCustomDomainAssociationInput struct { + + // The identifier of the cluster to change a custom domain association for. + // + // This member is required. + ClusterIdentifier *string + + // The certificate Amazon Resource Name (ARN) for the changed custom domain + // association. + CustomDomainCertificateArn *string + + // The custom domain name for a changed custom domain association. + CustomDomainName *string + + noSmithyDocumentSerde +} + +type ModifyCustomDomainAssociationOutput struct { + + // The identifier of the cluster associated with the result for the changed custom + // domain association. + ClusterIdentifier *string + + // The certificate expiration time associated with the result for the changed + // custom domain association. + CustomDomainCertExpiryTime *string + + // The certificate Amazon Resource Name (ARN) associated with the result for the + // changed custom domain association. + CustomDomainCertificateArn *string + + // The custom domain name associated with the result for the changed custom domain + // association. + CustomDomainName *string + + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (c *Client) addOperationModifyCustomDomainAssociationMiddlewares(stack *middleware.Stack, options Options) (err error) { + err = stack.Serialize.Add(&awsAwsquery_serializeOpModifyCustomDomainAssociation{}, middleware.After) + if err != nil { + return err + } + err = stack.Deserialize.Add(&awsAwsquery_deserializeOpModifyCustomDomainAssociation{}, middleware.After) + if err != nil { + return err + } + if err = addSetLoggerMiddleware(stack, options); err != nil { + return err + } + if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil { + return err + } + if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil { + return err + } + if err = addResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil { + return err + } + if err = addRetryMiddlewares(stack, options); err != nil { + return err + } + if err = addHTTPSignerV4Middleware(stack, options); err != nil { + return err + } + if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil { + return err + } + if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil { + return err + } + if err = addClientUserAgent(stack); err != nil { + return err + } + if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil { + return err + } + if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { + return err + } + if err = addOpModifyCustomDomainAssociationValidationMiddleware(stack); err != nil { + return err + } + if err = stack.Initialize.Add(newServiceMetadataMiddleware_opModifyCustomDomainAssociation(options.Region), middleware.Before); err != nil { + return err + } + if err = awsmiddleware.AddRecursionDetection(stack); err != nil { + return err + } + if err = addRequestIDRetrieverMiddleware(stack); err != nil { + return err + } + if err = addResponseErrorMiddleware(stack); err != nil { + return err + } + if err = addRequestResponseLogging(stack, options); err != nil { + return err + } + return nil +} + +func newServiceMetadataMiddleware_opModifyCustomDomainAssociation(region string) *awsmiddleware.RegisterServiceMetadata { + return &awsmiddleware.RegisterServiceMetadata{ + Region: region, + ServiceID: ServiceID, + SigningName: "redshift", + OperationName: "ModifyCustomDomainAssociation", + } +} diff --git a/service/redshift/api_op_RestoreFromClusterSnapshot.go b/service/redshift/api_op_RestoreFromClusterSnapshot.go index c1a20c94fc1..57225c3d979 100644 --- a/service/redshift/api_op_RestoreFromClusterSnapshot.go +++ b/service/redshift/api_op_RestoreFromClusterSnapshot.go @@ -202,8 +202,8 @@ type RestoreFromClusterSnapshotInput struct { SnapshotArn *string // The name of the cluster the source snapshot was created from. This parameter is - // required if your IAM user or role has a policy containing a snapshot resource - // element that specifies anything other than * for the cluster name. + // required if your IAM user has a policy containing a snapshot resource element + // that specifies anything other than * for the cluster name. SnapshotClusterIdentifier *string // The name of the snapshot from which to create the new cluster. This parameter diff --git a/service/redshift/api_op_RevokeSnapshotAccess.go b/service/redshift/api_op_RevokeSnapshotAccess.go index 45691a3ab4d..7772929db73 100644 --- a/service/redshift/api_op_RevokeSnapshotAccess.go +++ b/service/redshift/api_op_RevokeSnapshotAccess.go @@ -44,8 +44,8 @@ type RevokeSnapshotAccessInput struct { SnapshotArn *string // The identifier of the cluster the snapshot was created from. This parameter is - // required if your IAM user or role has a policy containing a snapshot resource - // element that specifies anything other than * for the cluster name. + // required if your IAM user has a policy containing a snapshot resource element + // that specifies anything other than * for the cluster name. SnapshotClusterIdentifier *string // The identifier of the snapshot that the account can no longer access. diff --git a/service/redshift/deserializers.go b/service/redshift/deserializers.go index 55924385c78..c37e7894e42 100644 --- a/service/redshift/deserializers.go +++ b/service/redshift/deserializers.go @@ -2079,6 +2079,120 @@ func awsAwsquery_deserializeOpErrorCreateClusterSubnetGroup(response *smithyhttp } } +type awsAwsquery_deserializeOpCreateCustomDomainAssociation struct { +} + +func (*awsAwsquery_deserializeOpCreateCustomDomainAssociation) ID() string { + return "OperationDeserializer" +} + +func (m *awsAwsquery_deserializeOpCreateCustomDomainAssociation) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( + out middleware.DeserializeOutput, metadata middleware.Metadata, err error, +) { + out, metadata, err = next.HandleDeserialize(ctx, in) + if err != nil { + return out, metadata, err + } + + response, ok := out.RawResponse.(*smithyhttp.Response) + if !ok { + return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} + } + + if response.StatusCode < 200 || response.StatusCode >= 300 { + return out, metadata, awsAwsquery_deserializeOpErrorCreateCustomDomainAssociation(response, &metadata) + } + output := &CreateCustomDomainAssociationOutput{} + out.Result = output + + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + body := io.TeeReader(response.Body, ringBuffer) + rootDecoder := xml.NewDecoder(body) + t, err := smithyxml.FetchRootElement(rootDecoder) + if err == io.EOF { + return out, metadata, nil + } + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + return out, metadata, &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + } + + decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) + t, err = decoder.GetElement("CreateCustomDomainAssociationResult") + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return out, metadata, err + } + + decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) + err = awsAwsquery_deserializeOpDocumentCreateCustomDomainAssociationOutput(&output, decoder) + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return out, metadata, err + } + + return out, metadata, err +} + +func awsAwsquery_deserializeOpErrorCreateCustomDomainAssociation(response *smithyhttp.Response, metadata *middleware.Metadata) error { + var errorBuffer bytes.Buffer + if _, err := io.Copy(&errorBuffer, response.Body); err != nil { + return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} + } + errorBody := bytes.NewReader(errorBuffer.Bytes()) + + errorCode := "UnknownError" + errorMessage := errorCode + + errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) + if err != nil { + return err + } + if reqID := errorComponents.RequestID; len(reqID) != 0 { + awsmiddleware.SetRequestIDMetadata(metadata, reqID) + } + if len(errorComponents.Code) != 0 { + errorCode = errorComponents.Code + } + if len(errorComponents.Message) != 0 { + errorMessage = errorComponents.Message + } + errorBody.Seek(0, io.SeekStart) + switch { + case strings.EqualFold("ClusterNotFound", errorCode): + return awsAwsquery_deserializeErrorClusterNotFoundFault(response, errorBody) + + case strings.EqualFold("CustomCnameAssociationFault", errorCode): + return awsAwsquery_deserializeErrorCustomCnameAssociationFault(response, errorBody) + + case strings.EqualFold("UnsupportedOperation", errorCode): + return awsAwsquery_deserializeErrorUnsupportedOperationFault(response, errorBody) + + default: + genericError := &smithy.GenericAPIError{ + Code: errorCode, + Message: errorMessage, + } + return genericError + + } +} + type awsAwsquery_deserializeOpCreateEndpointAccess struct { } @@ -3844,6 +3958,85 @@ func awsAwsquery_deserializeOpErrorDeleteClusterSubnetGroup(response *smithyhttp } } +type awsAwsquery_deserializeOpDeleteCustomDomainAssociation struct { +} + +func (*awsAwsquery_deserializeOpDeleteCustomDomainAssociation) ID() string { + return "OperationDeserializer" +} + +func (m *awsAwsquery_deserializeOpDeleteCustomDomainAssociation) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( + out middleware.DeserializeOutput, metadata middleware.Metadata, err error, +) { + out, metadata, err = next.HandleDeserialize(ctx, in) + if err != nil { + return out, metadata, err + } + + response, ok := out.RawResponse.(*smithyhttp.Response) + if !ok { + return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} + } + + if response.StatusCode < 200 || response.StatusCode >= 300 { + return out, metadata, awsAwsquery_deserializeOpErrorDeleteCustomDomainAssociation(response, &metadata) + } + output := &DeleteCustomDomainAssociationOutput{} + out.Result = output + + if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { + return out, metadata, &smithy.DeserializationError{ + Err: fmt.Errorf("failed to discard response body, %w", err), + } + } + + return out, metadata, err +} + +func awsAwsquery_deserializeOpErrorDeleteCustomDomainAssociation(response *smithyhttp.Response, metadata *middleware.Metadata) error { + var errorBuffer bytes.Buffer + if _, err := io.Copy(&errorBuffer, response.Body); err != nil { + return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} + } + errorBody := bytes.NewReader(errorBuffer.Bytes()) + + errorCode := "UnknownError" + errorMessage := errorCode + + errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) + if err != nil { + return err + } + if reqID := errorComponents.RequestID; len(reqID) != 0 { + awsmiddleware.SetRequestIDMetadata(metadata, reqID) + } + if len(errorComponents.Code) != 0 { + errorCode = errorComponents.Code + } + if len(errorComponents.Message) != 0 { + errorMessage = errorComponents.Message + } + errorBody.Seek(0, io.SeekStart) + switch { + case strings.EqualFold("ClusterNotFound", errorCode): + return awsAwsquery_deserializeErrorClusterNotFoundFault(response, errorBody) + + case strings.EqualFold("CustomCnameAssociationFault", errorCode): + return awsAwsquery_deserializeErrorCustomCnameAssociationFault(response, errorBody) + + case strings.EqualFold("UnsupportedOperation", errorCode): + return awsAwsquery_deserializeErrorUnsupportedOperationFault(response, errorBody) + + default: + genericError := &smithy.GenericAPIError{ + Code: errorCode, + Message: errorMessage, + } + return genericError + + } +} + type awsAwsquery_deserializeOpDeleteEndpointAccess struct { } @@ -5898,14 +6091,14 @@ func awsAwsquery_deserializeOpErrorDescribeClusterVersions(response *smithyhttp. } } -type awsAwsquery_deserializeOpDescribeDataShares struct { +type awsAwsquery_deserializeOpDescribeCustomDomainAssociations struct { } -func (*awsAwsquery_deserializeOpDescribeDataShares) ID() string { +func (*awsAwsquery_deserializeOpDescribeCustomDomainAssociations) ID() string { return "OperationDeserializer" } -func (m *awsAwsquery_deserializeOpDescribeDataShares) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsquery_deserializeOpDescribeCustomDomainAssociations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -5919,9 +6112,9 @@ func (m *awsAwsquery_deserializeOpDescribeDataShares) HandleDeserialize(ctx cont } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsquery_deserializeOpErrorDescribeDataShares(response, &metadata) + return out, metadata, awsAwsquery_deserializeOpErrorDescribeCustomDomainAssociations(response, &metadata) } - output := &DescribeDataSharesOutput{} + output := &DescribeCustomDomainAssociationsOutput{} out.Result = output var buff [1024]byte @@ -5942,7 +6135,7 @@ func (m *awsAwsquery_deserializeOpDescribeDataShares) HandleDeserialize(ctx cont } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - t, err = decoder.GetElement("DescribeDataSharesResult") + t, err = decoder.GetElement("DescribeCustomDomainAssociationsResult") if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -5954,7 +6147,7 @@ func (m *awsAwsquery_deserializeOpDescribeDataShares) HandleDeserialize(ctx cont } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeOpDocumentDescribeDataSharesOutput(&output, decoder) + err = awsAwsquery_deserializeOpDocumentDescribeCustomDomainAssociationsOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -5968,7 +6161,7 @@ func (m *awsAwsquery_deserializeOpDescribeDataShares) HandleDeserialize(ctx cont return out, metadata, err } -func awsAwsquery_deserializeOpErrorDescribeDataShares(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsquery_deserializeOpErrorDescribeCustomDomainAssociations(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -5993,8 +6186,11 @@ func awsAwsquery_deserializeOpErrorDescribeDataShares(response *smithyhttp.Respo } errorBody.Seek(0, io.SeekStart) switch { - case strings.EqualFold("InvalidDataShareFault", errorCode): - return awsAwsquery_deserializeErrorInvalidDataShareFault(response, errorBody) + case strings.EqualFold("CustomDomainAssociationNotFoundFault", errorCode): + return awsAwsquery_deserializeErrorCustomDomainAssociationNotFoundFault(response, errorBody) + + case strings.EqualFold("UnsupportedOperation", errorCode): + return awsAwsquery_deserializeErrorUnsupportedOperationFault(response, errorBody) default: genericError := &smithy.GenericAPIError{ @@ -6006,14 +6202,14 @@ func awsAwsquery_deserializeOpErrorDescribeDataShares(response *smithyhttp.Respo } } -type awsAwsquery_deserializeOpDescribeDataSharesForConsumer struct { +type awsAwsquery_deserializeOpDescribeDataShares struct { } -func (*awsAwsquery_deserializeOpDescribeDataSharesForConsumer) ID() string { +func (*awsAwsquery_deserializeOpDescribeDataShares) ID() string { return "OperationDeserializer" } -func (m *awsAwsquery_deserializeOpDescribeDataSharesForConsumer) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsquery_deserializeOpDescribeDataShares) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -6027,9 +6223,9 @@ func (m *awsAwsquery_deserializeOpDescribeDataSharesForConsumer) HandleDeseriali } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsquery_deserializeOpErrorDescribeDataSharesForConsumer(response, &metadata) + return out, metadata, awsAwsquery_deserializeOpErrorDescribeDataShares(response, &metadata) } - output := &DescribeDataSharesForConsumerOutput{} + output := &DescribeDataSharesOutput{} out.Result = output var buff [1024]byte @@ -6050,7 +6246,7 @@ func (m *awsAwsquery_deserializeOpDescribeDataSharesForConsumer) HandleDeseriali } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - t, err = decoder.GetElement("DescribeDataSharesForConsumerResult") + t, err = decoder.GetElement("DescribeDataSharesResult") if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -6062,7 +6258,7 @@ func (m *awsAwsquery_deserializeOpDescribeDataSharesForConsumer) HandleDeseriali } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeOpDocumentDescribeDataSharesForConsumerOutput(&output, decoder) + err = awsAwsquery_deserializeOpDocumentDescribeDataSharesOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -6076,7 +6272,7 @@ func (m *awsAwsquery_deserializeOpDescribeDataSharesForConsumer) HandleDeseriali return out, metadata, err } -func awsAwsquery_deserializeOpErrorDescribeDataSharesForConsumer(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsquery_deserializeOpErrorDescribeDataShares(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -6101,8 +6297,8 @@ func awsAwsquery_deserializeOpErrorDescribeDataSharesForConsumer(response *smith } errorBody.Seek(0, io.SeekStart) switch { - case strings.EqualFold("InvalidNamespaceFault", errorCode): - return awsAwsquery_deserializeErrorInvalidNamespaceFault(response, errorBody) + case strings.EqualFold("InvalidDataShareFault", errorCode): + return awsAwsquery_deserializeErrorInvalidDataShareFault(response, errorBody) default: genericError := &smithy.GenericAPIError{ @@ -6114,14 +6310,14 @@ func awsAwsquery_deserializeOpErrorDescribeDataSharesForConsumer(response *smith } } -type awsAwsquery_deserializeOpDescribeDataSharesForProducer struct { +type awsAwsquery_deserializeOpDescribeDataSharesForConsumer struct { } -func (*awsAwsquery_deserializeOpDescribeDataSharesForProducer) ID() string { +func (*awsAwsquery_deserializeOpDescribeDataSharesForConsumer) ID() string { return "OperationDeserializer" } -func (m *awsAwsquery_deserializeOpDescribeDataSharesForProducer) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsquery_deserializeOpDescribeDataSharesForConsumer) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -6135,9 +6331,9 @@ func (m *awsAwsquery_deserializeOpDescribeDataSharesForProducer) HandleDeseriali } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsquery_deserializeOpErrorDescribeDataSharesForProducer(response, &metadata) + return out, metadata, awsAwsquery_deserializeOpErrorDescribeDataSharesForConsumer(response, &metadata) } - output := &DescribeDataSharesForProducerOutput{} + output := &DescribeDataSharesForConsumerOutput{} out.Result = output var buff [1024]byte @@ -6158,7 +6354,7 @@ func (m *awsAwsquery_deserializeOpDescribeDataSharesForProducer) HandleDeseriali } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - t, err = decoder.GetElement("DescribeDataSharesForProducerResult") + t, err = decoder.GetElement("DescribeDataSharesForConsumerResult") if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -6170,7 +6366,7 @@ func (m *awsAwsquery_deserializeOpDescribeDataSharesForProducer) HandleDeseriali } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeOpDocumentDescribeDataSharesForProducerOutput(&output, decoder) + err = awsAwsquery_deserializeOpDocumentDescribeDataSharesForConsumerOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -6184,7 +6380,7 @@ func (m *awsAwsquery_deserializeOpDescribeDataSharesForProducer) HandleDeseriali return out, metadata, err } -func awsAwsquery_deserializeOpErrorDescribeDataSharesForProducer(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsquery_deserializeOpErrorDescribeDataSharesForConsumer(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -6222,14 +6418,14 @@ func awsAwsquery_deserializeOpErrorDescribeDataSharesForProducer(response *smith } } -type awsAwsquery_deserializeOpDescribeDefaultClusterParameters struct { +type awsAwsquery_deserializeOpDescribeDataSharesForProducer struct { } -func (*awsAwsquery_deserializeOpDescribeDefaultClusterParameters) ID() string { +func (*awsAwsquery_deserializeOpDescribeDataSharesForProducer) ID() string { return "OperationDeserializer" } -func (m *awsAwsquery_deserializeOpDescribeDefaultClusterParameters) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsquery_deserializeOpDescribeDataSharesForProducer) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -6243,9 +6439,9 @@ func (m *awsAwsquery_deserializeOpDescribeDefaultClusterParameters) HandleDeseri } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsquery_deserializeOpErrorDescribeDefaultClusterParameters(response, &metadata) + return out, metadata, awsAwsquery_deserializeOpErrorDescribeDataSharesForProducer(response, &metadata) } - output := &DescribeDefaultClusterParametersOutput{} + output := &DescribeDataSharesForProducerOutput{} out.Result = output var buff [1024]byte @@ -6266,7 +6462,7 @@ func (m *awsAwsquery_deserializeOpDescribeDefaultClusterParameters) HandleDeseri } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - t, err = decoder.GetElement("DescribeDefaultClusterParametersResult") + t, err = decoder.GetElement("DescribeDataSharesForProducerResult") if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -6278,7 +6474,7 @@ func (m *awsAwsquery_deserializeOpDescribeDefaultClusterParameters) HandleDeseri } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeOpDocumentDescribeDefaultClusterParametersOutput(&output, decoder) + err = awsAwsquery_deserializeOpDocumentDescribeDataSharesForProducerOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -6292,7 +6488,7 @@ func (m *awsAwsquery_deserializeOpDescribeDefaultClusterParameters) HandleDeseri return out, metadata, err } -func awsAwsquery_deserializeOpErrorDescribeDefaultClusterParameters(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsquery_deserializeOpErrorDescribeDataSharesForProducer(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -6317,6 +6513,9 @@ func awsAwsquery_deserializeOpErrorDescribeDefaultClusterParameters(response *sm } errorBody.Seek(0, io.SeekStart) switch { + case strings.EqualFold("InvalidNamespaceFault", errorCode): + return awsAwsquery_deserializeErrorInvalidNamespaceFault(response, errorBody) + default: genericError := &smithy.GenericAPIError{ Code: errorCode, @@ -6327,14 +6526,14 @@ func awsAwsquery_deserializeOpErrorDescribeDefaultClusterParameters(response *sm } } -type awsAwsquery_deserializeOpDescribeEndpointAccess struct { +type awsAwsquery_deserializeOpDescribeDefaultClusterParameters struct { } -func (*awsAwsquery_deserializeOpDescribeEndpointAccess) ID() string { +func (*awsAwsquery_deserializeOpDescribeDefaultClusterParameters) ID() string { return "OperationDeserializer" } -func (m *awsAwsquery_deserializeOpDescribeEndpointAccess) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsquery_deserializeOpDescribeDefaultClusterParameters) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -6348,9 +6547,9 @@ func (m *awsAwsquery_deserializeOpDescribeEndpointAccess) HandleDeserialize(ctx } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsquery_deserializeOpErrorDescribeEndpointAccess(response, &metadata) + return out, metadata, awsAwsquery_deserializeOpErrorDescribeDefaultClusterParameters(response, &metadata) } - output := &DescribeEndpointAccessOutput{} + output := &DescribeDefaultClusterParametersOutput{} out.Result = output var buff [1024]byte @@ -6371,7 +6570,7 @@ func (m *awsAwsquery_deserializeOpDescribeEndpointAccess) HandleDeserialize(ctx } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - t, err = decoder.GetElement("DescribeEndpointAccessResult") + t, err = decoder.GetElement("DescribeDefaultClusterParametersResult") if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -6383,7 +6582,7 @@ func (m *awsAwsquery_deserializeOpDescribeEndpointAccess) HandleDeserialize(ctx } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeOpDocumentDescribeEndpointAccessOutput(&output, decoder) + err = awsAwsquery_deserializeOpDocumentDescribeDefaultClusterParametersOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -6397,7 +6596,112 @@ func (m *awsAwsquery_deserializeOpDescribeEndpointAccess) HandleDeserialize(ctx return out, metadata, err } -func awsAwsquery_deserializeOpErrorDescribeEndpointAccess(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsquery_deserializeOpErrorDescribeDefaultClusterParameters(response *smithyhttp.Response, metadata *middleware.Metadata) error { + var errorBuffer bytes.Buffer + if _, err := io.Copy(&errorBuffer, response.Body); err != nil { + return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} + } + errorBody := bytes.NewReader(errorBuffer.Bytes()) + + errorCode := "UnknownError" + errorMessage := errorCode + + errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) + if err != nil { + return err + } + if reqID := errorComponents.RequestID; len(reqID) != 0 { + awsmiddleware.SetRequestIDMetadata(metadata, reqID) + } + if len(errorComponents.Code) != 0 { + errorCode = errorComponents.Code + } + if len(errorComponents.Message) != 0 { + errorMessage = errorComponents.Message + } + errorBody.Seek(0, io.SeekStart) + switch { + default: + genericError := &smithy.GenericAPIError{ + Code: errorCode, + Message: errorMessage, + } + return genericError + + } +} + +type awsAwsquery_deserializeOpDescribeEndpointAccess struct { +} + +func (*awsAwsquery_deserializeOpDescribeEndpointAccess) ID() string { + return "OperationDeserializer" +} + +func (m *awsAwsquery_deserializeOpDescribeEndpointAccess) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( + out middleware.DeserializeOutput, metadata middleware.Metadata, err error, +) { + out, metadata, err = next.HandleDeserialize(ctx, in) + if err != nil { + return out, metadata, err + } + + response, ok := out.RawResponse.(*smithyhttp.Response) + if !ok { + return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} + } + + if response.StatusCode < 200 || response.StatusCode >= 300 { + return out, metadata, awsAwsquery_deserializeOpErrorDescribeEndpointAccess(response, &metadata) + } + output := &DescribeEndpointAccessOutput{} + out.Result = output + + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + body := io.TeeReader(response.Body, ringBuffer) + rootDecoder := xml.NewDecoder(body) + t, err := smithyxml.FetchRootElement(rootDecoder) + if err == io.EOF { + return out, metadata, nil + } + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + return out, metadata, &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + } + + decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) + t, err = decoder.GetElement("DescribeEndpointAccessResult") + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return out, metadata, err + } + + decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) + err = awsAwsquery_deserializeOpDocumentDescribeEndpointAccessOutput(&output, decoder) + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return out, metadata, err + } + + return out, metadata, err +} + +func awsAwsquery_deserializeOpErrorDescribeEndpointAccess(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -10163,6 +10467,9 @@ func awsAwsquery_deserializeOpErrorModifyCluster(response *smithyhttp.Response, case strings.EqualFold("ClusterSecurityGroupNotFound", errorCode): return awsAwsquery_deserializeErrorClusterSecurityGroupNotFoundFault(response, errorBody) + case strings.EqualFold("CustomCnameAssociationFault", errorCode): + return awsAwsquery_deserializeErrorCustomCnameAssociationFault(response, errorBody) + case strings.EqualFold("DependentServiceRequestThrottlingFault", errorCode): return awsAwsquery_deserializeErrorDependentServiceRequestThrottlingFault(response, errorBody) @@ -10205,6 +10512,9 @@ func awsAwsquery_deserializeOpErrorModifyCluster(response *smithyhttp.Response, case strings.EqualFold("UnauthorizedOperation", errorCode): return awsAwsquery_deserializeErrorUnauthorizedOperation(response, errorBody) + case strings.EqualFold("UnsupportedOperation", errorCode): + return awsAwsquery_deserializeErrorUnsupportedOperationFault(response, errorBody) + case strings.EqualFold("UnsupportedOptionFault", errorCode): return awsAwsquery_deserializeErrorUnsupportedOptionFault(response, errorBody) @@ -10981,6 +11291,120 @@ func awsAwsquery_deserializeOpErrorModifyClusterSubnetGroup(response *smithyhttp } } +type awsAwsquery_deserializeOpModifyCustomDomainAssociation struct { +} + +func (*awsAwsquery_deserializeOpModifyCustomDomainAssociation) ID() string { + return "OperationDeserializer" +} + +func (m *awsAwsquery_deserializeOpModifyCustomDomainAssociation) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( + out middleware.DeserializeOutput, metadata middleware.Metadata, err error, +) { + out, metadata, err = next.HandleDeserialize(ctx, in) + if err != nil { + return out, metadata, err + } + + response, ok := out.RawResponse.(*smithyhttp.Response) + if !ok { + return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} + } + + if response.StatusCode < 200 || response.StatusCode >= 300 { + return out, metadata, awsAwsquery_deserializeOpErrorModifyCustomDomainAssociation(response, &metadata) + } + output := &ModifyCustomDomainAssociationOutput{} + out.Result = output + + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + body := io.TeeReader(response.Body, ringBuffer) + rootDecoder := xml.NewDecoder(body) + t, err := smithyxml.FetchRootElement(rootDecoder) + if err == io.EOF { + return out, metadata, nil + } + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + return out, metadata, &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + } + + decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) + t, err = decoder.GetElement("ModifyCustomDomainAssociationResult") + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return out, metadata, err + } + + decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) + err = awsAwsquery_deserializeOpDocumentModifyCustomDomainAssociationOutput(&output, decoder) + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return out, metadata, err + } + + return out, metadata, err +} + +func awsAwsquery_deserializeOpErrorModifyCustomDomainAssociation(response *smithyhttp.Response, metadata *middleware.Metadata) error { + var errorBuffer bytes.Buffer + if _, err := io.Copy(&errorBuffer, response.Body); err != nil { + return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} + } + errorBody := bytes.NewReader(errorBuffer.Bytes()) + + errorCode := "UnknownError" + errorMessage := errorCode + + errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) + if err != nil { + return err + } + if reqID := errorComponents.RequestID; len(reqID) != 0 { + awsmiddleware.SetRequestIDMetadata(metadata, reqID) + } + if len(errorComponents.Code) != 0 { + errorCode = errorComponents.Code + } + if len(errorComponents.Message) != 0 { + errorMessage = errorComponents.Message + } + errorBody.Seek(0, io.SeekStart) + switch { + case strings.EqualFold("ClusterNotFound", errorCode): + return awsAwsquery_deserializeErrorClusterNotFoundFault(response, errorBody) + + case strings.EqualFold("CustomCnameAssociationFault", errorCode): + return awsAwsquery_deserializeErrorCustomCnameAssociationFault(response, errorBody) + + case strings.EqualFold("UnsupportedOperation", errorCode): + return awsAwsquery_deserializeErrorUnsupportedOperationFault(response, errorBody) + + default: + genericError := &smithy.GenericAPIError{ + Code: errorCode, + Message: errorMessage, + } + return genericError + + } +} + type awsAwsquery_deserializeOpModifyEndpointAccess struct { } @@ -14714,8 +15138,8 @@ func awsAwsquery_deserializeErrorCopyToRegionDisabledFault(response *smithyhttp. return output } -func awsAwsquery_deserializeErrorDependentServiceRequestThrottlingFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.DependentServiceRequestThrottlingFault{} +func awsAwsquery_deserializeErrorCustomCnameAssociationFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.CustomCnameAssociationFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -14745,7 +15169,7 @@ func awsAwsquery_deserializeErrorDependentServiceRequestThrottlingFault(response } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentDependentServiceRequestThrottlingFault(&output, decoder) + err = awsAwsquery_deserializeDocumentCustomCnameAssociationFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -14758,8 +15182,8 @@ func awsAwsquery_deserializeErrorDependentServiceRequestThrottlingFault(response return output } -func awsAwsquery_deserializeErrorDependentServiceUnavailableFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.DependentServiceUnavailableFault{} +func awsAwsquery_deserializeErrorCustomDomainAssociationNotFoundFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.CustomDomainAssociationNotFoundFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -14789,7 +15213,7 @@ func awsAwsquery_deserializeErrorDependentServiceUnavailableFault(response *smit } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentDependentServiceUnavailableFault(&output, decoder) + err = awsAwsquery_deserializeDocumentCustomDomainAssociationNotFoundFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -14802,8 +15226,8 @@ func awsAwsquery_deserializeErrorDependentServiceUnavailableFault(response *smit return output } -func awsAwsquery_deserializeErrorEndpointAlreadyExistsFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.EndpointAlreadyExistsFault{} +func awsAwsquery_deserializeErrorDependentServiceRequestThrottlingFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.DependentServiceRequestThrottlingFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -14833,7 +15257,7 @@ func awsAwsquery_deserializeErrorEndpointAlreadyExistsFault(response *smithyhttp } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentEndpointAlreadyExistsFault(&output, decoder) + err = awsAwsquery_deserializeDocumentDependentServiceRequestThrottlingFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -14846,8 +15270,8 @@ func awsAwsquery_deserializeErrorEndpointAlreadyExistsFault(response *smithyhttp return output } -func awsAwsquery_deserializeErrorEndpointAuthorizationAlreadyExistsFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.EndpointAuthorizationAlreadyExistsFault{} +func awsAwsquery_deserializeErrorDependentServiceUnavailableFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.DependentServiceUnavailableFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -14877,7 +15301,7 @@ func awsAwsquery_deserializeErrorEndpointAuthorizationAlreadyExistsFault(respons } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentEndpointAuthorizationAlreadyExistsFault(&output, decoder) + err = awsAwsquery_deserializeDocumentDependentServiceUnavailableFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -14890,8 +15314,8 @@ func awsAwsquery_deserializeErrorEndpointAuthorizationAlreadyExistsFault(respons return output } -func awsAwsquery_deserializeErrorEndpointAuthorizationNotFoundFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.EndpointAuthorizationNotFoundFault{} +func awsAwsquery_deserializeErrorEndpointAlreadyExistsFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.EndpointAlreadyExistsFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -14921,7 +15345,7 @@ func awsAwsquery_deserializeErrorEndpointAuthorizationNotFoundFault(response *sm } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentEndpointAuthorizationNotFoundFault(&output, decoder) + err = awsAwsquery_deserializeDocumentEndpointAlreadyExistsFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -14934,8 +15358,8 @@ func awsAwsquery_deserializeErrorEndpointAuthorizationNotFoundFault(response *sm return output } -func awsAwsquery_deserializeErrorEndpointAuthorizationsPerClusterLimitExceededFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.EndpointAuthorizationsPerClusterLimitExceededFault{} +func awsAwsquery_deserializeErrorEndpointAuthorizationAlreadyExistsFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.EndpointAuthorizationAlreadyExistsFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -14965,7 +15389,7 @@ func awsAwsquery_deserializeErrorEndpointAuthorizationsPerClusterLimitExceededFa } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentEndpointAuthorizationsPerClusterLimitExceededFault(&output, decoder) + err = awsAwsquery_deserializeDocumentEndpointAuthorizationAlreadyExistsFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -14978,8 +15402,8 @@ func awsAwsquery_deserializeErrorEndpointAuthorizationsPerClusterLimitExceededFa return output } -func awsAwsquery_deserializeErrorEndpointNotFoundFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.EndpointNotFoundFault{} +func awsAwsquery_deserializeErrorEndpointAuthorizationNotFoundFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.EndpointAuthorizationNotFoundFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -15009,7 +15433,7 @@ func awsAwsquery_deserializeErrorEndpointNotFoundFault(response *smithyhttp.Resp } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentEndpointNotFoundFault(&output, decoder) + err = awsAwsquery_deserializeDocumentEndpointAuthorizationNotFoundFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -15022,8 +15446,8 @@ func awsAwsquery_deserializeErrorEndpointNotFoundFault(response *smithyhttp.Resp return output } -func awsAwsquery_deserializeErrorEndpointsPerAuthorizationLimitExceededFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.EndpointsPerAuthorizationLimitExceededFault{} +func awsAwsquery_deserializeErrorEndpointAuthorizationsPerClusterLimitExceededFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.EndpointAuthorizationsPerClusterLimitExceededFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -15053,7 +15477,7 @@ func awsAwsquery_deserializeErrorEndpointsPerAuthorizationLimitExceededFault(res } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentEndpointsPerAuthorizationLimitExceededFault(&output, decoder) + err = awsAwsquery_deserializeDocumentEndpointAuthorizationsPerClusterLimitExceededFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -15066,8 +15490,8 @@ func awsAwsquery_deserializeErrorEndpointsPerAuthorizationLimitExceededFault(res return output } -func awsAwsquery_deserializeErrorEndpointsPerClusterLimitExceededFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.EndpointsPerClusterLimitExceededFault{} +func awsAwsquery_deserializeErrorEndpointNotFoundFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.EndpointNotFoundFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -15097,139 +15521,7 @@ func awsAwsquery_deserializeErrorEndpointsPerClusterLimitExceededFault(response } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentEndpointsPerClusterLimitExceededFault(&output, decoder) - if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - return &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - } - - return output -} - -func awsAwsquery_deserializeErrorEventSubscriptionQuotaExceededFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.EventSubscriptionQuotaExceededFault{} - var buff [1024]byte - ringBuffer := smithyio.NewRingBuffer(buff[:]) - body := io.TeeReader(errorBody, ringBuffer) - rootDecoder := xml.NewDecoder(body) - t, err := smithyxml.FetchRootElement(rootDecoder) - if err == io.EOF { - return output - } - if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - return &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - } - - decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - t, err = decoder.GetElement("Error") - if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - return &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - } - - decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentEventSubscriptionQuotaExceededFault(&output, decoder) - if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - return &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - } - - return output -} - -func awsAwsquery_deserializeErrorHsmClientCertificateAlreadyExistsFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.HsmClientCertificateAlreadyExistsFault{} - var buff [1024]byte - ringBuffer := smithyio.NewRingBuffer(buff[:]) - body := io.TeeReader(errorBody, ringBuffer) - rootDecoder := xml.NewDecoder(body) - t, err := smithyxml.FetchRootElement(rootDecoder) - if err == io.EOF { - return output - } - if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - return &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - } - - decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - t, err = decoder.GetElement("Error") - if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - return &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - } - - decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentHsmClientCertificateAlreadyExistsFault(&output, decoder) - if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - return &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - } - - return output -} - -func awsAwsquery_deserializeErrorHsmClientCertificateNotFoundFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.HsmClientCertificateNotFoundFault{} - var buff [1024]byte - ringBuffer := smithyio.NewRingBuffer(buff[:]) - body := io.TeeReader(errorBody, ringBuffer) - rootDecoder := xml.NewDecoder(body) - t, err := smithyxml.FetchRootElement(rootDecoder) - if err == io.EOF { - return output - } - if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - return &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - } - - decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - t, err = decoder.GetElement("Error") - if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - return &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - } - - decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentHsmClientCertificateNotFoundFault(&output, decoder) + err = awsAwsquery_deserializeDocumentEndpointNotFoundFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -15242,8 +15534,8 @@ func awsAwsquery_deserializeErrorHsmClientCertificateNotFoundFault(response *smi return output } -func awsAwsquery_deserializeErrorHsmClientCertificateQuotaExceededFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.HsmClientCertificateQuotaExceededFault{} +func awsAwsquery_deserializeErrorEndpointsPerAuthorizationLimitExceededFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.EndpointsPerAuthorizationLimitExceededFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -15273,7 +15565,7 @@ func awsAwsquery_deserializeErrorHsmClientCertificateQuotaExceededFault(response } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentHsmClientCertificateQuotaExceededFault(&output, decoder) + err = awsAwsquery_deserializeDocumentEndpointsPerAuthorizationLimitExceededFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -15286,8 +15578,8 @@ func awsAwsquery_deserializeErrorHsmClientCertificateQuotaExceededFault(response return output } -func awsAwsquery_deserializeErrorHsmConfigurationAlreadyExistsFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.HsmConfigurationAlreadyExistsFault{} +func awsAwsquery_deserializeErrorEndpointsPerClusterLimitExceededFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.EndpointsPerClusterLimitExceededFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -15317,7 +15609,7 @@ func awsAwsquery_deserializeErrorHsmConfigurationAlreadyExistsFault(response *sm } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentHsmConfigurationAlreadyExistsFault(&output, decoder) + err = awsAwsquery_deserializeDocumentEndpointsPerClusterLimitExceededFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -15330,8 +15622,8 @@ func awsAwsquery_deserializeErrorHsmConfigurationAlreadyExistsFault(response *sm return output } -func awsAwsquery_deserializeErrorHsmConfigurationNotFoundFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.HsmConfigurationNotFoundFault{} +func awsAwsquery_deserializeErrorEventSubscriptionQuotaExceededFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.EventSubscriptionQuotaExceededFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -15361,7 +15653,7 @@ func awsAwsquery_deserializeErrorHsmConfigurationNotFoundFault(response *smithyh } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentHsmConfigurationNotFoundFault(&output, decoder) + err = awsAwsquery_deserializeDocumentEventSubscriptionQuotaExceededFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -15374,8 +15666,8 @@ func awsAwsquery_deserializeErrorHsmConfigurationNotFoundFault(response *smithyh return output } -func awsAwsquery_deserializeErrorHsmConfigurationQuotaExceededFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.HsmConfigurationQuotaExceededFault{} +func awsAwsquery_deserializeErrorHsmClientCertificateAlreadyExistsFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.HsmClientCertificateAlreadyExistsFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -15405,7 +15697,7 @@ func awsAwsquery_deserializeErrorHsmConfigurationQuotaExceededFault(response *sm } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentHsmConfigurationQuotaExceededFault(&output, decoder) + err = awsAwsquery_deserializeDocumentHsmClientCertificateAlreadyExistsFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -15418,8 +15710,8 @@ func awsAwsquery_deserializeErrorHsmConfigurationQuotaExceededFault(response *sm return output } -func awsAwsquery_deserializeErrorIncompatibleOrderableOptions(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.IncompatibleOrderableOptions{} +func awsAwsquery_deserializeErrorHsmClientCertificateNotFoundFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.HsmClientCertificateNotFoundFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -15449,7 +15741,7 @@ func awsAwsquery_deserializeErrorIncompatibleOrderableOptions(response *smithyht } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentIncompatibleOrderableOptions(&output, decoder) + err = awsAwsquery_deserializeDocumentHsmClientCertificateNotFoundFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -15462,8 +15754,8 @@ func awsAwsquery_deserializeErrorIncompatibleOrderableOptions(response *smithyht return output } -func awsAwsquery_deserializeErrorInProgressTableRestoreQuotaExceededFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.InProgressTableRestoreQuotaExceededFault{} +func awsAwsquery_deserializeErrorHsmClientCertificateQuotaExceededFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.HsmClientCertificateQuotaExceededFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -15493,7 +15785,7 @@ func awsAwsquery_deserializeErrorInProgressTableRestoreQuotaExceededFault(respon } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentInProgressTableRestoreQuotaExceededFault(&output, decoder) + err = awsAwsquery_deserializeDocumentHsmClientCertificateQuotaExceededFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -15506,8 +15798,8 @@ func awsAwsquery_deserializeErrorInProgressTableRestoreQuotaExceededFault(respon return output } -func awsAwsquery_deserializeErrorInsufficientClusterCapacityFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.InsufficientClusterCapacityFault{} +func awsAwsquery_deserializeErrorHsmConfigurationAlreadyExistsFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.HsmConfigurationAlreadyExistsFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -15537,7 +15829,7 @@ func awsAwsquery_deserializeErrorInsufficientClusterCapacityFault(response *smit } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentInsufficientClusterCapacityFault(&output, decoder) + err = awsAwsquery_deserializeDocumentHsmConfigurationAlreadyExistsFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -15550,8 +15842,8 @@ func awsAwsquery_deserializeErrorInsufficientClusterCapacityFault(response *smit return output } -func awsAwsquery_deserializeErrorInsufficientS3BucketPolicyFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.InsufficientS3BucketPolicyFault{} +func awsAwsquery_deserializeErrorHsmConfigurationNotFoundFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.HsmConfigurationNotFoundFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -15581,7 +15873,7 @@ func awsAwsquery_deserializeErrorInsufficientS3BucketPolicyFault(response *smith } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentInsufficientS3BucketPolicyFault(&output, decoder) + err = awsAwsquery_deserializeDocumentHsmConfigurationNotFoundFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -15594,8 +15886,8 @@ func awsAwsquery_deserializeErrorInsufficientS3BucketPolicyFault(response *smith return output } -func awsAwsquery_deserializeErrorInvalidAuthenticationProfileRequestFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.InvalidAuthenticationProfileRequestFault{} +func awsAwsquery_deserializeErrorHsmConfigurationQuotaExceededFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.HsmConfigurationQuotaExceededFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -15625,7 +15917,7 @@ func awsAwsquery_deserializeErrorInvalidAuthenticationProfileRequestFault(respon } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentInvalidAuthenticationProfileRequestFault(&output, decoder) + err = awsAwsquery_deserializeDocumentHsmConfigurationQuotaExceededFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -15638,8 +15930,8 @@ func awsAwsquery_deserializeErrorInvalidAuthenticationProfileRequestFault(respon return output } -func awsAwsquery_deserializeErrorInvalidAuthorizationStateFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.InvalidAuthorizationStateFault{} +func awsAwsquery_deserializeErrorIncompatibleOrderableOptions(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.IncompatibleOrderableOptions{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -15669,7 +15961,7 @@ func awsAwsquery_deserializeErrorInvalidAuthorizationStateFault(response *smithy } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentInvalidAuthorizationStateFault(&output, decoder) + err = awsAwsquery_deserializeDocumentIncompatibleOrderableOptions(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -15682,8 +15974,8 @@ func awsAwsquery_deserializeErrorInvalidAuthorizationStateFault(response *smithy return output } -func awsAwsquery_deserializeErrorInvalidClusterParameterGroupStateFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.InvalidClusterParameterGroupStateFault{} +func awsAwsquery_deserializeErrorInProgressTableRestoreQuotaExceededFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.InProgressTableRestoreQuotaExceededFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -15713,7 +16005,7 @@ func awsAwsquery_deserializeErrorInvalidClusterParameterGroupStateFault(response } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentInvalidClusterParameterGroupStateFault(&output, decoder) + err = awsAwsquery_deserializeDocumentInProgressTableRestoreQuotaExceededFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -15726,8 +16018,8 @@ func awsAwsquery_deserializeErrorInvalidClusterParameterGroupStateFault(response return output } -func awsAwsquery_deserializeErrorInvalidClusterSecurityGroupStateFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.InvalidClusterSecurityGroupStateFault{} +func awsAwsquery_deserializeErrorInsufficientClusterCapacityFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.InsufficientClusterCapacityFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -15757,7 +16049,7 @@ func awsAwsquery_deserializeErrorInvalidClusterSecurityGroupStateFault(response } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentInvalidClusterSecurityGroupStateFault(&output, decoder) + err = awsAwsquery_deserializeDocumentInsufficientClusterCapacityFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -15770,8 +16062,8 @@ func awsAwsquery_deserializeErrorInvalidClusterSecurityGroupStateFault(response return output } -func awsAwsquery_deserializeErrorInvalidClusterSnapshotScheduleStateFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.InvalidClusterSnapshotScheduleStateFault{} +func awsAwsquery_deserializeErrorInsufficientS3BucketPolicyFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.InsufficientS3BucketPolicyFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -15801,7 +16093,7 @@ func awsAwsquery_deserializeErrorInvalidClusterSnapshotScheduleStateFault(respon } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentInvalidClusterSnapshotScheduleStateFault(&output, decoder) + err = awsAwsquery_deserializeDocumentInsufficientS3BucketPolicyFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -15814,8 +16106,8 @@ func awsAwsquery_deserializeErrorInvalidClusterSnapshotScheduleStateFault(respon return output } -func awsAwsquery_deserializeErrorInvalidClusterSnapshotStateFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.InvalidClusterSnapshotStateFault{} +func awsAwsquery_deserializeErrorInvalidAuthenticationProfileRequestFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.InvalidAuthenticationProfileRequestFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -15845,7 +16137,7 @@ func awsAwsquery_deserializeErrorInvalidClusterSnapshotStateFault(response *smit } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentInvalidClusterSnapshotStateFault(&output, decoder) + err = awsAwsquery_deserializeDocumentInvalidAuthenticationProfileRequestFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -15858,8 +16150,8 @@ func awsAwsquery_deserializeErrorInvalidClusterSnapshotStateFault(response *smit return output } -func awsAwsquery_deserializeErrorInvalidClusterStateFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.InvalidClusterStateFault{} +func awsAwsquery_deserializeErrorInvalidAuthorizationStateFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.InvalidAuthorizationStateFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -15889,7 +16181,7 @@ func awsAwsquery_deserializeErrorInvalidClusterStateFault(response *smithyhttp.R } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentInvalidClusterStateFault(&output, decoder) + err = awsAwsquery_deserializeDocumentInvalidAuthorizationStateFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -15902,8 +16194,8 @@ func awsAwsquery_deserializeErrorInvalidClusterStateFault(response *smithyhttp.R return output } -func awsAwsquery_deserializeErrorInvalidClusterSubnetGroupStateFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.InvalidClusterSubnetGroupStateFault{} +func awsAwsquery_deserializeErrorInvalidClusterParameterGroupStateFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.InvalidClusterParameterGroupStateFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -15933,7 +16225,7 @@ func awsAwsquery_deserializeErrorInvalidClusterSubnetGroupStateFault(response *s } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentInvalidClusterSubnetGroupStateFault(&output, decoder) + err = awsAwsquery_deserializeDocumentInvalidClusterParameterGroupStateFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -15946,8 +16238,8 @@ func awsAwsquery_deserializeErrorInvalidClusterSubnetGroupStateFault(response *s return output } -func awsAwsquery_deserializeErrorInvalidClusterSubnetStateFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.InvalidClusterSubnetStateFault{} +func awsAwsquery_deserializeErrorInvalidClusterSecurityGroupStateFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.InvalidClusterSecurityGroupStateFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -15977,7 +16269,7 @@ func awsAwsquery_deserializeErrorInvalidClusterSubnetStateFault(response *smithy } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentInvalidClusterSubnetStateFault(&output, decoder) + err = awsAwsquery_deserializeDocumentInvalidClusterSecurityGroupStateFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -15990,8 +16282,8 @@ func awsAwsquery_deserializeErrorInvalidClusterSubnetStateFault(response *smithy return output } -func awsAwsquery_deserializeErrorInvalidClusterTrackFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.InvalidClusterTrackFault{} +func awsAwsquery_deserializeErrorInvalidClusterSnapshotScheduleStateFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.InvalidClusterSnapshotScheduleStateFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -16021,7 +16313,7 @@ func awsAwsquery_deserializeErrorInvalidClusterTrackFault(response *smithyhttp.R } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentInvalidClusterTrackFault(&output, decoder) + err = awsAwsquery_deserializeDocumentInvalidClusterSnapshotScheduleStateFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -16034,8 +16326,8 @@ func awsAwsquery_deserializeErrorInvalidClusterTrackFault(response *smithyhttp.R return output } -func awsAwsquery_deserializeErrorInvalidDataShareFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.InvalidDataShareFault{} +func awsAwsquery_deserializeErrorInvalidClusterSnapshotStateFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.InvalidClusterSnapshotStateFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -16065,7 +16357,7 @@ func awsAwsquery_deserializeErrorInvalidDataShareFault(response *smithyhttp.Resp } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentInvalidDataShareFault(&output, decoder) + err = awsAwsquery_deserializeDocumentInvalidClusterSnapshotStateFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -16078,8 +16370,8 @@ func awsAwsquery_deserializeErrorInvalidDataShareFault(response *smithyhttp.Resp return output } -func awsAwsquery_deserializeErrorInvalidElasticIpFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.InvalidElasticIpFault{} +func awsAwsquery_deserializeErrorInvalidClusterStateFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.InvalidClusterStateFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -16109,7 +16401,7 @@ func awsAwsquery_deserializeErrorInvalidElasticIpFault(response *smithyhttp.Resp } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentInvalidElasticIpFault(&output, decoder) + err = awsAwsquery_deserializeDocumentInvalidClusterStateFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -16122,8 +16414,8 @@ func awsAwsquery_deserializeErrorInvalidElasticIpFault(response *smithyhttp.Resp return output } -func awsAwsquery_deserializeErrorInvalidEndpointStateFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.InvalidEndpointStateFault{} +func awsAwsquery_deserializeErrorInvalidClusterSubnetGroupStateFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.InvalidClusterSubnetGroupStateFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -16153,7 +16445,7 @@ func awsAwsquery_deserializeErrorInvalidEndpointStateFault(response *smithyhttp. } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentInvalidEndpointStateFault(&output, decoder) + err = awsAwsquery_deserializeDocumentInvalidClusterSubnetGroupStateFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -16166,8 +16458,8 @@ func awsAwsquery_deserializeErrorInvalidEndpointStateFault(response *smithyhttp. return output } -func awsAwsquery_deserializeErrorInvalidHsmClientCertificateStateFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.InvalidHsmClientCertificateStateFault{} +func awsAwsquery_deserializeErrorInvalidClusterSubnetStateFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.InvalidClusterSubnetStateFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -16197,7 +16489,7 @@ func awsAwsquery_deserializeErrorInvalidHsmClientCertificateStateFault(response } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentInvalidHsmClientCertificateStateFault(&output, decoder) + err = awsAwsquery_deserializeDocumentInvalidClusterSubnetStateFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -16210,8 +16502,8 @@ func awsAwsquery_deserializeErrorInvalidHsmClientCertificateStateFault(response return output } -func awsAwsquery_deserializeErrorInvalidHsmConfigurationStateFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.InvalidHsmConfigurationStateFault{} +func awsAwsquery_deserializeErrorInvalidClusterTrackFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.InvalidClusterTrackFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -16241,7 +16533,7 @@ func awsAwsquery_deserializeErrorInvalidHsmConfigurationStateFault(response *smi } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentInvalidHsmConfigurationStateFault(&output, decoder) + err = awsAwsquery_deserializeDocumentInvalidClusterTrackFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -16254,8 +16546,8 @@ func awsAwsquery_deserializeErrorInvalidHsmConfigurationStateFault(response *smi return output } -func awsAwsquery_deserializeErrorInvalidNamespaceFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.InvalidNamespaceFault{} +func awsAwsquery_deserializeErrorInvalidDataShareFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.InvalidDataShareFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -16285,7 +16577,7 @@ func awsAwsquery_deserializeErrorInvalidNamespaceFault(response *smithyhttp.Resp } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentInvalidNamespaceFault(&output, decoder) + err = awsAwsquery_deserializeDocumentInvalidDataShareFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -16298,8 +16590,8 @@ func awsAwsquery_deserializeErrorInvalidNamespaceFault(response *smithyhttp.Resp return output } -func awsAwsquery_deserializeErrorInvalidReservedNodeStateFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.InvalidReservedNodeStateFault{} +func awsAwsquery_deserializeErrorInvalidElasticIpFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.InvalidElasticIpFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -16329,7 +16621,7 @@ func awsAwsquery_deserializeErrorInvalidReservedNodeStateFault(response *smithyh } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentInvalidReservedNodeStateFault(&output, decoder) + err = awsAwsquery_deserializeDocumentInvalidElasticIpFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -16342,8 +16634,8 @@ func awsAwsquery_deserializeErrorInvalidReservedNodeStateFault(response *smithyh return output } -func awsAwsquery_deserializeErrorInvalidRestoreFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.InvalidRestoreFault{} +func awsAwsquery_deserializeErrorInvalidEndpointStateFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.InvalidEndpointStateFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -16373,7 +16665,7 @@ func awsAwsquery_deserializeErrorInvalidRestoreFault(response *smithyhttp.Respon } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentInvalidRestoreFault(&output, decoder) + err = awsAwsquery_deserializeDocumentInvalidEndpointStateFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -16386,8 +16678,8 @@ func awsAwsquery_deserializeErrorInvalidRestoreFault(response *smithyhttp.Respon return output } -func awsAwsquery_deserializeErrorInvalidRetentionPeriodFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.InvalidRetentionPeriodFault{} +func awsAwsquery_deserializeErrorInvalidHsmClientCertificateStateFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.InvalidHsmClientCertificateStateFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -16417,7 +16709,7 @@ func awsAwsquery_deserializeErrorInvalidRetentionPeriodFault(response *smithyhtt } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentInvalidRetentionPeriodFault(&output, decoder) + err = awsAwsquery_deserializeDocumentInvalidHsmClientCertificateStateFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -16430,8 +16722,8 @@ func awsAwsquery_deserializeErrorInvalidRetentionPeriodFault(response *smithyhtt return output } -func awsAwsquery_deserializeErrorInvalidS3BucketNameFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.InvalidS3BucketNameFault{} +func awsAwsquery_deserializeErrorInvalidHsmConfigurationStateFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.InvalidHsmConfigurationStateFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -16461,7 +16753,7 @@ func awsAwsquery_deserializeErrorInvalidS3BucketNameFault(response *smithyhttp.R } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentInvalidS3BucketNameFault(&output, decoder) + err = awsAwsquery_deserializeDocumentInvalidHsmConfigurationStateFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -16474,8 +16766,8 @@ func awsAwsquery_deserializeErrorInvalidS3BucketNameFault(response *smithyhttp.R return output } -func awsAwsquery_deserializeErrorInvalidS3KeyPrefixFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.InvalidS3KeyPrefixFault{} +func awsAwsquery_deserializeErrorInvalidNamespaceFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.InvalidNamespaceFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -16505,7 +16797,7 @@ func awsAwsquery_deserializeErrorInvalidS3KeyPrefixFault(response *smithyhttp.Re } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentInvalidS3KeyPrefixFault(&output, decoder) + err = awsAwsquery_deserializeDocumentInvalidNamespaceFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -16518,8 +16810,8 @@ func awsAwsquery_deserializeErrorInvalidS3KeyPrefixFault(response *smithyhttp.Re return output } -func awsAwsquery_deserializeErrorInvalidScheduledActionFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.InvalidScheduledActionFault{} +func awsAwsquery_deserializeErrorInvalidReservedNodeStateFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.InvalidReservedNodeStateFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -16549,7 +16841,7 @@ func awsAwsquery_deserializeErrorInvalidScheduledActionFault(response *smithyhtt } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentInvalidScheduledActionFault(&output, decoder) + err = awsAwsquery_deserializeDocumentInvalidReservedNodeStateFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -16562,8 +16854,8 @@ func awsAwsquery_deserializeErrorInvalidScheduledActionFault(response *smithyhtt return output } -func awsAwsquery_deserializeErrorInvalidScheduleFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.InvalidScheduleFault{} +func awsAwsquery_deserializeErrorInvalidRestoreFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.InvalidRestoreFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -16593,7 +16885,7 @@ func awsAwsquery_deserializeErrorInvalidScheduleFault(response *smithyhttp.Respo } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentInvalidScheduleFault(&output, decoder) + err = awsAwsquery_deserializeDocumentInvalidRestoreFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -16606,8 +16898,8 @@ func awsAwsquery_deserializeErrorInvalidScheduleFault(response *smithyhttp.Respo return output } -func awsAwsquery_deserializeErrorInvalidSnapshotCopyGrantStateFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.InvalidSnapshotCopyGrantStateFault{} +func awsAwsquery_deserializeErrorInvalidRetentionPeriodFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.InvalidRetentionPeriodFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -16637,7 +16929,7 @@ func awsAwsquery_deserializeErrorInvalidSnapshotCopyGrantStateFault(response *sm } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentInvalidSnapshotCopyGrantStateFault(&output, decoder) + err = awsAwsquery_deserializeDocumentInvalidRetentionPeriodFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -16650,8 +16942,8 @@ func awsAwsquery_deserializeErrorInvalidSnapshotCopyGrantStateFault(response *sm return output } -func awsAwsquery_deserializeErrorInvalidSubnet(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.InvalidSubnet{} +func awsAwsquery_deserializeErrorInvalidS3BucketNameFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.InvalidS3BucketNameFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -16681,7 +16973,7 @@ func awsAwsquery_deserializeErrorInvalidSubnet(response *smithyhttp.Response, er } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentInvalidSubnet(&output, decoder) + err = awsAwsquery_deserializeDocumentInvalidS3BucketNameFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -16694,8 +16986,8 @@ func awsAwsquery_deserializeErrorInvalidSubnet(response *smithyhttp.Response, er return output } -func awsAwsquery_deserializeErrorInvalidSubscriptionStateFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.InvalidSubscriptionStateFault{} +func awsAwsquery_deserializeErrorInvalidS3KeyPrefixFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.InvalidS3KeyPrefixFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -16725,7 +17017,7 @@ func awsAwsquery_deserializeErrorInvalidSubscriptionStateFault(response *smithyh } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentInvalidSubscriptionStateFault(&output, decoder) + err = awsAwsquery_deserializeDocumentInvalidS3KeyPrefixFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -16738,8 +17030,8 @@ func awsAwsquery_deserializeErrorInvalidSubscriptionStateFault(response *smithyh return output } -func awsAwsquery_deserializeErrorInvalidTableRestoreArgumentFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.InvalidTableRestoreArgumentFault{} +func awsAwsquery_deserializeErrorInvalidScheduledActionFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.InvalidScheduledActionFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -16769,7 +17061,7 @@ func awsAwsquery_deserializeErrorInvalidTableRestoreArgumentFault(response *smit } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentInvalidTableRestoreArgumentFault(&output, decoder) + err = awsAwsquery_deserializeDocumentInvalidScheduledActionFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -16782,8 +17074,8 @@ func awsAwsquery_deserializeErrorInvalidTableRestoreArgumentFault(response *smit return output } -func awsAwsquery_deserializeErrorInvalidTagFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.InvalidTagFault{} +func awsAwsquery_deserializeErrorInvalidScheduleFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.InvalidScheduleFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -16813,7 +17105,7 @@ func awsAwsquery_deserializeErrorInvalidTagFault(response *smithyhttp.Response, } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentInvalidTagFault(&output, decoder) + err = awsAwsquery_deserializeDocumentInvalidScheduleFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -16826,8 +17118,8 @@ func awsAwsquery_deserializeErrorInvalidTagFault(response *smithyhttp.Response, return output } -func awsAwsquery_deserializeErrorInvalidUsageLimitFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.InvalidUsageLimitFault{} +func awsAwsquery_deserializeErrorInvalidSnapshotCopyGrantStateFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.InvalidSnapshotCopyGrantStateFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -16857,7 +17149,7 @@ func awsAwsquery_deserializeErrorInvalidUsageLimitFault(response *smithyhttp.Res } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentInvalidUsageLimitFault(&output, decoder) + err = awsAwsquery_deserializeDocumentInvalidSnapshotCopyGrantStateFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -16870,8 +17162,8 @@ func awsAwsquery_deserializeErrorInvalidUsageLimitFault(response *smithyhttp.Res return output } -func awsAwsquery_deserializeErrorInvalidVPCNetworkStateFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.InvalidVPCNetworkStateFault{} +func awsAwsquery_deserializeErrorInvalidSubnet(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.InvalidSubnet{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -16901,7 +17193,7 @@ func awsAwsquery_deserializeErrorInvalidVPCNetworkStateFault(response *smithyhtt } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentInvalidVPCNetworkStateFault(&output, decoder) + err = awsAwsquery_deserializeDocumentInvalidSubnet(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -16914,8 +17206,8 @@ func awsAwsquery_deserializeErrorInvalidVPCNetworkStateFault(response *smithyhtt return output } -func awsAwsquery_deserializeErrorLimitExceededFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.LimitExceededFault{} +func awsAwsquery_deserializeErrorInvalidSubscriptionStateFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.InvalidSubscriptionStateFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -16945,7 +17237,7 @@ func awsAwsquery_deserializeErrorLimitExceededFault(response *smithyhttp.Respons } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentLimitExceededFault(&output, decoder) + err = awsAwsquery_deserializeDocumentInvalidSubscriptionStateFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -16958,8 +17250,8 @@ func awsAwsquery_deserializeErrorLimitExceededFault(response *smithyhttp.Respons return output } -func awsAwsquery_deserializeErrorNumberOfNodesPerClusterLimitExceededFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.NumberOfNodesPerClusterLimitExceededFault{} +func awsAwsquery_deserializeErrorInvalidTableRestoreArgumentFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.InvalidTableRestoreArgumentFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -16989,7 +17281,7 @@ func awsAwsquery_deserializeErrorNumberOfNodesPerClusterLimitExceededFault(respo } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentNumberOfNodesPerClusterLimitExceededFault(&output, decoder) + err = awsAwsquery_deserializeDocumentInvalidTableRestoreArgumentFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -17002,8 +17294,8 @@ func awsAwsquery_deserializeErrorNumberOfNodesPerClusterLimitExceededFault(respo return output } -func awsAwsquery_deserializeErrorNumberOfNodesQuotaExceededFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.NumberOfNodesQuotaExceededFault{} +func awsAwsquery_deserializeErrorInvalidTagFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.InvalidTagFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -17033,7 +17325,7 @@ func awsAwsquery_deserializeErrorNumberOfNodesQuotaExceededFault(response *smith } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentNumberOfNodesQuotaExceededFault(&output, decoder) + err = awsAwsquery_deserializeDocumentInvalidTagFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -17046,8 +17338,8 @@ func awsAwsquery_deserializeErrorNumberOfNodesQuotaExceededFault(response *smith return output } -func awsAwsquery_deserializeErrorPartnerNotFoundFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.PartnerNotFoundFault{} +func awsAwsquery_deserializeErrorInvalidUsageLimitFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.InvalidUsageLimitFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -17077,7 +17369,7 @@ func awsAwsquery_deserializeErrorPartnerNotFoundFault(response *smithyhttp.Respo } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentPartnerNotFoundFault(&output, decoder) + err = awsAwsquery_deserializeDocumentInvalidUsageLimitFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -17090,8 +17382,8 @@ func awsAwsquery_deserializeErrorPartnerNotFoundFault(response *smithyhttp.Respo return output } -func awsAwsquery_deserializeErrorReservedNodeAlreadyExistsFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.ReservedNodeAlreadyExistsFault{} +func awsAwsquery_deserializeErrorInvalidVPCNetworkStateFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.InvalidVPCNetworkStateFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -17121,7 +17413,7 @@ func awsAwsquery_deserializeErrorReservedNodeAlreadyExistsFault(response *smithy } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentReservedNodeAlreadyExistsFault(&output, decoder) + err = awsAwsquery_deserializeDocumentInvalidVPCNetworkStateFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -17134,8 +17426,8 @@ func awsAwsquery_deserializeErrorReservedNodeAlreadyExistsFault(response *smithy return output } -func awsAwsquery_deserializeErrorReservedNodeAlreadyMigratedFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.ReservedNodeAlreadyMigratedFault{} +func awsAwsquery_deserializeErrorLimitExceededFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.LimitExceededFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -17165,7 +17457,7 @@ func awsAwsquery_deserializeErrorReservedNodeAlreadyMigratedFault(response *smit } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentReservedNodeAlreadyMigratedFault(&output, decoder) + err = awsAwsquery_deserializeDocumentLimitExceededFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -17178,8 +17470,8 @@ func awsAwsquery_deserializeErrorReservedNodeAlreadyMigratedFault(response *smit return output } -func awsAwsquery_deserializeErrorReservedNodeExchangeNotFoundFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.ReservedNodeExchangeNotFoundFault{} +func awsAwsquery_deserializeErrorNumberOfNodesPerClusterLimitExceededFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.NumberOfNodesPerClusterLimitExceededFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -17209,7 +17501,7 @@ func awsAwsquery_deserializeErrorReservedNodeExchangeNotFoundFault(response *smi } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentReservedNodeExchangeNotFoundFault(&output, decoder) + err = awsAwsquery_deserializeDocumentNumberOfNodesPerClusterLimitExceededFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -17222,8 +17514,8 @@ func awsAwsquery_deserializeErrorReservedNodeExchangeNotFoundFault(response *smi return output } -func awsAwsquery_deserializeErrorReservedNodeNotFoundFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.ReservedNodeNotFoundFault{} +func awsAwsquery_deserializeErrorNumberOfNodesQuotaExceededFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.NumberOfNodesQuotaExceededFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -17253,7 +17545,7 @@ func awsAwsquery_deserializeErrorReservedNodeNotFoundFault(response *smithyhttp. } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentReservedNodeNotFoundFault(&output, decoder) + err = awsAwsquery_deserializeDocumentNumberOfNodesQuotaExceededFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -17266,8 +17558,8 @@ func awsAwsquery_deserializeErrorReservedNodeNotFoundFault(response *smithyhttp. return output } -func awsAwsquery_deserializeErrorReservedNodeOfferingNotFoundFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.ReservedNodeOfferingNotFoundFault{} +func awsAwsquery_deserializeErrorPartnerNotFoundFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.PartnerNotFoundFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -17297,7 +17589,7 @@ func awsAwsquery_deserializeErrorReservedNodeOfferingNotFoundFault(response *smi } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentReservedNodeOfferingNotFoundFault(&output, decoder) + err = awsAwsquery_deserializeDocumentPartnerNotFoundFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -17310,8 +17602,8 @@ func awsAwsquery_deserializeErrorReservedNodeOfferingNotFoundFault(response *smi return output } -func awsAwsquery_deserializeErrorReservedNodeQuotaExceededFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.ReservedNodeQuotaExceededFault{} +func awsAwsquery_deserializeErrorReservedNodeAlreadyExistsFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.ReservedNodeAlreadyExistsFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -17341,7 +17633,7 @@ func awsAwsquery_deserializeErrorReservedNodeQuotaExceededFault(response *smithy } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentReservedNodeQuotaExceededFault(&output, decoder) + err = awsAwsquery_deserializeDocumentReservedNodeAlreadyExistsFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -17354,8 +17646,8 @@ func awsAwsquery_deserializeErrorReservedNodeQuotaExceededFault(response *smithy return output } -func awsAwsquery_deserializeErrorResizeNotFoundFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.ResizeNotFoundFault{} +func awsAwsquery_deserializeErrorReservedNodeAlreadyMigratedFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.ReservedNodeAlreadyMigratedFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -17385,7 +17677,7 @@ func awsAwsquery_deserializeErrorResizeNotFoundFault(response *smithyhttp.Respon } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentResizeNotFoundFault(&output, decoder) + err = awsAwsquery_deserializeDocumentReservedNodeAlreadyMigratedFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -17398,8 +17690,8 @@ func awsAwsquery_deserializeErrorResizeNotFoundFault(response *smithyhttp.Respon return output } -func awsAwsquery_deserializeErrorResourceNotFoundFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.ResourceNotFoundFault{} +func awsAwsquery_deserializeErrorReservedNodeExchangeNotFoundFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.ReservedNodeExchangeNotFoundFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -17429,7 +17721,7 @@ func awsAwsquery_deserializeErrorResourceNotFoundFault(response *smithyhttp.Resp } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentResourceNotFoundFault(&output, decoder) + err = awsAwsquery_deserializeDocumentReservedNodeExchangeNotFoundFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -17442,8 +17734,8 @@ func awsAwsquery_deserializeErrorResourceNotFoundFault(response *smithyhttp.Resp return output } -func awsAwsquery_deserializeErrorScheduledActionAlreadyExistsFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.ScheduledActionAlreadyExistsFault{} +func awsAwsquery_deserializeErrorReservedNodeNotFoundFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.ReservedNodeNotFoundFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -17473,7 +17765,7 @@ func awsAwsquery_deserializeErrorScheduledActionAlreadyExistsFault(response *smi } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentScheduledActionAlreadyExistsFault(&output, decoder) + err = awsAwsquery_deserializeDocumentReservedNodeNotFoundFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -17486,8 +17778,8 @@ func awsAwsquery_deserializeErrorScheduledActionAlreadyExistsFault(response *smi return output } -func awsAwsquery_deserializeErrorScheduledActionNotFoundFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.ScheduledActionNotFoundFault{} +func awsAwsquery_deserializeErrorReservedNodeOfferingNotFoundFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.ReservedNodeOfferingNotFoundFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -17517,7 +17809,7 @@ func awsAwsquery_deserializeErrorScheduledActionNotFoundFault(response *smithyht } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentScheduledActionNotFoundFault(&output, decoder) + err = awsAwsquery_deserializeDocumentReservedNodeOfferingNotFoundFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -17530,8 +17822,8 @@ func awsAwsquery_deserializeErrorScheduledActionNotFoundFault(response *smithyht return output } -func awsAwsquery_deserializeErrorScheduledActionQuotaExceededFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.ScheduledActionQuotaExceededFault{} +func awsAwsquery_deserializeErrorReservedNodeQuotaExceededFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.ReservedNodeQuotaExceededFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -17561,7 +17853,7 @@ func awsAwsquery_deserializeErrorScheduledActionQuotaExceededFault(response *smi } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentScheduledActionQuotaExceededFault(&output, decoder) + err = awsAwsquery_deserializeDocumentReservedNodeQuotaExceededFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -17574,8 +17866,8 @@ func awsAwsquery_deserializeErrorScheduledActionQuotaExceededFault(response *smi return output } -func awsAwsquery_deserializeErrorScheduledActionTypeUnsupportedFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.ScheduledActionTypeUnsupportedFault{} +func awsAwsquery_deserializeErrorResizeNotFoundFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.ResizeNotFoundFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -17605,7 +17897,7 @@ func awsAwsquery_deserializeErrorScheduledActionTypeUnsupportedFault(response *s } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentScheduledActionTypeUnsupportedFault(&output, decoder) + err = awsAwsquery_deserializeDocumentResizeNotFoundFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -17618,8 +17910,8 @@ func awsAwsquery_deserializeErrorScheduledActionTypeUnsupportedFault(response *s return output } -func awsAwsquery_deserializeErrorScheduleDefinitionTypeUnsupportedFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.ScheduleDefinitionTypeUnsupportedFault{} +func awsAwsquery_deserializeErrorResourceNotFoundFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.ResourceNotFoundFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -17649,7 +17941,7 @@ func awsAwsquery_deserializeErrorScheduleDefinitionTypeUnsupportedFault(response } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentScheduleDefinitionTypeUnsupportedFault(&output, decoder) + err = awsAwsquery_deserializeDocumentResourceNotFoundFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -17662,8 +17954,8 @@ func awsAwsquery_deserializeErrorScheduleDefinitionTypeUnsupportedFault(response return output } -func awsAwsquery_deserializeErrorSnapshotCopyAlreadyDisabledFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.SnapshotCopyAlreadyDisabledFault{} +func awsAwsquery_deserializeErrorScheduledActionAlreadyExistsFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.ScheduledActionAlreadyExistsFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -17693,7 +17985,7 @@ func awsAwsquery_deserializeErrorSnapshotCopyAlreadyDisabledFault(response *smit } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentSnapshotCopyAlreadyDisabledFault(&output, decoder) + err = awsAwsquery_deserializeDocumentScheduledActionAlreadyExistsFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -17706,8 +17998,8 @@ func awsAwsquery_deserializeErrorSnapshotCopyAlreadyDisabledFault(response *smit return output } -func awsAwsquery_deserializeErrorSnapshotCopyAlreadyEnabledFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.SnapshotCopyAlreadyEnabledFault{} +func awsAwsquery_deserializeErrorScheduledActionNotFoundFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.ScheduledActionNotFoundFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -17737,7 +18029,7 @@ func awsAwsquery_deserializeErrorSnapshotCopyAlreadyEnabledFault(response *smith } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentSnapshotCopyAlreadyEnabledFault(&output, decoder) + err = awsAwsquery_deserializeDocumentScheduledActionNotFoundFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -17750,8 +18042,8 @@ func awsAwsquery_deserializeErrorSnapshotCopyAlreadyEnabledFault(response *smith return output } -func awsAwsquery_deserializeErrorSnapshotCopyDisabledFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.SnapshotCopyDisabledFault{} +func awsAwsquery_deserializeErrorScheduledActionQuotaExceededFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.ScheduledActionQuotaExceededFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -17781,7 +18073,7 @@ func awsAwsquery_deserializeErrorSnapshotCopyDisabledFault(response *smithyhttp. } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentSnapshotCopyDisabledFault(&output, decoder) + err = awsAwsquery_deserializeDocumentScheduledActionQuotaExceededFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -17794,8 +18086,8 @@ func awsAwsquery_deserializeErrorSnapshotCopyDisabledFault(response *smithyhttp. return output } -func awsAwsquery_deserializeErrorSnapshotCopyGrantAlreadyExistsFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.SnapshotCopyGrantAlreadyExistsFault{} +func awsAwsquery_deserializeErrorScheduledActionTypeUnsupportedFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.ScheduledActionTypeUnsupportedFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -17825,7 +18117,7 @@ func awsAwsquery_deserializeErrorSnapshotCopyGrantAlreadyExistsFault(response *s } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentSnapshotCopyGrantAlreadyExistsFault(&output, decoder) + err = awsAwsquery_deserializeDocumentScheduledActionTypeUnsupportedFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -17838,8 +18130,8 @@ func awsAwsquery_deserializeErrorSnapshotCopyGrantAlreadyExistsFault(response *s return output } -func awsAwsquery_deserializeErrorSnapshotCopyGrantNotFoundFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.SnapshotCopyGrantNotFoundFault{} +func awsAwsquery_deserializeErrorScheduleDefinitionTypeUnsupportedFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.ScheduleDefinitionTypeUnsupportedFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -17869,7 +18161,7 @@ func awsAwsquery_deserializeErrorSnapshotCopyGrantNotFoundFault(response *smithy } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentSnapshotCopyGrantNotFoundFault(&output, decoder) + err = awsAwsquery_deserializeDocumentScheduleDefinitionTypeUnsupportedFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -17882,8 +18174,8 @@ func awsAwsquery_deserializeErrorSnapshotCopyGrantNotFoundFault(response *smithy return output } -func awsAwsquery_deserializeErrorSnapshotCopyGrantQuotaExceededFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.SnapshotCopyGrantQuotaExceededFault{} +func awsAwsquery_deserializeErrorSnapshotCopyAlreadyDisabledFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.SnapshotCopyAlreadyDisabledFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -17913,7 +18205,7 @@ func awsAwsquery_deserializeErrorSnapshotCopyGrantQuotaExceededFault(response *s } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentSnapshotCopyGrantQuotaExceededFault(&output, decoder) + err = awsAwsquery_deserializeDocumentSnapshotCopyAlreadyDisabledFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -17926,8 +18218,8 @@ func awsAwsquery_deserializeErrorSnapshotCopyGrantQuotaExceededFault(response *s return output } -func awsAwsquery_deserializeErrorSnapshotScheduleAlreadyExistsFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.SnapshotScheduleAlreadyExistsFault{} +func awsAwsquery_deserializeErrorSnapshotCopyAlreadyEnabledFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.SnapshotCopyAlreadyEnabledFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -17957,7 +18249,7 @@ func awsAwsquery_deserializeErrorSnapshotScheduleAlreadyExistsFault(response *sm } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentSnapshotScheduleAlreadyExistsFault(&output, decoder) + err = awsAwsquery_deserializeDocumentSnapshotCopyAlreadyEnabledFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -17970,8 +18262,8 @@ func awsAwsquery_deserializeErrorSnapshotScheduleAlreadyExistsFault(response *sm return output } -func awsAwsquery_deserializeErrorSnapshotScheduleNotFoundFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.SnapshotScheduleNotFoundFault{} +func awsAwsquery_deserializeErrorSnapshotCopyDisabledFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.SnapshotCopyDisabledFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -18001,7 +18293,7 @@ func awsAwsquery_deserializeErrorSnapshotScheduleNotFoundFault(response *smithyh } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentSnapshotScheduleNotFoundFault(&output, decoder) + err = awsAwsquery_deserializeDocumentSnapshotCopyDisabledFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -18014,8 +18306,8 @@ func awsAwsquery_deserializeErrorSnapshotScheduleNotFoundFault(response *smithyh return output } -func awsAwsquery_deserializeErrorSnapshotScheduleQuotaExceededFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.SnapshotScheduleQuotaExceededFault{} +func awsAwsquery_deserializeErrorSnapshotCopyGrantAlreadyExistsFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.SnapshotCopyGrantAlreadyExistsFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -18045,7 +18337,7 @@ func awsAwsquery_deserializeErrorSnapshotScheduleQuotaExceededFault(response *sm } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentSnapshotScheduleQuotaExceededFault(&output, decoder) + err = awsAwsquery_deserializeDocumentSnapshotCopyGrantAlreadyExistsFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -18058,8 +18350,8 @@ func awsAwsquery_deserializeErrorSnapshotScheduleQuotaExceededFault(response *sm return output } -func awsAwsquery_deserializeErrorSnapshotScheduleUpdateInProgressFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.SnapshotScheduleUpdateInProgressFault{} +func awsAwsquery_deserializeErrorSnapshotCopyGrantNotFoundFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.SnapshotCopyGrantNotFoundFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -18089,7 +18381,7 @@ func awsAwsquery_deserializeErrorSnapshotScheduleUpdateInProgressFault(response } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentSnapshotScheduleUpdateInProgressFault(&output, decoder) + err = awsAwsquery_deserializeDocumentSnapshotCopyGrantNotFoundFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -18102,8 +18394,8 @@ func awsAwsquery_deserializeErrorSnapshotScheduleUpdateInProgressFault(response return output } -func awsAwsquery_deserializeErrorSNSInvalidTopicFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.SNSInvalidTopicFault{} +func awsAwsquery_deserializeErrorSnapshotCopyGrantQuotaExceededFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.SnapshotCopyGrantQuotaExceededFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -18133,7 +18425,7 @@ func awsAwsquery_deserializeErrorSNSInvalidTopicFault(response *smithyhttp.Respo } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentSNSInvalidTopicFault(&output, decoder) + err = awsAwsquery_deserializeDocumentSnapshotCopyGrantQuotaExceededFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -18146,8 +18438,8 @@ func awsAwsquery_deserializeErrorSNSInvalidTopicFault(response *smithyhttp.Respo return output } -func awsAwsquery_deserializeErrorSNSNoAuthorizationFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.SNSNoAuthorizationFault{} +func awsAwsquery_deserializeErrorSnapshotScheduleAlreadyExistsFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.SnapshotScheduleAlreadyExistsFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -18177,7 +18469,7 @@ func awsAwsquery_deserializeErrorSNSNoAuthorizationFault(response *smithyhttp.Re } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentSNSNoAuthorizationFault(&output, decoder) + err = awsAwsquery_deserializeDocumentSnapshotScheduleAlreadyExistsFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -18190,8 +18482,8 @@ func awsAwsquery_deserializeErrorSNSNoAuthorizationFault(response *smithyhttp.Re return output } -func awsAwsquery_deserializeErrorSNSTopicArnNotFoundFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.SNSTopicArnNotFoundFault{} +func awsAwsquery_deserializeErrorSnapshotScheduleNotFoundFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.SnapshotScheduleNotFoundFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -18221,7 +18513,7 @@ func awsAwsquery_deserializeErrorSNSTopicArnNotFoundFault(response *smithyhttp.R } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentSNSTopicArnNotFoundFault(&output, decoder) + err = awsAwsquery_deserializeDocumentSnapshotScheduleNotFoundFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -18234,8 +18526,8 @@ func awsAwsquery_deserializeErrorSNSTopicArnNotFoundFault(response *smithyhttp.R return output } -func awsAwsquery_deserializeErrorSourceNotFoundFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.SourceNotFoundFault{} +func awsAwsquery_deserializeErrorSnapshotScheduleQuotaExceededFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.SnapshotScheduleQuotaExceededFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -18265,7 +18557,7 @@ func awsAwsquery_deserializeErrorSourceNotFoundFault(response *smithyhttp.Respon } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentSourceNotFoundFault(&output, decoder) + err = awsAwsquery_deserializeDocumentSnapshotScheduleQuotaExceededFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -18278,8 +18570,8 @@ func awsAwsquery_deserializeErrorSourceNotFoundFault(response *smithyhttp.Respon return output } -func awsAwsquery_deserializeErrorSubnetAlreadyInUse(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.SubnetAlreadyInUse{} +func awsAwsquery_deserializeErrorSnapshotScheduleUpdateInProgressFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.SnapshotScheduleUpdateInProgressFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -18309,7 +18601,7 @@ func awsAwsquery_deserializeErrorSubnetAlreadyInUse(response *smithyhttp.Respons } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentSubnetAlreadyInUse(&output, decoder) + err = awsAwsquery_deserializeDocumentSnapshotScheduleUpdateInProgressFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -18322,8 +18614,228 @@ func awsAwsquery_deserializeErrorSubnetAlreadyInUse(response *smithyhttp.Respons return output } -func awsAwsquery_deserializeErrorSubscriptionAlreadyExistFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.SubscriptionAlreadyExistFault{} +func awsAwsquery_deserializeErrorSNSInvalidTopicFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.SNSInvalidTopicFault{} + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + body := io.TeeReader(errorBody, ringBuffer) + rootDecoder := xml.NewDecoder(body) + t, err := smithyxml.FetchRootElement(rootDecoder) + if err == io.EOF { + return output + } + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + return &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + } + + decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) + t, err = decoder.GetElement("Error") + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + return &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + } + + decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) + err = awsAwsquery_deserializeDocumentSNSInvalidTopicFault(&output, decoder) + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + return &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + } + + return output +} + +func awsAwsquery_deserializeErrorSNSNoAuthorizationFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.SNSNoAuthorizationFault{} + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + body := io.TeeReader(errorBody, ringBuffer) + rootDecoder := xml.NewDecoder(body) + t, err := smithyxml.FetchRootElement(rootDecoder) + if err == io.EOF { + return output + } + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + return &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + } + + decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) + t, err = decoder.GetElement("Error") + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + return &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + } + + decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) + err = awsAwsquery_deserializeDocumentSNSNoAuthorizationFault(&output, decoder) + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + return &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + } + + return output +} + +func awsAwsquery_deserializeErrorSNSTopicArnNotFoundFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.SNSTopicArnNotFoundFault{} + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + body := io.TeeReader(errorBody, ringBuffer) + rootDecoder := xml.NewDecoder(body) + t, err := smithyxml.FetchRootElement(rootDecoder) + if err == io.EOF { + return output + } + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + return &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + } + + decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) + t, err = decoder.GetElement("Error") + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + return &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + } + + decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) + err = awsAwsquery_deserializeDocumentSNSTopicArnNotFoundFault(&output, decoder) + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + return &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + } + + return output +} + +func awsAwsquery_deserializeErrorSourceNotFoundFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.SourceNotFoundFault{} + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + body := io.TeeReader(errorBody, ringBuffer) + rootDecoder := xml.NewDecoder(body) + t, err := smithyxml.FetchRootElement(rootDecoder) + if err == io.EOF { + return output + } + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + return &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + } + + decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) + t, err = decoder.GetElement("Error") + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + return &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + } + + decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) + err = awsAwsquery_deserializeDocumentSourceNotFoundFault(&output, decoder) + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + return &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + } + + return output +} + +func awsAwsquery_deserializeErrorSubnetAlreadyInUse(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.SubnetAlreadyInUse{} + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + body := io.TeeReader(errorBody, ringBuffer) + rootDecoder := xml.NewDecoder(body) + t, err := smithyxml.FetchRootElement(rootDecoder) + if err == io.EOF { + return output + } + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + return &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + } + + decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) + t, err = decoder.GetElement("Error") + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + return &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + } + + decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) + err = awsAwsquery_deserializeDocumentSubnetAlreadyInUse(&output, decoder) + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + return &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + } + + return output +} + +func awsAwsquery_deserializeErrorSubscriptionAlreadyExistFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.SubscriptionAlreadyExistFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -19395,6 +19907,146 @@ func awsAwsquery_deserializeDocumentAssociatedClusterListUnwrapped(v *[]types.Cl *v = sv return nil } +func awsAwsquery_deserializeDocumentAssociation(v **types.Association, decoder smithyxml.NodeDecoder) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + var sv *types.Association + if *v == nil { + sv = &types.Association{} + } else { + sv = *v + } + + for { + t, done, err := decoder.Token() + if err != nil { + return err + } + if done { + break + } + originalDecoder := decoder + decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) + switch { + case strings.EqualFold("CertificateAssociations", t.Name.Local): + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + if err := awsAwsquery_deserializeDocumentCertificateAssociationList(&sv.CertificateAssociations, nodeDecoder); err != nil { + return err + } + + case strings.EqualFold("CustomDomainCertificateArn", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.CustomDomainCertificateArn = ptr.String(xtv) + } + + case strings.EqualFold("CustomDomainCertificateExpiryDate", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + t, err := smithytime.ParseDateTime(xtv) + if err != nil { + return err + } + sv.CustomDomainCertificateExpiryDate = ptr.Time(t) + } + + default: + // Do nothing and ignore the unexpected tag element + err = decoder.Decoder.Skip() + if err != nil { + return err + } + + } + decoder = originalDecoder + } + *v = sv + return nil +} + +func awsAwsquery_deserializeDocumentAssociationList(v *[]types.Association, decoder smithyxml.NodeDecoder) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + var sv []types.Association + if *v == nil { + sv = make([]types.Association, 0) + } else { + sv = *v + } + + originalDecoder := decoder + for { + t, done, err := decoder.Token() + if err != nil { + return err + } + if done { + break + } + switch { + case strings.EqualFold("Association", t.Name.Local): + var col types.Association + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + destAddr := &col + if err := awsAwsquery_deserializeDocumentAssociation(&destAddr, nodeDecoder); err != nil { + return err + } + col = *destAddr + sv = append(sv, col) + + default: + err = decoder.Decoder.Skip() + if err != nil { + return err + } + + } + decoder = originalDecoder + } + *v = sv + return nil +} + +func awsAwsquery_deserializeDocumentAssociationListUnwrapped(v *[]types.Association, decoder smithyxml.NodeDecoder) error { + var sv []types.Association + if *v == nil { + sv = make([]types.Association, 0) + } else { + sv = *v + } + + switch { + default: + var mv types.Association + t := decoder.StartEl + _ = t + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + destAddr := &mv + if err := awsAwsquery_deserializeDocumentAssociation(&destAddr, nodeDecoder); err != nil { + return err + } + mv = *destAddr + sv = append(sv, mv) + } + *v = sv + return nil +} func awsAwsquery_deserializeDocumentAttributeList(v *[]types.AccountAttribute, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) @@ -20410,6 +21062,136 @@ func awsAwsquery_deserializeDocumentBucketNotFoundFault(v **types.BucketNotFound return nil } +func awsAwsquery_deserializeDocumentCertificateAssociation(v **types.CertificateAssociation, decoder smithyxml.NodeDecoder) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + var sv *types.CertificateAssociation + if *v == nil { + sv = &types.CertificateAssociation{} + } else { + sv = *v + } + + for { + t, done, err := decoder.Token() + if err != nil { + return err + } + if done { + break + } + originalDecoder := decoder + decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) + switch { + case strings.EqualFold("ClusterIdentifier", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.ClusterIdentifier = ptr.String(xtv) + } + + case strings.EqualFold("CustomDomainName", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.CustomDomainName = ptr.String(xtv) + } + + default: + // Do nothing and ignore the unexpected tag element + err = decoder.Decoder.Skip() + if err != nil { + return err + } + + } + decoder = originalDecoder + } + *v = sv + return nil +} + +func awsAwsquery_deserializeDocumentCertificateAssociationList(v *[]types.CertificateAssociation, decoder smithyxml.NodeDecoder) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + var sv []types.CertificateAssociation + if *v == nil { + sv = make([]types.CertificateAssociation, 0) + } else { + sv = *v + } + + originalDecoder := decoder + for { + t, done, err := decoder.Token() + if err != nil { + return err + } + if done { + break + } + switch { + case strings.EqualFold("CertificateAssociation", t.Name.Local): + var col types.CertificateAssociation + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + destAddr := &col + if err := awsAwsquery_deserializeDocumentCertificateAssociation(&destAddr, nodeDecoder); err != nil { + return err + } + col = *destAddr + sv = append(sv, col) + + default: + err = decoder.Decoder.Skip() + if err != nil { + return err + } + + } + decoder = originalDecoder + } + *v = sv + return nil +} + +func awsAwsquery_deserializeDocumentCertificateAssociationListUnwrapped(v *[]types.CertificateAssociation, decoder smithyxml.NodeDecoder) error { + var sv []types.CertificateAssociation + if *v == nil { + sv = make([]types.CertificateAssociation, 0) + } else { + sv = *v + } + + switch { + default: + var mv types.CertificateAssociation + t := decoder.StartEl + _ = t + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + destAddr := &mv + if err := awsAwsquery_deserializeDocumentCertificateAssociation(&destAddr, nodeDecoder); err != nil { + return err + } + mv = *destAddr + sv = append(sv, mv) + } + *v = sv + return nil +} func awsAwsquery_deserializeDocumentCluster(v **types.Cluster, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) @@ -20642,6 +21424,49 @@ func awsAwsquery_deserializeDocumentCluster(v **types.Cluster, decoder smithyxml sv.ClusterVersion = ptr.String(xtv) } + case strings.EqualFold("CustomDomainCertificateArn", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.CustomDomainCertificateArn = ptr.String(xtv) + } + + case strings.EqualFold("CustomDomainCertificateExpiryDate", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + t, err := smithytime.ParseDateTime(xtv) + if err != nil { + return err + } + sv.CustomDomainCertificateExpiryDate = ptr.Time(t) + } + + case strings.EqualFold("CustomDomainName", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.CustomDomainName = ptr.String(xtv) + } + case strings.EqualFold("DataTransferProgress", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsAwsquery_deserializeDocumentDataTransferProgress(&sv.DataTransferProgress, nodeDecoder); err != nil { @@ -23519,6 +24344,104 @@ func awsAwsquery_deserializeDocumentCopyToRegionDisabledFault(v **types.CopyToRe return nil } +func awsAwsquery_deserializeDocumentCustomCnameAssociationFault(v **types.CustomCnameAssociationFault, decoder smithyxml.NodeDecoder) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + var sv *types.CustomCnameAssociationFault + if *v == nil { + sv = &types.CustomCnameAssociationFault{} + } else { + sv = *v + } + + for { + t, done, err := decoder.Token() + if err != nil { + return err + } + if done { + break + } + originalDecoder := decoder + decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) + switch { + case strings.EqualFold("message", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.Message = ptr.String(xtv) + } + + default: + // Do nothing and ignore the unexpected tag element + err = decoder.Decoder.Skip() + if err != nil { + return err + } + + } + decoder = originalDecoder + } + *v = sv + return nil +} + +func awsAwsquery_deserializeDocumentCustomDomainAssociationNotFoundFault(v **types.CustomDomainAssociationNotFoundFault, decoder smithyxml.NodeDecoder) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + var sv *types.CustomDomainAssociationNotFoundFault + if *v == nil { + sv = &types.CustomDomainAssociationNotFoundFault{} + } else { + sv = *v + } + + for { + t, done, err := decoder.Token() + if err != nil { + return err + } + if done { + break + } + originalDecoder := decoder + decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) + switch { + case strings.EqualFold("message", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.Message = ptr.String(xtv) + } + + default: + // Do nothing and ignore the unexpected tag element + err = decoder.Decoder.Skip() + if err != nil { + return err + } + + } + decoder = originalDecoder + } + *v = sv + return nil +} + func awsAwsquery_deserializeDocumentDataShare(v **types.DataShare, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) @@ -38826,6 +39749,94 @@ func awsAwsquery_deserializeOpDocumentCreateClusterSubnetGroupOutput(v **CreateC return nil } +func awsAwsquery_deserializeOpDocumentCreateCustomDomainAssociationOutput(v **CreateCustomDomainAssociationOutput, decoder smithyxml.NodeDecoder) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + var sv *CreateCustomDomainAssociationOutput + if *v == nil { + sv = &CreateCustomDomainAssociationOutput{} + } else { + sv = *v + } + + for { + t, done, err := decoder.Token() + if err != nil { + return err + } + if done { + break + } + originalDecoder := decoder + decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) + switch { + case strings.EqualFold("ClusterIdentifier", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.ClusterIdentifier = ptr.String(xtv) + } + + case strings.EqualFold("CustomDomainCertExpiryTime", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.CustomDomainCertExpiryTime = ptr.String(xtv) + } + + case strings.EqualFold("CustomDomainCertificateArn", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.CustomDomainCertificateArn = ptr.String(xtv) + } + + case strings.EqualFold("CustomDomainName", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.CustomDomainName = ptr.String(xtv) + } + + default: + // Do nothing and ignore the unexpected tag element + err = decoder.Decoder.Skip() + if err != nil { + return err + } + + } + decoder = originalDecoder + } + *v = sv + return nil +} + func awsAwsquery_deserializeOpDocumentCreateEndpointAccessOutput(v **CreateEndpointAccessOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) @@ -40572,6 +41583,61 @@ func awsAwsquery_deserializeOpDocumentDescribeClusterVersionsOutput(v **Describe return nil } +func awsAwsquery_deserializeOpDocumentDescribeCustomDomainAssociationsOutput(v **DescribeCustomDomainAssociationsOutput, decoder smithyxml.NodeDecoder) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + var sv *DescribeCustomDomainAssociationsOutput + if *v == nil { + sv = &DescribeCustomDomainAssociationsOutput{} + } else { + sv = *v + } + + for { + t, done, err := decoder.Token() + if err != nil { + return err + } + if done { + break + } + originalDecoder := decoder + decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) + switch { + case strings.EqualFold("Associations", t.Name.Local): + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + if err := awsAwsquery_deserializeDocumentAssociationList(&sv.Associations, nodeDecoder); err != nil { + return err + } + + case strings.EqualFold("Marker", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.Marker = ptr.String(xtv) + } + + default: + // Do nothing and ignore the unexpected tag element + err = decoder.Decoder.Skip() + if err != nil { + return err + } + + } + decoder = originalDecoder + } + *v = sv + return nil +} + func awsAwsquery_deserializeOpDocumentDescribeDataSharesForConsumerOutput(v **DescribeDataSharesForConsumerOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) @@ -43435,6 +44501,94 @@ func awsAwsquery_deserializeOpDocumentModifyClusterSubnetGroupOutput(v **ModifyC return nil } +func awsAwsquery_deserializeOpDocumentModifyCustomDomainAssociationOutput(v **ModifyCustomDomainAssociationOutput, decoder smithyxml.NodeDecoder) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + var sv *ModifyCustomDomainAssociationOutput + if *v == nil { + sv = &ModifyCustomDomainAssociationOutput{} + } else { + sv = *v + } + + for { + t, done, err := decoder.Token() + if err != nil { + return err + } + if done { + break + } + originalDecoder := decoder + decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) + switch { + case strings.EqualFold("ClusterIdentifier", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.ClusterIdentifier = ptr.String(xtv) + } + + case strings.EqualFold("CustomDomainCertExpiryTime", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.CustomDomainCertExpiryTime = ptr.String(xtv) + } + + case strings.EqualFold("CustomDomainCertificateArn", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.CustomDomainCertificateArn = ptr.String(xtv) + } + + case strings.EqualFold("CustomDomainName", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.CustomDomainName = ptr.String(xtv) + } + + default: + // Do nothing and ignore the unexpected tag element + err = decoder.Decoder.Skip() + if err != nil { + return err + } + + } + decoder = originalDecoder + } + *v = sv + return nil +} + func awsAwsquery_deserializeOpDocumentModifyEndpointAccessOutput(v **ModifyEndpointAccessOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) diff --git a/service/redshift/generated.json b/service/redshift/generated.json index c1196b40aab..f604c73cf03 100644 --- a/service/redshift/generated.json +++ b/service/redshift/generated.json @@ -26,6 +26,7 @@ "api_op_CreateClusterSecurityGroup.go", "api_op_CreateClusterSnapshot.go", "api_op_CreateClusterSubnetGroup.go", + "api_op_CreateCustomDomainAssociation.go", "api_op_CreateEndpointAccess.go", "api_op_CreateEventSubscription.go", "api_op_CreateHsmClientCertificate.go", @@ -42,6 +43,7 @@ "api_op_DeleteClusterSecurityGroup.go", "api_op_DeleteClusterSnapshot.go", "api_op_DeleteClusterSubnetGroup.go", + "api_op_DeleteCustomDomainAssociation.go", "api_op_DeleteEndpointAccess.go", "api_op_DeleteEventSubscription.go", "api_op_DeleteHsmClientCertificate.go", @@ -63,6 +65,7 @@ "api_op_DescribeClusterTracks.go", "api_op_DescribeClusterVersions.go", "api_op_DescribeClusters.go", + "api_op_DescribeCustomDomainAssociations.go", "api_op_DescribeDataShares.go", "api_op_DescribeDataSharesForConsumer.go", "api_op_DescribeDataSharesForProducer.go", @@ -108,6 +111,7 @@ "api_op_ModifyClusterSnapshot.go", "api_op_ModifyClusterSnapshotSchedule.go", "api_op_ModifyClusterSubnetGroup.go", + "api_op_ModifyCustomDomainAssociation.go", "api_op_ModifyEndpointAccess.go", "api_op_ModifyEventSubscription.go", "api_op_ModifyScheduledAction.go", diff --git a/service/redshift/serializers.go b/service/redshift/serializers.go index 18a728274f5..27a0ffcb259 100644 --- a/service/redshift/serializers.go +++ b/service/redshift/serializers.go @@ -1104,6 +1104,70 @@ func (m *awsAwsquery_serializeOpCreateClusterSubnetGroup) HandleSerialize(ctx co return next.HandleSerialize(ctx, in) } +type awsAwsquery_serializeOpCreateCustomDomainAssociation struct { +} + +func (*awsAwsquery_serializeOpCreateCustomDomainAssociation) ID() string { + return "OperationSerializer" +} + +func (m *awsAwsquery_serializeOpCreateCustomDomainAssociation) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( + out middleware.SerializeOutput, metadata middleware.Metadata, err error, +) { + request, ok := in.Request.(*smithyhttp.Request) + if !ok { + return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} + } + + input, ok := in.Parameters.(*CreateCustomDomainAssociationInput) + _ = input + if !ok { + return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} + } + + operationPath := "/" + if len(request.Request.URL.Path) == 0 { + request.Request.URL.Path = operationPath + } else { + request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath) + if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' { + request.Request.URL.Path += "/" + } + } + request.Request.Method = "POST" + httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) + if err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") + + bodyWriter := bytes.NewBuffer(nil) + bodyEncoder := query.NewEncoder(bodyWriter) + body := bodyEncoder.Object() + body.Key("Action").String("CreateCustomDomainAssociation") + body.Key("Version").String("2012-12-01") + + if err := awsAwsquery_serializeOpDocumentCreateCustomDomainAssociationInput(input, bodyEncoder.Value); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + err = bodyEncoder.Encode() + if err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + in.Request = request + + return next.HandleSerialize(ctx, in) +} + type awsAwsquery_serializeOpCreateEndpointAccess struct { } @@ -2128,6 +2192,70 @@ func (m *awsAwsquery_serializeOpDeleteClusterSubnetGroup) HandleSerialize(ctx co return next.HandleSerialize(ctx, in) } +type awsAwsquery_serializeOpDeleteCustomDomainAssociation struct { +} + +func (*awsAwsquery_serializeOpDeleteCustomDomainAssociation) ID() string { + return "OperationSerializer" +} + +func (m *awsAwsquery_serializeOpDeleteCustomDomainAssociation) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( + out middleware.SerializeOutput, metadata middleware.Metadata, err error, +) { + request, ok := in.Request.(*smithyhttp.Request) + if !ok { + return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} + } + + input, ok := in.Parameters.(*DeleteCustomDomainAssociationInput) + _ = input + if !ok { + return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} + } + + operationPath := "/" + if len(request.Request.URL.Path) == 0 { + request.Request.URL.Path = operationPath + } else { + request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath) + if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' { + request.Request.URL.Path += "/" + } + } + request.Request.Method = "POST" + httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) + if err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") + + bodyWriter := bytes.NewBuffer(nil) + bodyEncoder := query.NewEncoder(bodyWriter) + body := bodyEncoder.Object() + body.Key("Action").String("DeleteCustomDomainAssociation") + body.Key("Version").String("2012-12-01") + + if err := awsAwsquery_serializeOpDocumentDeleteCustomDomainAssociationInput(input, bodyEncoder.Value); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + err = bodyEncoder.Encode() + if err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + in.Request = request + + return next.HandleSerialize(ctx, in) +} + type awsAwsquery_serializeOpDeleteEndpointAccess struct { } @@ -3472,6 +3600,70 @@ func (m *awsAwsquery_serializeOpDescribeClusterVersions) HandleSerialize(ctx con return next.HandleSerialize(ctx, in) } +type awsAwsquery_serializeOpDescribeCustomDomainAssociations struct { +} + +func (*awsAwsquery_serializeOpDescribeCustomDomainAssociations) ID() string { + return "OperationSerializer" +} + +func (m *awsAwsquery_serializeOpDescribeCustomDomainAssociations) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( + out middleware.SerializeOutput, metadata middleware.Metadata, err error, +) { + request, ok := in.Request.(*smithyhttp.Request) + if !ok { + return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} + } + + input, ok := in.Parameters.(*DescribeCustomDomainAssociationsInput) + _ = input + if !ok { + return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} + } + + operationPath := "/" + if len(request.Request.URL.Path) == 0 { + request.Request.URL.Path = operationPath + } else { + request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath) + if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' { + request.Request.URL.Path += "/" + } + } + request.Request.Method = "POST" + httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) + if err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") + + bodyWriter := bytes.NewBuffer(nil) + bodyEncoder := query.NewEncoder(bodyWriter) + body := bodyEncoder.Object() + body.Key("Action").String("DescribeCustomDomainAssociations") + body.Key("Version").String("2012-12-01") + + if err := awsAwsquery_serializeOpDocumentDescribeCustomDomainAssociationsInput(input, bodyEncoder.Value); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + err = bodyEncoder.Encode() + if err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + in.Request = request + + return next.HandleSerialize(ctx, in) +} + type awsAwsquery_serializeOpDescribeDataShares struct { } @@ -6348,6 +6540,70 @@ func (m *awsAwsquery_serializeOpModifyClusterSubnetGroup) HandleSerialize(ctx co return next.HandleSerialize(ctx, in) } +type awsAwsquery_serializeOpModifyCustomDomainAssociation struct { +} + +func (*awsAwsquery_serializeOpModifyCustomDomainAssociation) ID() string { + return "OperationSerializer" +} + +func (m *awsAwsquery_serializeOpModifyCustomDomainAssociation) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( + out middleware.SerializeOutput, metadata middleware.Metadata, err error, +) { + request, ok := in.Request.(*smithyhttp.Request) + if !ok { + return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} + } + + input, ok := in.Parameters.(*ModifyCustomDomainAssociationInput) + _ = input + if !ok { + return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} + } + + operationPath := "/" + if len(request.Request.URL.Path) == 0 { + request.Request.URL.Path = operationPath + } else { + request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath) + if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' { + request.Request.URL.Path += "/" + } + } + request.Request.Method = "POST" + httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) + if err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") + + bodyWriter := bytes.NewBuffer(nil) + bodyEncoder := query.NewEncoder(bodyWriter) + body := bodyEncoder.Object() + body.Key("Action").String("ModifyCustomDomainAssociation") + body.Key("Version").String("2012-12-01") + + if err := awsAwsquery_serializeOpDocumentModifyCustomDomainAssociationInput(input, bodyEncoder.Value); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + err = bodyEncoder.Encode() + if err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + in.Request = request + + return next.HandleSerialize(ctx, in) +} + type awsAwsquery_serializeOpModifyEndpointAccess struct { } @@ -8647,6 +8903,28 @@ func awsAwsquery_serializeOpDocumentCreateClusterSubnetGroupInput(v *CreateClust return nil } +func awsAwsquery_serializeOpDocumentCreateCustomDomainAssociationInput(v *CreateCustomDomainAssociationInput, value query.Value) error { + object := value.Object() + _ = object + + if v.ClusterIdentifier != nil { + objectKey := object.Key("ClusterIdentifier") + objectKey.String(*v.ClusterIdentifier) + } + + if v.CustomDomainCertificateArn != nil { + objectKey := object.Key("CustomDomainCertificateArn") + objectKey.String(*v.CustomDomainCertificateArn) + } + + if v.CustomDomainName != nil { + objectKey := object.Key("CustomDomainName") + objectKey.String(*v.CustomDomainName) + } + + return nil +} + func awsAwsquery_serializeOpDocumentCreateEndpointAccessInput(v *CreateEndpointAccessInput, value query.Value) error { object := value.Object() _ = object @@ -9083,6 +9361,18 @@ func awsAwsquery_serializeOpDocumentDeleteClusterSubnetGroupInput(v *DeleteClust return nil } +func awsAwsquery_serializeOpDocumentDeleteCustomDomainAssociationInput(v *DeleteCustomDomainAssociationInput, value query.Value) error { + object := value.Object() + _ = object + + if v.ClusterIdentifier != nil { + objectKey := object.Key("ClusterIdentifier") + objectKey.String(*v.ClusterIdentifier) + } + + return nil +} + func awsAwsquery_serializeOpDocumentDeleteEndpointAccessInput(v *DeleteEndpointAccessInput, value query.Value) error { object := value.Object() _ = object @@ -9571,6 +9861,33 @@ func awsAwsquery_serializeOpDocumentDescribeClusterVersionsInput(v *DescribeClus return nil } +func awsAwsquery_serializeOpDocumentDescribeCustomDomainAssociationsInput(v *DescribeCustomDomainAssociationsInput, value query.Value) error { + object := value.Object() + _ = object + + if v.CustomDomainCertificateArn != nil { + objectKey := object.Key("CustomDomainCertificateArn") + objectKey.String(*v.CustomDomainCertificateArn) + } + + if v.CustomDomainName != nil { + objectKey := object.Key("CustomDomainName") + objectKey.String(*v.CustomDomainName) + } + + if v.Marker != nil { + objectKey := object.Key("Marker") + objectKey.String(*v.Marker) + } + + if v.MaxRecords != nil { + objectKey := object.Key("MaxRecords") + objectKey.Integer(*v.MaxRecords) + } + + return nil +} + func awsAwsquery_serializeOpDocumentDescribeDataSharesForConsumerInput(v *DescribeDataSharesForConsumerInput, value query.Value) error { object := value.Object() _ = object @@ -10469,6 +10786,11 @@ func awsAwsquery_serializeOpDocumentGetClusterCredentialsInput(v *GetClusterCred objectKey.String(*v.ClusterIdentifier) } + if v.CustomDomainName != nil { + objectKey := object.Key("CustomDomainName") + objectKey.String(*v.CustomDomainName) + } + if v.DbGroups != nil { objectKey := object.Key("DbGroups") if err := awsAwsquery_serializeDocumentDbGroupList(v.DbGroups, objectKey); err != nil { @@ -10503,6 +10825,11 @@ func awsAwsquery_serializeOpDocumentGetClusterCredentialsWithIAMInput(v *GetClus objectKey.String(*v.ClusterIdentifier) } + if v.CustomDomainName != nil { + objectKey := object.Key("CustomDomainName") + objectKey.String(*v.CustomDomainName) + } + if v.DbName != nil { objectKey := object.Key("DbName") objectKey.String(*v.DbName) @@ -10912,6 +11239,28 @@ func awsAwsquery_serializeOpDocumentModifyClusterSubnetGroupInput(v *ModifyClust return nil } +func awsAwsquery_serializeOpDocumentModifyCustomDomainAssociationInput(v *ModifyCustomDomainAssociationInput, value query.Value) error { + object := value.Object() + _ = object + + if v.ClusterIdentifier != nil { + objectKey := object.Key("ClusterIdentifier") + objectKey.String(*v.ClusterIdentifier) + } + + if v.CustomDomainCertificateArn != nil { + objectKey := object.Key("CustomDomainCertificateArn") + objectKey.String(*v.CustomDomainCertificateArn) + } + + if v.CustomDomainName != nil { + objectKey := object.Key("CustomDomainName") + objectKey.String(*v.CustomDomainName) + } + + return nil +} + func awsAwsquery_serializeOpDocumentModifyEndpointAccessInput(v *ModifyEndpointAccessInput, value query.Value) error { object := value.Object() _ = object diff --git a/service/redshift/types/errors.go b/service/redshift/types/errors.go index 72a1cb365eb..19bf142342f 100644 --- a/service/redshift/types/errors.go +++ b/service/redshift/types/errors.go @@ -810,6 +810,61 @@ func (e *CopyToRegionDisabledFault) ErrorCode() string { } func (e *CopyToRegionDisabledFault) ErrorFault() smithy.ErrorFault { return smithy.FaultClient } +// An error occurred when an attempt was made to change the custom domain +// association. +type CustomCnameAssociationFault struct { + Message *string + + ErrorCodeOverride *string + + noSmithyDocumentSerde +} + +func (e *CustomCnameAssociationFault) Error() string { + return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage()) +} +func (e *CustomCnameAssociationFault) ErrorMessage() string { + if e.Message == nil { + return "" + } + return *e.Message +} +func (e *CustomCnameAssociationFault) ErrorCode() string { + if e == nil || e.ErrorCodeOverride == nil { + return "CustomCnameAssociationFault" + } + return *e.ErrorCodeOverride +} +func (e *CustomCnameAssociationFault) ErrorFault() smithy.ErrorFault { return smithy.FaultClient } + +// An error occurred. The custom domain name couldn't be found. +type CustomDomainAssociationNotFoundFault struct { + Message *string + + ErrorCodeOverride *string + + noSmithyDocumentSerde +} + +func (e *CustomDomainAssociationNotFoundFault) Error() string { + return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage()) +} +func (e *CustomDomainAssociationNotFoundFault) ErrorMessage() string { + if e.Message == nil { + return "" + } + return *e.Message +} +func (e *CustomDomainAssociationNotFoundFault) ErrorCode() string { + if e == nil || e.ErrorCodeOverride == nil { + return "CustomDomainAssociationNotFoundFault" + } + return *e.ErrorCodeOverride +} +func (e *CustomDomainAssociationNotFoundFault) ErrorFault() smithy.ErrorFault { + return smithy.FaultClient +} + // The request cannot be completed because a dependent service is throttling // requests made by Amazon Redshift on your behalf. Wait and retry the request. type DependentServiceRequestThrottlingFault struct { diff --git a/service/redshift/types/types.go b/service/redshift/types/types.go index a2443a7f718..5f45b64aafd 100644 --- a/service/redshift/types/types.go +++ b/service/redshift/types/types.go @@ -49,6 +49,23 @@ type AquaConfiguration struct { noSmithyDocumentSerde } +// Contains information about the custom domain name association. +type Association struct { + + // A list of all associated clusters and domain names tied to a specific + // certificate. + CertificateAssociations []CertificateAssociation + + // The Amazon Resource Name (ARN) for the certificate associated with the custom + // domain. + CustomDomainCertificateArn *string + + // The expiration date for the certificate. + CustomDomainCertificateExpiryDate *time.Time + + noSmithyDocumentSerde +} + // Describes an attribute value. type AttributeValueTarget struct { @@ -83,6 +100,19 @@ type AvailabilityZone struct { noSmithyDocumentSerde } +// A cluster ID and custom domain name tied to a specific certificate. These are +// typically returned in a list. +type CertificateAssociation struct { + + // The cluster identifier for the certificate association. + ClusterIdentifier *string + + // The custom domain name for the certificate association. + CustomDomainName *string + + noSmithyDocumentSerde +} + // Describes a cluster. type Cluster struct { @@ -178,6 +208,15 @@ type Cluster struct { // The version ID of the Amazon Redshift engine that is running on the cluster. ClusterVersion *string + // The certificate Amazon Resource Name (ARN) for the custom domain name. + CustomDomainCertificateArn *string + + // The expiration date for the certificate associated with the custom domain name. + CustomDomainCertificateExpiryDate *time.Time + + // The custom domain name associated with the cluster. + CustomDomainName *string + // The name of the initial database that was created when the cluster was created. // This same name is returned for the life of the cluster. If an initial database // was not specified, a database named dev dev was created by default. @@ -661,9 +700,9 @@ type DeleteClusterSnapshotMessage struct { SnapshotIdentifier *string // The unique identifier of the cluster the snapshot was created from. This - // parameter is required if your IAM user or role has a policy containing a - // snapshot resource element that specifies anything other than * for the cluster - // name. Constraints: Must be the name of valid cluster. + // parameter is required if your IAM user has a policy containing a snapshot + // resource element that specifies anything other than * for the cluster name. + // Constraints: Must be the name of valid cluster. SnapshotClusterIdentifier *string noSmithyDocumentSerde diff --git a/service/redshift/validators.go b/service/redshift/validators.go index 2aa20bd5175..ea71474a48c 100644 --- a/service/redshift/validators.go +++ b/service/redshift/validators.go @@ -350,6 +350,26 @@ func (m *validateOpCreateClusterSubnetGroup) HandleInitialize(ctx context.Contex return next.HandleInitialize(ctx, in) } +type validateOpCreateCustomDomainAssociation struct { +} + +func (*validateOpCreateCustomDomainAssociation) ID() string { + return "OperationInputValidation" +} + +func (m *validateOpCreateCustomDomainAssociation) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + input, ok := in.Parameters.(*CreateCustomDomainAssociationInput) + if !ok { + return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) + } + if err := validateOpCreateCustomDomainAssociationInput(input); err != nil { + return out, metadata, err + } + return next.HandleInitialize(ctx, in) +} + type validateOpCreateEndpointAccess struct { } @@ -650,6 +670,26 @@ func (m *validateOpDeleteClusterSubnetGroup) HandleInitialize(ctx context.Contex return next.HandleInitialize(ctx, in) } +type validateOpDeleteCustomDomainAssociation struct { +} + +func (*validateOpDeleteCustomDomainAssociation) ID() string { + return "OperationInputValidation" +} + +func (m *validateOpDeleteCustomDomainAssociation) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + input, ok := in.Parameters.(*DeleteCustomDomainAssociationInput) + if !ok { + return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) + } + if err := validateOpDeleteCustomDomainAssociationInput(input); err != nil { + return out, metadata, err + } + return next.HandleInitialize(ctx, in) +} + type validateOpDeleteEndpointAccess struct { } @@ -1130,26 +1170,6 @@ func (m *validateOpGetClusterCredentials) HandleInitialize(ctx context.Context, return next.HandleInitialize(ctx, in) } -type validateOpGetClusterCredentialsWithIAM struct { -} - -func (*validateOpGetClusterCredentialsWithIAM) ID() string { - return "OperationInputValidation" -} - -func (m *validateOpGetClusterCredentialsWithIAM) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( - out middleware.InitializeOutput, metadata middleware.Metadata, err error, -) { - input, ok := in.Parameters.(*GetClusterCredentialsWithIAMInput) - if !ok { - return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) - } - if err := validateOpGetClusterCredentialsWithIAMInput(input); err != nil { - return out, metadata, err - } - return next.HandleInitialize(ctx, in) -} - type validateOpGetReservedNodeExchangeConfigurationOptions struct { } @@ -1390,6 +1410,26 @@ func (m *validateOpModifyClusterSubnetGroup) HandleInitialize(ctx context.Contex return next.HandleInitialize(ctx, in) } +type validateOpModifyCustomDomainAssociation struct { +} + +func (*validateOpModifyCustomDomainAssociation) ID() string { + return "OperationInputValidation" +} + +func (m *validateOpModifyCustomDomainAssociation) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + input, ok := in.Parameters.(*ModifyCustomDomainAssociationInput) + if !ok { + return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) + } + if err := validateOpModifyCustomDomainAssociationInput(input); err != nil { + return out, metadata, err + } + return next.HandleInitialize(ctx, in) +} + type validateOpModifyEndpointAccess struct { } @@ -1838,6 +1878,10 @@ func addOpCreateClusterSubnetGroupValidationMiddleware(stack *middleware.Stack) return stack.Initialize.Add(&validateOpCreateClusterSubnetGroup{}, middleware.After) } +func addOpCreateCustomDomainAssociationValidationMiddleware(stack *middleware.Stack) error { + return stack.Initialize.Add(&validateOpCreateCustomDomainAssociation{}, middleware.After) +} + func addOpCreateEndpointAccessValidationMiddleware(stack *middleware.Stack) error { return stack.Initialize.Add(&validateOpCreateEndpointAccess{}, middleware.After) } @@ -1898,6 +1942,10 @@ func addOpDeleteClusterSubnetGroupValidationMiddleware(stack *middleware.Stack) return stack.Initialize.Add(&validateOpDeleteClusterSubnetGroup{}, middleware.After) } +func addOpDeleteCustomDomainAssociationValidationMiddleware(stack *middleware.Stack) error { + return stack.Initialize.Add(&validateOpDeleteCustomDomainAssociation{}, middleware.After) +} + func addOpDeleteEndpointAccessValidationMiddleware(stack *middleware.Stack) error { return stack.Initialize.Add(&validateOpDeleteEndpointAccess{}, middleware.After) } @@ -1994,10 +2042,6 @@ func addOpGetClusterCredentialsValidationMiddleware(stack *middleware.Stack) err return stack.Initialize.Add(&validateOpGetClusterCredentials{}, middleware.After) } -func addOpGetClusterCredentialsWithIAMValidationMiddleware(stack *middleware.Stack) error { - return stack.Initialize.Add(&validateOpGetClusterCredentialsWithIAM{}, middleware.After) -} - func addOpGetReservedNodeExchangeConfigurationOptionsValidationMiddleware(stack *middleware.Stack) error { return stack.Initialize.Add(&validateOpGetReservedNodeExchangeConfigurationOptions{}, middleware.After) } @@ -2046,6 +2090,10 @@ func addOpModifyClusterSubnetGroupValidationMiddleware(stack *middleware.Stack) return stack.Initialize.Add(&validateOpModifyClusterSubnetGroup{}, middleware.After) } +func addOpModifyCustomDomainAssociationValidationMiddleware(stack *middleware.Stack) error { + return stack.Initialize.Add(&validateOpModifyCustomDomainAssociation{}, middleware.After) +} + func addOpModifyEndpointAccessValidationMiddleware(stack *middleware.Stack) error { return stack.Initialize.Add(&validateOpModifyEndpointAccess{}, middleware.After) } @@ -2600,6 +2648,27 @@ func validateOpCreateClusterSubnetGroupInput(v *CreateClusterSubnetGroupInput) e } } +func validateOpCreateCustomDomainAssociationInput(v *CreateCustomDomainAssociationInput) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "CreateCustomDomainAssociationInput"} + if v.CustomDomainName == nil { + invalidParams.Add(smithy.NewErrParamRequired("CustomDomainName")) + } + if v.CustomDomainCertificateArn == nil { + invalidParams.Add(smithy.NewErrParamRequired("CustomDomainCertificateArn")) + } + if v.ClusterIdentifier == nil { + invalidParams.Add(smithy.NewErrParamRequired("ClusterIdentifier")) + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + func validateOpCreateEndpointAccessInput(v *CreateEndpointAccessInput) error { if v == nil { return nil @@ -2871,6 +2940,21 @@ func validateOpDeleteClusterSubnetGroupInput(v *DeleteClusterSubnetGroupInput) e } } +func validateOpDeleteCustomDomainAssociationInput(v *DeleteCustomDomainAssociationInput) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "DeleteCustomDomainAssociationInput"} + if v.ClusterIdentifier == nil { + invalidParams.Add(smithy.NewErrParamRequired("ClusterIdentifier")) + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + func validateOpDeleteEndpointAccessInput(v *DeleteEndpointAccessInput) error { if v == nil { return nil @@ -3246,24 +3330,6 @@ func validateOpGetClusterCredentialsInput(v *GetClusterCredentialsInput) error { if v.DbUser == nil { invalidParams.Add(smithy.NewErrParamRequired("DbUser")) } - if v.ClusterIdentifier == nil { - invalidParams.Add(smithy.NewErrParamRequired("ClusterIdentifier")) - } - if invalidParams.Len() > 0 { - return invalidParams - } else { - return nil - } -} - -func validateOpGetClusterCredentialsWithIAMInput(v *GetClusterCredentialsWithIAMInput) error { - if v == nil { - return nil - } - invalidParams := smithy.InvalidParamsError{Context: "GetClusterCredentialsWithIAMInput"} - if v.ClusterIdentifier == nil { - invalidParams.Add(smithy.NewErrParamRequired("ClusterIdentifier")) - } if invalidParams.Len() > 0 { return invalidParams } else { @@ -3463,6 +3529,21 @@ func validateOpModifyClusterSubnetGroupInput(v *ModifyClusterSubnetGroupInput) e } } +func validateOpModifyCustomDomainAssociationInput(v *ModifyCustomDomainAssociationInput) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "ModifyCustomDomainAssociationInput"} + if v.ClusterIdentifier == nil { + invalidParams.Add(smithy.NewErrParamRequired("ClusterIdentifier")) + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + func validateOpModifyEndpointAccessInput(v *ModifyEndpointAccessInput) error { if v == nil { return nil