// Code generated by smithy-go-codegen DO NOT EDIT. package cloudfront import ( "bytes" "context" "encoding/xml" "fmt" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" awsxml "github.com/aws/aws-sdk-go-v2/aws/protocol/xml" "github.com/aws/aws-sdk-go-v2/service/cloudfront/types" smithy "github.com/aws/smithy-go" smithyxml "github.com/aws/smithy-go/encoding/xml" smithyio "github.com/aws/smithy-go/io" "github.com/aws/smithy-go/middleware" "github.com/aws/smithy-go/ptr" smithytime "github.com/aws/smithy-go/time" smithyhttp "github.com/aws/smithy-go/transport/http" "io" "io/ioutil" "strconv" "strings" ) type awsRestxml_deserializeOpAssociateAlias struct { } func (*awsRestxml_deserializeOpAssociateAlias) ID() string { return "OperationDeserializer" } func (m *awsRestxml_deserializeOpAssociateAlias) 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, awsRestxml_deserializeOpErrorAssociateAlias(response, &metadata) } output := &AssociateAliasOutput{} 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 awsRestxml_deserializeOpErrorAssociateAlias(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("AccessDenied", errorCode): return awsRestxml_deserializeErrorAccessDenied(response, errorBody) case strings.EqualFold("IllegalUpdate", errorCode): return awsRestxml_deserializeErrorIllegalUpdate(response, errorBody) case strings.EqualFold("InvalidArgument", errorCode): return awsRestxml_deserializeErrorInvalidArgument(response, errorBody) case strings.EqualFold("NoSuchDistribution", errorCode): return awsRestxml_deserializeErrorNoSuchDistribution(response, errorBody) case strings.EqualFold("TooManyDistributionCNAMEs", errorCode): return awsRestxml_deserializeErrorTooManyDistributionCNAMEs(response, errorBody) default: genericError := &smithy.GenericAPIError{ Code: errorCode, Message: errorMessage, } return genericError } } type awsRestxml_deserializeOpCopyDistribution struct { } func (*awsRestxml_deserializeOpCopyDistribution) ID() string { return "OperationDeserializer" } func (m *awsRestxml_deserializeOpCopyDistribution) 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, awsRestxml_deserializeOpErrorCopyDistribution(response, &metadata) } output := &CopyDistributionOutput{} out.Result = output err = awsRestxml_deserializeOpHttpBindingsCopyDistributionOutput(output, response) if err != nil { return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} } 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) err = awsRestxml_deserializeDocumentDistribution(&output.Distribution, decoder) 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(), } } return out, metadata, err } func awsRestxml_deserializeOpErrorCopyDistribution(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("AccessDenied", errorCode): return awsRestxml_deserializeErrorAccessDenied(response, errorBody) case strings.EqualFold("CNAMEAlreadyExists", errorCode): return awsRestxml_deserializeErrorCNAMEAlreadyExists(response, errorBody) case strings.EqualFold("DistributionAlreadyExists", errorCode): return awsRestxml_deserializeErrorDistributionAlreadyExists(response, errorBody) case strings.EqualFold("IllegalFieldLevelEncryptionConfigAssociationWithCacheBehavior", errorCode): return awsRestxml_deserializeErrorIllegalFieldLevelEncryptionConfigAssociationWithCacheBehavior(response, errorBody) case strings.EqualFold("InconsistentQuantities", errorCode): return awsRestxml_deserializeErrorInconsistentQuantities(response, errorBody) case strings.EqualFold("InvalidArgument", errorCode): return awsRestxml_deserializeErrorInvalidArgument(response, errorBody) case strings.EqualFold("InvalidDefaultRootObject", errorCode): return awsRestxml_deserializeErrorInvalidDefaultRootObject(response, errorBody) case strings.EqualFold("InvalidErrorCode", errorCode): return awsRestxml_deserializeErrorInvalidErrorCode(response, errorBody) case strings.EqualFold("InvalidForwardCookies", errorCode): return awsRestxml_deserializeErrorInvalidForwardCookies(response, errorBody) case strings.EqualFold("InvalidFunctionAssociation", errorCode): return awsRestxml_deserializeErrorInvalidFunctionAssociation(response, errorBody) case strings.EqualFold("InvalidGeoRestrictionParameter", errorCode): return awsRestxml_deserializeErrorInvalidGeoRestrictionParameter(response, errorBody) case strings.EqualFold("InvalidHeadersForS3Origin", errorCode): return awsRestxml_deserializeErrorInvalidHeadersForS3Origin(response, errorBody) case strings.EqualFold("InvalidIfMatchVersion", errorCode): return awsRestxml_deserializeErrorInvalidIfMatchVersion(response, errorBody) case strings.EqualFold("InvalidLambdaFunctionAssociation", errorCode): return awsRestxml_deserializeErrorInvalidLambdaFunctionAssociation(response, errorBody) case strings.EqualFold("InvalidLocationCode", errorCode): return awsRestxml_deserializeErrorInvalidLocationCode(response, errorBody) case strings.EqualFold("InvalidMinimumProtocolVersion", errorCode): return awsRestxml_deserializeErrorInvalidMinimumProtocolVersion(response, errorBody) case strings.EqualFold("InvalidOrigin", errorCode): return awsRestxml_deserializeErrorInvalidOrigin(response, errorBody) case strings.EqualFold("InvalidOriginAccessControl", errorCode): return awsRestxml_deserializeErrorInvalidOriginAccessControl(response, errorBody) case strings.EqualFold("InvalidOriginAccessIdentity", errorCode): return awsRestxml_deserializeErrorInvalidOriginAccessIdentity(response, errorBody) case strings.EqualFold("InvalidOriginKeepaliveTimeout", errorCode): return awsRestxml_deserializeErrorInvalidOriginKeepaliveTimeout(response, errorBody) case strings.EqualFold("InvalidOriginReadTimeout", errorCode): return awsRestxml_deserializeErrorInvalidOriginReadTimeout(response, errorBody) case strings.EqualFold("InvalidProtocolSettings", errorCode): return awsRestxml_deserializeErrorInvalidProtocolSettings(response, errorBody) case strings.EqualFold("InvalidQueryStringParameters", errorCode): return awsRestxml_deserializeErrorInvalidQueryStringParameters(response, errorBody) case strings.EqualFold("InvalidRelativePath", errorCode): return awsRestxml_deserializeErrorInvalidRelativePath(response, errorBody) case strings.EqualFold("InvalidRequiredProtocol", errorCode): return awsRestxml_deserializeErrorInvalidRequiredProtocol(response, errorBody) case strings.EqualFold("InvalidResponseCode", errorCode): return awsRestxml_deserializeErrorInvalidResponseCode(response, errorBody) case strings.EqualFold("InvalidTTLOrder", errorCode): return awsRestxml_deserializeErrorInvalidTTLOrder(response, errorBody) case strings.EqualFold("InvalidViewerCertificate", errorCode): return awsRestxml_deserializeErrorInvalidViewerCertificate(response, errorBody) case strings.EqualFold("InvalidWebACLId", errorCode): return awsRestxml_deserializeErrorInvalidWebACLId(response, errorBody) case strings.EqualFold("MissingBody", errorCode): return awsRestxml_deserializeErrorMissingBody(response, errorBody) case strings.EqualFold("NoSuchCachePolicy", errorCode): return awsRestxml_deserializeErrorNoSuchCachePolicy(response, errorBody) case strings.EqualFold("NoSuchDistribution", errorCode): return awsRestxml_deserializeErrorNoSuchDistribution(response, errorBody) case strings.EqualFold("NoSuchFieldLevelEncryptionConfig", errorCode): return awsRestxml_deserializeErrorNoSuchFieldLevelEncryptionConfig(response, errorBody) case strings.EqualFold("NoSuchOrigin", errorCode): return awsRestxml_deserializeErrorNoSuchOrigin(response, errorBody) case strings.EqualFold("NoSuchOriginRequestPolicy", errorCode): return awsRestxml_deserializeErrorNoSuchOriginRequestPolicy(response, errorBody) case strings.EqualFold("NoSuchRealtimeLogConfig", errorCode): return awsRestxml_deserializeErrorNoSuchRealtimeLogConfig(response, errorBody) case strings.EqualFold("NoSuchResponseHeadersPolicy", errorCode): return awsRestxml_deserializeErrorNoSuchResponseHeadersPolicy(response, errorBody) case strings.EqualFold("PreconditionFailed", errorCode): return awsRestxml_deserializeErrorPreconditionFailed(response, errorBody) case strings.EqualFold("RealtimeLogConfigOwnerMismatch", errorCode): return awsRestxml_deserializeErrorRealtimeLogConfigOwnerMismatch(response, errorBody) case strings.EqualFold("TooManyCacheBehaviors", errorCode): return awsRestxml_deserializeErrorTooManyCacheBehaviors(response, errorBody) case strings.EqualFold("TooManyCertificates", errorCode): return awsRestxml_deserializeErrorTooManyCertificates(response, errorBody) case strings.EqualFold("TooManyCookieNamesInWhiteList", errorCode): return awsRestxml_deserializeErrorTooManyCookieNamesInWhiteList(response, errorBody) case strings.EqualFold("TooManyDistributionCNAMEs", errorCode): return awsRestxml_deserializeErrorTooManyDistributionCNAMEs(response, errorBody) case strings.EqualFold("TooManyDistributions", errorCode): return awsRestxml_deserializeErrorTooManyDistributions(response, errorBody) case strings.EqualFold("TooManyDistributionsAssociatedToCachePolicy", errorCode): return awsRestxml_deserializeErrorTooManyDistributionsAssociatedToCachePolicy(response, errorBody) case strings.EqualFold("TooManyDistributionsAssociatedToFieldLevelEncryptionConfig", errorCode): return awsRestxml_deserializeErrorTooManyDistributionsAssociatedToFieldLevelEncryptionConfig(response, errorBody) case strings.EqualFold("TooManyDistributionsAssociatedToKeyGroup", errorCode): return awsRestxml_deserializeErrorTooManyDistributionsAssociatedToKeyGroup(response, errorBody) case strings.EqualFold("TooManyDistributionsAssociatedToOriginAccessControl", errorCode): return awsRestxml_deserializeErrorTooManyDistributionsAssociatedToOriginAccessControl(response, errorBody) case strings.EqualFold("TooManyDistributionsAssociatedToOriginRequestPolicy", errorCode): return awsRestxml_deserializeErrorTooManyDistributionsAssociatedToOriginRequestPolicy(response, errorBody) case strings.EqualFold("TooManyDistributionsAssociatedToResponseHeadersPolicy", errorCode): return awsRestxml_deserializeErrorTooManyDistributionsAssociatedToResponseHeadersPolicy(response, errorBody) case strings.EqualFold("TooManyDistributionsWithFunctionAssociations", errorCode): return awsRestxml_deserializeErrorTooManyDistributionsWithFunctionAssociations(response, errorBody) case strings.EqualFold("TooManyDistributionsWithLambdaAssociations", errorCode): return awsRestxml_deserializeErrorTooManyDistributionsWithLambdaAssociations(response, errorBody) case strings.EqualFold("TooManyDistributionsWithSingleFunctionARN", errorCode): return awsRestxml_deserializeErrorTooManyDistributionsWithSingleFunctionARN(response, errorBody) case strings.EqualFold("TooManyFunctionAssociations", errorCode): return awsRestxml_deserializeErrorTooManyFunctionAssociations(response, errorBody) case strings.EqualFold("TooManyHeadersInForwardedValues", errorCode): return awsRestxml_deserializeErrorTooManyHeadersInForwardedValues(response, errorBody) case strings.EqualFold("TooManyKeyGroupsAssociatedToDistribution", errorCode): return awsRestxml_deserializeErrorTooManyKeyGroupsAssociatedToDistribution(response, errorBody) case strings.EqualFold("TooManyLambdaFunctionAssociations", errorCode): return awsRestxml_deserializeErrorTooManyLambdaFunctionAssociations(response, errorBody) case strings.EqualFold("TooManyOriginCustomHeaders", errorCode): return awsRestxml_deserializeErrorTooManyOriginCustomHeaders(response, errorBody) case strings.EqualFold("TooManyOriginGroupsPerDistribution", errorCode): return awsRestxml_deserializeErrorTooManyOriginGroupsPerDistribution(response, errorBody) case strings.EqualFold("TooManyOrigins", errorCode): return awsRestxml_deserializeErrorTooManyOrigins(response, errorBody) case strings.EqualFold("TooManyQueryStringParameters", errorCode): return awsRestxml_deserializeErrorTooManyQueryStringParameters(response, errorBody) case strings.EqualFold("TooManyTrustedSigners", errorCode): return awsRestxml_deserializeErrorTooManyTrustedSigners(response, errorBody) case strings.EqualFold("TrustedKeyGroupDoesNotExist", errorCode): return awsRestxml_deserializeErrorTrustedKeyGroupDoesNotExist(response, errorBody) case strings.EqualFold("TrustedSignerDoesNotExist", errorCode): return awsRestxml_deserializeErrorTrustedSignerDoesNotExist(response, errorBody) default: genericError := &smithy.GenericAPIError{ Code: errorCode, Message: errorMessage, } return genericError } } func awsRestxml_deserializeOpHttpBindingsCopyDistributionOutput(v *CopyDistributionOutput, response *smithyhttp.Response) error { if v == nil { return fmt.Errorf("unsupported deserialization for nil %T", v) } if headerValues := response.Header.Values("ETag"); len(headerValues) != 0 { headerValues[0] = strings.TrimSpace(headerValues[0]) v.ETag = ptr.String(headerValues[0]) } if headerValues := response.Header.Values("Location"); len(headerValues) != 0 { headerValues[0] = strings.TrimSpace(headerValues[0]) v.Location = ptr.String(headerValues[0]) } return nil } func awsRestxml_deserializeOpDocumentCopyDistributionOutput(v **CopyDistributionOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *CopyDistributionOutput if *v == nil { sv = &CopyDistributionOutput{} } 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("Distribution", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentDistribution(&sv.Distribution, nodeDecoder); err != nil { return err } default: // Do nothing and ignore the unexpected tag element err = decoder.Decoder.Skip() if err != nil { return err } } decoder = originalDecoder } *v = sv return nil } type awsRestxml_deserializeOpCreateCachePolicy struct { } func (*awsRestxml_deserializeOpCreateCachePolicy) ID() string { return "OperationDeserializer" } func (m *awsRestxml_deserializeOpCreateCachePolicy) 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, awsRestxml_deserializeOpErrorCreateCachePolicy(response, &metadata) } output := &CreateCachePolicyOutput{} out.Result = output err = awsRestxml_deserializeOpHttpBindingsCreateCachePolicyOutput(output, response) if err != nil { return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} } 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) err = awsRestxml_deserializeDocumentCachePolicy(&output.CachePolicy, decoder) 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(), } } return out, metadata, err } func awsRestxml_deserializeOpErrorCreateCachePolicy(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("AccessDenied", errorCode): return awsRestxml_deserializeErrorAccessDenied(response, errorBody) case strings.EqualFold("CachePolicyAlreadyExists", errorCode): return awsRestxml_deserializeErrorCachePolicyAlreadyExists(response, errorBody) case strings.EqualFold("InconsistentQuantities", errorCode): return awsRestxml_deserializeErrorInconsistentQuantities(response, errorBody) case strings.EqualFold("InvalidArgument", errorCode): return awsRestxml_deserializeErrorInvalidArgument(response, errorBody) case strings.EqualFold("TooManyCachePolicies", errorCode): return awsRestxml_deserializeErrorTooManyCachePolicies(response, errorBody) case strings.EqualFold("TooManyCookiesInCachePolicy", errorCode): return awsRestxml_deserializeErrorTooManyCookiesInCachePolicy(response, errorBody) case strings.EqualFold("TooManyHeadersInCachePolicy", errorCode): return awsRestxml_deserializeErrorTooManyHeadersInCachePolicy(response, errorBody) case strings.EqualFold("TooManyQueryStringsInCachePolicy", errorCode): return awsRestxml_deserializeErrorTooManyQueryStringsInCachePolicy(response, errorBody) default: genericError := &smithy.GenericAPIError{ Code: errorCode, Message: errorMessage, } return genericError } } func awsRestxml_deserializeOpHttpBindingsCreateCachePolicyOutput(v *CreateCachePolicyOutput, response *smithyhttp.Response) error { if v == nil { return fmt.Errorf("unsupported deserialization for nil %T", v) } if headerValues := response.Header.Values("ETag"); len(headerValues) != 0 { headerValues[0] = strings.TrimSpace(headerValues[0]) v.ETag = ptr.String(headerValues[0]) } if headerValues := response.Header.Values("Location"); len(headerValues) != 0 { headerValues[0] = strings.TrimSpace(headerValues[0]) v.Location = ptr.String(headerValues[0]) } return nil } func awsRestxml_deserializeOpDocumentCreateCachePolicyOutput(v **CreateCachePolicyOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *CreateCachePolicyOutput if *v == nil { sv = &CreateCachePolicyOutput{} } 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("CachePolicy", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentCachePolicy(&sv.CachePolicy, nodeDecoder); err != nil { return err } default: // Do nothing and ignore the unexpected tag element err = decoder.Decoder.Skip() if err != nil { return err } } decoder = originalDecoder } *v = sv return nil } type awsRestxml_deserializeOpCreateCloudFrontOriginAccessIdentity struct { } func (*awsRestxml_deserializeOpCreateCloudFrontOriginAccessIdentity) ID() string { return "OperationDeserializer" } func (m *awsRestxml_deserializeOpCreateCloudFrontOriginAccessIdentity) 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, awsRestxml_deserializeOpErrorCreateCloudFrontOriginAccessIdentity(response, &metadata) } output := &CreateCloudFrontOriginAccessIdentityOutput{} out.Result = output err = awsRestxml_deserializeOpHttpBindingsCreateCloudFrontOriginAccessIdentityOutput(output, response) if err != nil { return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} } 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) err = awsRestxml_deserializeDocumentCloudFrontOriginAccessIdentity(&output.CloudFrontOriginAccessIdentity, decoder) 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(), } } return out, metadata, err } func awsRestxml_deserializeOpErrorCreateCloudFrontOriginAccessIdentity(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("CloudFrontOriginAccessIdentityAlreadyExists", errorCode): return awsRestxml_deserializeErrorCloudFrontOriginAccessIdentityAlreadyExists(response, errorBody) case strings.EqualFold("InconsistentQuantities", errorCode): return awsRestxml_deserializeErrorInconsistentQuantities(response, errorBody) case strings.EqualFold("InvalidArgument", errorCode): return awsRestxml_deserializeErrorInvalidArgument(response, errorBody) case strings.EqualFold("MissingBody", errorCode): return awsRestxml_deserializeErrorMissingBody(response, errorBody) case strings.EqualFold("TooManyCloudFrontOriginAccessIdentities", errorCode): return awsRestxml_deserializeErrorTooManyCloudFrontOriginAccessIdentities(response, errorBody) default: genericError := &smithy.GenericAPIError{ Code: errorCode, Message: errorMessage, } return genericError } } func awsRestxml_deserializeOpHttpBindingsCreateCloudFrontOriginAccessIdentityOutput(v *CreateCloudFrontOriginAccessIdentityOutput, response *smithyhttp.Response) error { if v == nil { return fmt.Errorf("unsupported deserialization for nil %T", v) } if headerValues := response.Header.Values("ETag"); len(headerValues) != 0 { headerValues[0] = strings.TrimSpace(headerValues[0]) v.ETag = ptr.String(headerValues[0]) } if headerValues := response.Header.Values("Location"); len(headerValues) != 0 { headerValues[0] = strings.TrimSpace(headerValues[0]) v.Location = ptr.String(headerValues[0]) } return nil } func awsRestxml_deserializeOpDocumentCreateCloudFrontOriginAccessIdentityOutput(v **CreateCloudFrontOriginAccessIdentityOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *CreateCloudFrontOriginAccessIdentityOutput if *v == nil { sv = &CreateCloudFrontOriginAccessIdentityOutput{} } 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("CloudFrontOriginAccessIdentity", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentCloudFrontOriginAccessIdentity(&sv.CloudFrontOriginAccessIdentity, nodeDecoder); err != nil { return err } default: // Do nothing and ignore the unexpected tag element err = decoder.Decoder.Skip() if err != nil { return err } } decoder = originalDecoder } *v = sv return nil } type awsRestxml_deserializeOpCreateContinuousDeploymentPolicy struct { } func (*awsRestxml_deserializeOpCreateContinuousDeploymentPolicy) ID() string { return "OperationDeserializer" } func (m *awsRestxml_deserializeOpCreateContinuousDeploymentPolicy) 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, awsRestxml_deserializeOpErrorCreateContinuousDeploymentPolicy(response, &metadata) } output := &CreateContinuousDeploymentPolicyOutput{} out.Result = output err = awsRestxml_deserializeOpHttpBindingsCreateContinuousDeploymentPolicyOutput(output, response) if err != nil { return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} } 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) err = awsRestxml_deserializeDocumentContinuousDeploymentPolicy(&output.ContinuousDeploymentPolicy, decoder) 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(), } } return out, metadata, err } func awsRestxml_deserializeOpErrorCreateContinuousDeploymentPolicy(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("AccessDenied", errorCode): return awsRestxml_deserializeErrorAccessDenied(response, errorBody) case strings.EqualFold("ContinuousDeploymentPolicyAlreadyExists", errorCode): return awsRestxml_deserializeErrorContinuousDeploymentPolicyAlreadyExists(response, errorBody) case strings.EqualFold("InconsistentQuantities", errorCode): return awsRestxml_deserializeErrorInconsistentQuantities(response, errorBody) case strings.EqualFold("InvalidArgument", errorCode): return awsRestxml_deserializeErrorInvalidArgument(response, errorBody) case strings.EqualFold("StagingDistributionInUse", errorCode): return awsRestxml_deserializeErrorStagingDistributionInUse(response, errorBody) case strings.EqualFold("TooManyContinuousDeploymentPolicies", errorCode): return awsRestxml_deserializeErrorTooManyContinuousDeploymentPolicies(response, errorBody) default: genericError := &smithy.GenericAPIError{ Code: errorCode, Message: errorMessage, } return genericError } } func awsRestxml_deserializeOpHttpBindingsCreateContinuousDeploymentPolicyOutput(v *CreateContinuousDeploymentPolicyOutput, response *smithyhttp.Response) error { if v == nil { return fmt.Errorf("unsupported deserialization for nil %T", v) } if headerValues := response.Header.Values("ETag"); len(headerValues) != 0 { headerValues[0] = strings.TrimSpace(headerValues[0]) v.ETag = ptr.String(headerValues[0]) } if headerValues := response.Header.Values("Location"); len(headerValues) != 0 { headerValues[0] = strings.TrimSpace(headerValues[0]) v.Location = ptr.String(headerValues[0]) } return nil } func awsRestxml_deserializeOpDocumentCreateContinuousDeploymentPolicyOutput(v **CreateContinuousDeploymentPolicyOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *CreateContinuousDeploymentPolicyOutput if *v == nil { sv = &CreateContinuousDeploymentPolicyOutput{} } 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("ContinuousDeploymentPolicy", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentContinuousDeploymentPolicy(&sv.ContinuousDeploymentPolicy, nodeDecoder); err != nil { return err } default: // Do nothing and ignore the unexpected tag element err = decoder.Decoder.Skip() if err != nil { return err } } decoder = originalDecoder } *v = sv return nil } type awsRestxml_deserializeOpCreateDistribution struct { } func (*awsRestxml_deserializeOpCreateDistribution) ID() string { return "OperationDeserializer" } func (m *awsRestxml_deserializeOpCreateDistribution) 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, awsRestxml_deserializeOpErrorCreateDistribution(response, &metadata) } output := &CreateDistributionOutput{} out.Result = output err = awsRestxml_deserializeOpHttpBindingsCreateDistributionOutput(output, response) if err != nil { return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} } 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) err = awsRestxml_deserializeDocumentDistribution(&output.Distribution, decoder) 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(), } } return out, metadata, err } func awsRestxml_deserializeOpErrorCreateDistribution(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("AccessDenied", errorCode): return awsRestxml_deserializeErrorAccessDenied(response, errorBody) case strings.EqualFold("CNAMEAlreadyExists", errorCode): return awsRestxml_deserializeErrorCNAMEAlreadyExists(response, errorBody) case strings.EqualFold("ContinuousDeploymentPolicyInUse", errorCode): return awsRestxml_deserializeErrorContinuousDeploymentPolicyInUse(response, errorBody) case strings.EqualFold("DistributionAlreadyExists", errorCode): return awsRestxml_deserializeErrorDistributionAlreadyExists(response, errorBody) case strings.EqualFold("IllegalFieldLevelEncryptionConfigAssociationWithCacheBehavior", errorCode): return awsRestxml_deserializeErrorIllegalFieldLevelEncryptionConfigAssociationWithCacheBehavior(response, errorBody) case strings.EqualFold("IllegalOriginAccessConfiguration", errorCode): return awsRestxml_deserializeErrorIllegalOriginAccessConfiguration(response, errorBody) case strings.EqualFold("InconsistentQuantities", errorCode): return awsRestxml_deserializeErrorInconsistentQuantities(response, errorBody) case strings.EqualFold("InvalidArgument", errorCode): return awsRestxml_deserializeErrorInvalidArgument(response, errorBody) case strings.EqualFold("InvalidDefaultRootObject", errorCode): return awsRestxml_deserializeErrorInvalidDefaultRootObject(response, errorBody) case strings.EqualFold("InvalidDomainNameForOriginAccessControl", errorCode): return awsRestxml_deserializeErrorInvalidDomainNameForOriginAccessControl(response, errorBody) case strings.EqualFold("InvalidErrorCode", errorCode): return awsRestxml_deserializeErrorInvalidErrorCode(response, errorBody) case strings.EqualFold("InvalidForwardCookies", errorCode): return awsRestxml_deserializeErrorInvalidForwardCookies(response, errorBody) case strings.EqualFold("InvalidFunctionAssociation", errorCode): return awsRestxml_deserializeErrorInvalidFunctionAssociation(response, errorBody) case strings.EqualFold("InvalidGeoRestrictionParameter", errorCode): return awsRestxml_deserializeErrorInvalidGeoRestrictionParameter(response, errorBody) case strings.EqualFold("InvalidHeadersForS3Origin", errorCode): return awsRestxml_deserializeErrorInvalidHeadersForS3Origin(response, errorBody) case strings.EqualFold("InvalidLambdaFunctionAssociation", errorCode): return awsRestxml_deserializeErrorInvalidLambdaFunctionAssociation(response, errorBody) case strings.EqualFold("InvalidLocationCode", errorCode): return awsRestxml_deserializeErrorInvalidLocationCode(response, errorBody) case strings.EqualFold("InvalidMinimumProtocolVersion", errorCode): return awsRestxml_deserializeErrorInvalidMinimumProtocolVersion(response, errorBody) case strings.EqualFold("InvalidOrigin", errorCode): return awsRestxml_deserializeErrorInvalidOrigin(response, errorBody) case strings.EqualFold("InvalidOriginAccessControl", errorCode): return awsRestxml_deserializeErrorInvalidOriginAccessControl(response, errorBody) case strings.EqualFold("InvalidOriginAccessIdentity", errorCode): return awsRestxml_deserializeErrorInvalidOriginAccessIdentity(response, errorBody) case strings.EqualFold("InvalidOriginKeepaliveTimeout", errorCode): return awsRestxml_deserializeErrorInvalidOriginKeepaliveTimeout(response, errorBody) case strings.EqualFold("InvalidOriginReadTimeout", errorCode): return awsRestxml_deserializeErrorInvalidOriginReadTimeout(response, errorBody) case strings.EqualFold("InvalidProtocolSettings", errorCode): return awsRestxml_deserializeErrorInvalidProtocolSettings(response, errorBody) case strings.EqualFold("InvalidQueryStringParameters", errorCode): return awsRestxml_deserializeErrorInvalidQueryStringParameters(response, errorBody) case strings.EqualFold("InvalidRelativePath", errorCode): return awsRestxml_deserializeErrorInvalidRelativePath(response, errorBody) case strings.EqualFold("InvalidRequiredProtocol", errorCode): return awsRestxml_deserializeErrorInvalidRequiredProtocol(response, errorBody) case strings.EqualFold("InvalidResponseCode", errorCode): return awsRestxml_deserializeErrorInvalidResponseCode(response, errorBody) case strings.EqualFold("InvalidTTLOrder", errorCode): return awsRestxml_deserializeErrorInvalidTTLOrder(response, errorBody) case strings.EqualFold("InvalidViewerCertificate", errorCode): return awsRestxml_deserializeErrorInvalidViewerCertificate(response, errorBody) case strings.EqualFold("InvalidWebACLId", errorCode): return awsRestxml_deserializeErrorInvalidWebACLId(response, errorBody) case strings.EqualFold("MissingBody", errorCode): return awsRestxml_deserializeErrorMissingBody(response, errorBody) case strings.EqualFold("NoSuchCachePolicy", errorCode): return awsRestxml_deserializeErrorNoSuchCachePolicy(response, errorBody) case strings.EqualFold("NoSuchContinuousDeploymentPolicy", errorCode): return awsRestxml_deserializeErrorNoSuchContinuousDeploymentPolicy(response, errorBody) case strings.EqualFold("NoSuchFieldLevelEncryptionConfig", errorCode): return awsRestxml_deserializeErrorNoSuchFieldLevelEncryptionConfig(response, errorBody) case strings.EqualFold("NoSuchOrigin", errorCode): return awsRestxml_deserializeErrorNoSuchOrigin(response, errorBody) case strings.EqualFold("NoSuchOriginRequestPolicy", errorCode): return awsRestxml_deserializeErrorNoSuchOriginRequestPolicy(response, errorBody) case strings.EqualFold("NoSuchRealtimeLogConfig", errorCode): return awsRestxml_deserializeErrorNoSuchRealtimeLogConfig(response, errorBody) case strings.EqualFold("NoSuchResponseHeadersPolicy", errorCode): return awsRestxml_deserializeErrorNoSuchResponseHeadersPolicy(response, errorBody) case strings.EqualFold("RealtimeLogConfigOwnerMismatch", errorCode): return awsRestxml_deserializeErrorRealtimeLogConfigOwnerMismatch(response, errorBody) case strings.EqualFold("TooManyCacheBehaviors", errorCode): return awsRestxml_deserializeErrorTooManyCacheBehaviors(response, errorBody) case strings.EqualFold("TooManyCertificates", errorCode): return awsRestxml_deserializeErrorTooManyCertificates(response, errorBody) case strings.EqualFold("TooManyCookieNamesInWhiteList", errorCode): return awsRestxml_deserializeErrorTooManyCookieNamesInWhiteList(response, errorBody) case strings.EqualFold("TooManyDistributionCNAMEs", errorCode): return awsRestxml_deserializeErrorTooManyDistributionCNAMEs(response, errorBody) case strings.EqualFold("TooManyDistributions", errorCode): return awsRestxml_deserializeErrorTooManyDistributions(response, errorBody) case strings.EqualFold("TooManyDistributionsAssociatedToCachePolicy", errorCode): return awsRestxml_deserializeErrorTooManyDistributionsAssociatedToCachePolicy(response, errorBody) case strings.EqualFold("TooManyDistributionsAssociatedToFieldLevelEncryptionConfig", errorCode): return awsRestxml_deserializeErrorTooManyDistributionsAssociatedToFieldLevelEncryptionConfig(response, errorBody) case strings.EqualFold("TooManyDistributionsAssociatedToKeyGroup", errorCode): return awsRestxml_deserializeErrorTooManyDistributionsAssociatedToKeyGroup(response, errorBody) case strings.EqualFold("TooManyDistributionsAssociatedToOriginAccessControl", errorCode): return awsRestxml_deserializeErrorTooManyDistributionsAssociatedToOriginAccessControl(response, errorBody) case strings.EqualFold("TooManyDistributionsAssociatedToOriginRequestPolicy", errorCode): return awsRestxml_deserializeErrorTooManyDistributionsAssociatedToOriginRequestPolicy(response, errorBody) case strings.EqualFold("TooManyDistributionsAssociatedToResponseHeadersPolicy", errorCode): return awsRestxml_deserializeErrorTooManyDistributionsAssociatedToResponseHeadersPolicy(response, errorBody) case strings.EqualFold("TooManyDistributionsWithFunctionAssociations", errorCode): return awsRestxml_deserializeErrorTooManyDistributionsWithFunctionAssociations(response, errorBody) case strings.EqualFold("TooManyDistributionsWithLambdaAssociations", errorCode): return awsRestxml_deserializeErrorTooManyDistributionsWithLambdaAssociations(response, errorBody) case strings.EqualFold("TooManyDistributionsWithSingleFunctionARN", errorCode): return awsRestxml_deserializeErrorTooManyDistributionsWithSingleFunctionARN(response, errorBody) case strings.EqualFold("TooManyFunctionAssociations", errorCode): return awsRestxml_deserializeErrorTooManyFunctionAssociations(response, errorBody) case strings.EqualFold("TooManyHeadersInForwardedValues", errorCode): return awsRestxml_deserializeErrorTooManyHeadersInForwardedValues(response, errorBody) case strings.EqualFold("TooManyKeyGroupsAssociatedToDistribution", errorCode): return awsRestxml_deserializeErrorTooManyKeyGroupsAssociatedToDistribution(response, errorBody) case strings.EqualFold("TooManyLambdaFunctionAssociations", errorCode): return awsRestxml_deserializeErrorTooManyLambdaFunctionAssociations(response, errorBody) case strings.EqualFold("TooManyOriginCustomHeaders", errorCode): return awsRestxml_deserializeErrorTooManyOriginCustomHeaders(response, errorBody) case strings.EqualFold("TooManyOriginGroupsPerDistribution", errorCode): return awsRestxml_deserializeErrorTooManyOriginGroupsPerDistribution(response, errorBody) case strings.EqualFold("TooManyOrigins", errorCode): return awsRestxml_deserializeErrorTooManyOrigins(response, errorBody) case strings.EqualFold("TooManyQueryStringParameters", errorCode): return awsRestxml_deserializeErrorTooManyQueryStringParameters(response, errorBody) case strings.EqualFold("TooManyTrustedSigners", errorCode): return awsRestxml_deserializeErrorTooManyTrustedSigners(response, errorBody) case strings.EqualFold("TrustedKeyGroupDoesNotExist", errorCode): return awsRestxml_deserializeErrorTrustedKeyGroupDoesNotExist(response, errorBody) case strings.EqualFold("TrustedSignerDoesNotExist", errorCode): return awsRestxml_deserializeErrorTrustedSignerDoesNotExist(response, errorBody) default: genericError := &smithy.GenericAPIError{ Code: errorCode, Message: errorMessage, } return genericError } } func awsRestxml_deserializeOpHttpBindingsCreateDistributionOutput(v *CreateDistributionOutput, response *smithyhttp.Response) error { if v == nil { return fmt.Errorf("unsupported deserialization for nil %T", v) } if headerValues := response.Header.Values("ETag"); len(headerValues) != 0 { headerValues[0] = strings.TrimSpace(headerValues[0]) v.ETag = ptr.String(headerValues[0]) } if headerValues := response.Header.Values("Location"); len(headerValues) != 0 { headerValues[0] = strings.TrimSpace(headerValues[0]) v.Location = ptr.String(headerValues[0]) } return nil } func awsRestxml_deserializeOpDocumentCreateDistributionOutput(v **CreateDistributionOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *CreateDistributionOutput if *v == nil { sv = &CreateDistributionOutput{} } 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("Distribution", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentDistribution(&sv.Distribution, nodeDecoder); err != nil { return err } default: // Do nothing and ignore the unexpected tag element err = decoder.Decoder.Skip() if err != nil { return err } } decoder = originalDecoder } *v = sv return nil } type awsRestxml_deserializeOpCreateDistributionWithTags struct { } func (*awsRestxml_deserializeOpCreateDistributionWithTags) ID() string { return "OperationDeserializer" } func (m *awsRestxml_deserializeOpCreateDistributionWithTags) 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, awsRestxml_deserializeOpErrorCreateDistributionWithTags(response, &metadata) } output := &CreateDistributionWithTagsOutput{} out.Result = output err = awsRestxml_deserializeOpHttpBindingsCreateDistributionWithTagsOutput(output, response) if err != nil { return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} } 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) err = awsRestxml_deserializeDocumentDistribution(&output.Distribution, decoder) 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(), } } return out, metadata, err } func awsRestxml_deserializeOpErrorCreateDistributionWithTags(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("AccessDenied", errorCode): return awsRestxml_deserializeErrorAccessDenied(response, errorBody) case strings.EqualFold("CNAMEAlreadyExists", errorCode): return awsRestxml_deserializeErrorCNAMEAlreadyExists(response, errorBody) case strings.EqualFold("ContinuousDeploymentPolicyInUse", errorCode): return awsRestxml_deserializeErrorContinuousDeploymentPolicyInUse(response, errorBody) case strings.EqualFold("DistributionAlreadyExists", errorCode): return awsRestxml_deserializeErrorDistributionAlreadyExists(response, errorBody) case strings.EqualFold("IllegalFieldLevelEncryptionConfigAssociationWithCacheBehavior", errorCode): return awsRestxml_deserializeErrorIllegalFieldLevelEncryptionConfigAssociationWithCacheBehavior(response, errorBody) case strings.EqualFold("IllegalOriginAccessConfiguration", errorCode): return awsRestxml_deserializeErrorIllegalOriginAccessConfiguration(response, errorBody) case strings.EqualFold("InconsistentQuantities", errorCode): return awsRestxml_deserializeErrorInconsistentQuantities(response, errorBody) case strings.EqualFold("InvalidArgument", errorCode): return awsRestxml_deserializeErrorInvalidArgument(response, errorBody) case strings.EqualFold("InvalidDefaultRootObject", errorCode): return awsRestxml_deserializeErrorInvalidDefaultRootObject(response, errorBody) case strings.EqualFold("InvalidDomainNameForOriginAccessControl", errorCode): return awsRestxml_deserializeErrorInvalidDomainNameForOriginAccessControl(response, errorBody) case strings.EqualFold("InvalidErrorCode", errorCode): return awsRestxml_deserializeErrorInvalidErrorCode(response, errorBody) case strings.EqualFold("InvalidForwardCookies", errorCode): return awsRestxml_deserializeErrorInvalidForwardCookies(response, errorBody) case strings.EqualFold("InvalidFunctionAssociation", errorCode): return awsRestxml_deserializeErrorInvalidFunctionAssociation(response, errorBody) case strings.EqualFold("InvalidGeoRestrictionParameter", errorCode): return awsRestxml_deserializeErrorInvalidGeoRestrictionParameter(response, errorBody) case strings.EqualFold("InvalidHeadersForS3Origin", errorCode): return awsRestxml_deserializeErrorInvalidHeadersForS3Origin(response, errorBody) case strings.EqualFold("InvalidLambdaFunctionAssociation", errorCode): return awsRestxml_deserializeErrorInvalidLambdaFunctionAssociation(response, errorBody) case strings.EqualFold("InvalidLocationCode", errorCode): return awsRestxml_deserializeErrorInvalidLocationCode(response, errorBody) case strings.EqualFold("InvalidMinimumProtocolVersion", errorCode): return awsRestxml_deserializeErrorInvalidMinimumProtocolVersion(response, errorBody) case strings.EqualFold("InvalidOrigin", errorCode): return awsRestxml_deserializeErrorInvalidOrigin(response, errorBody) case strings.EqualFold("InvalidOriginAccessControl", errorCode): return awsRestxml_deserializeErrorInvalidOriginAccessControl(response, errorBody) case strings.EqualFold("InvalidOriginAccessIdentity", errorCode): return awsRestxml_deserializeErrorInvalidOriginAccessIdentity(response, errorBody) case strings.EqualFold("InvalidOriginKeepaliveTimeout", errorCode): return awsRestxml_deserializeErrorInvalidOriginKeepaliveTimeout(response, errorBody) case strings.EqualFold("InvalidOriginReadTimeout", errorCode): return awsRestxml_deserializeErrorInvalidOriginReadTimeout(response, errorBody) case strings.EqualFold("InvalidProtocolSettings", errorCode): return awsRestxml_deserializeErrorInvalidProtocolSettings(response, errorBody) case strings.EqualFold("InvalidQueryStringParameters", errorCode): return awsRestxml_deserializeErrorInvalidQueryStringParameters(response, errorBody) case strings.EqualFold("InvalidRelativePath", errorCode): return awsRestxml_deserializeErrorInvalidRelativePath(response, errorBody) case strings.EqualFold("InvalidRequiredProtocol", errorCode): return awsRestxml_deserializeErrorInvalidRequiredProtocol(response, errorBody) case strings.EqualFold("InvalidResponseCode", errorCode): return awsRestxml_deserializeErrorInvalidResponseCode(response, errorBody) case strings.EqualFold("InvalidTTLOrder", errorCode): return awsRestxml_deserializeErrorInvalidTTLOrder(response, errorBody) case strings.EqualFold("InvalidTagging", errorCode): return awsRestxml_deserializeErrorInvalidTagging(response, errorBody) case strings.EqualFold("InvalidViewerCertificate", errorCode): return awsRestxml_deserializeErrorInvalidViewerCertificate(response, errorBody) case strings.EqualFold("InvalidWebACLId", errorCode): return awsRestxml_deserializeErrorInvalidWebACLId(response, errorBody) case strings.EqualFold("MissingBody", errorCode): return awsRestxml_deserializeErrorMissingBody(response, errorBody) case strings.EqualFold("NoSuchCachePolicy", errorCode): return awsRestxml_deserializeErrorNoSuchCachePolicy(response, errorBody) case strings.EqualFold("NoSuchContinuousDeploymentPolicy", errorCode): return awsRestxml_deserializeErrorNoSuchContinuousDeploymentPolicy(response, errorBody) case strings.EqualFold("NoSuchFieldLevelEncryptionConfig", errorCode): return awsRestxml_deserializeErrorNoSuchFieldLevelEncryptionConfig(response, errorBody) case strings.EqualFold("NoSuchOrigin", errorCode): return awsRestxml_deserializeErrorNoSuchOrigin(response, errorBody) case strings.EqualFold("NoSuchOriginRequestPolicy", errorCode): return awsRestxml_deserializeErrorNoSuchOriginRequestPolicy(response, errorBody) case strings.EqualFold("NoSuchRealtimeLogConfig", errorCode): return awsRestxml_deserializeErrorNoSuchRealtimeLogConfig(response, errorBody) case strings.EqualFold("NoSuchResponseHeadersPolicy", errorCode): return awsRestxml_deserializeErrorNoSuchResponseHeadersPolicy(response, errorBody) case strings.EqualFold("RealtimeLogConfigOwnerMismatch", errorCode): return awsRestxml_deserializeErrorRealtimeLogConfigOwnerMismatch(response, errorBody) case strings.EqualFold("TooManyCacheBehaviors", errorCode): return awsRestxml_deserializeErrorTooManyCacheBehaviors(response, errorBody) case strings.EqualFold("TooManyCertificates", errorCode): return awsRestxml_deserializeErrorTooManyCertificates(response, errorBody) case strings.EqualFold("TooManyCookieNamesInWhiteList", errorCode): return awsRestxml_deserializeErrorTooManyCookieNamesInWhiteList(response, errorBody) case strings.EqualFold("TooManyDistributionCNAMEs", errorCode): return awsRestxml_deserializeErrorTooManyDistributionCNAMEs(response, errorBody) case strings.EqualFold("TooManyDistributions", errorCode): return awsRestxml_deserializeErrorTooManyDistributions(response, errorBody) case strings.EqualFold("TooManyDistributionsAssociatedToCachePolicy", errorCode): return awsRestxml_deserializeErrorTooManyDistributionsAssociatedToCachePolicy(response, errorBody) case strings.EqualFold("TooManyDistributionsAssociatedToFieldLevelEncryptionConfig", errorCode): return awsRestxml_deserializeErrorTooManyDistributionsAssociatedToFieldLevelEncryptionConfig(response, errorBody) case strings.EqualFold("TooManyDistributionsAssociatedToKeyGroup", errorCode): return awsRestxml_deserializeErrorTooManyDistributionsAssociatedToKeyGroup(response, errorBody) case strings.EqualFold("TooManyDistributionsAssociatedToOriginAccessControl", errorCode): return awsRestxml_deserializeErrorTooManyDistributionsAssociatedToOriginAccessControl(response, errorBody) case strings.EqualFold("TooManyDistributionsAssociatedToOriginRequestPolicy", errorCode): return awsRestxml_deserializeErrorTooManyDistributionsAssociatedToOriginRequestPolicy(response, errorBody) case strings.EqualFold("TooManyDistributionsAssociatedToResponseHeadersPolicy", errorCode): return awsRestxml_deserializeErrorTooManyDistributionsAssociatedToResponseHeadersPolicy(response, errorBody) case strings.EqualFold("TooManyDistributionsWithFunctionAssociations", errorCode): return awsRestxml_deserializeErrorTooManyDistributionsWithFunctionAssociations(response, errorBody) case strings.EqualFold("TooManyDistributionsWithLambdaAssociations", errorCode): return awsRestxml_deserializeErrorTooManyDistributionsWithLambdaAssociations(response, errorBody) case strings.EqualFold("TooManyDistributionsWithSingleFunctionARN", errorCode): return awsRestxml_deserializeErrorTooManyDistributionsWithSingleFunctionARN(response, errorBody) case strings.EqualFold("TooManyFunctionAssociations", errorCode): return awsRestxml_deserializeErrorTooManyFunctionAssociations(response, errorBody) case strings.EqualFold("TooManyHeadersInForwardedValues", errorCode): return awsRestxml_deserializeErrorTooManyHeadersInForwardedValues(response, errorBody) case strings.EqualFold("TooManyKeyGroupsAssociatedToDistribution", errorCode): return awsRestxml_deserializeErrorTooManyKeyGroupsAssociatedToDistribution(response, errorBody) case strings.EqualFold("TooManyLambdaFunctionAssociations", errorCode): return awsRestxml_deserializeErrorTooManyLambdaFunctionAssociations(response, errorBody) case strings.EqualFold("TooManyOriginCustomHeaders", errorCode): return awsRestxml_deserializeErrorTooManyOriginCustomHeaders(response, errorBody) case strings.EqualFold("TooManyOriginGroupsPerDistribution", errorCode): return awsRestxml_deserializeErrorTooManyOriginGroupsPerDistribution(response, errorBody) case strings.EqualFold("TooManyOrigins", errorCode): return awsRestxml_deserializeErrorTooManyOrigins(response, errorBody) case strings.EqualFold("TooManyQueryStringParameters", errorCode): return awsRestxml_deserializeErrorTooManyQueryStringParameters(response, errorBody) case strings.EqualFold("TooManyTrustedSigners", errorCode): return awsRestxml_deserializeErrorTooManyTrustedSigners(response, errorBody) case strings.EqualFold("TrustedKeyGroupDoesNotExist", errorCode): return awsRestxml_deserializeErrorTrustedKeyGroupDoesNotExist(response, errorBody) case strings.EqualFold("TrustedSignerDoesNotExist", errorCode): return awsRestxml_deserializeErrorTrustedSignerDoesNotExist(response, errorBody) default: genericError := &smithy.GenericAPIError{ Code: errorCode, Message: errorMessage, } return genericError } } func awsRestxml_deserializeOpHttpBindingsCreateDistributionWithTagsOutput(v *CreateDistributionWithTagsOutput, response *smithyhttp.Response) error { if v == nil { return fmt.Errorf("unsupported deserialization for nil %T", v) } if headerValues := response.Header.Values("ETag"); len(headerValues) != 0 { headerValues[0] = strings.TrimSpace(headerValues[0]) v.ETag = ptr.String(headerValues[0]) } if headerValues := response.Header.Values("Location"); len(headerValues) != 0 { headerValues[0] = strings.TrimSpace(headerValues[0]) v.Location = ptr.String(headerValues[0]) } return nil } func awsRestxml_deserializeOpDocumentCreateDistributionWithTagsOutput(v **CreateDistributionWithTagsOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *CreateDistributionWithTagsOutput if *v == nil { sv = &CreateDistributionWithTagsOutput{} } 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("Distribution", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentDistribution(&sv.Distribution, nodeDecoder); err != nil { return err } default: // Do nothing and ignore the unexpected tag element err = decoder.Decoder.Skip() if err != nil { return err } } decoder = originalDecoder } *v = sv return nil } type awsRestxml_deserializeOpCreateFieldLevelEncryptionConfig struct { } func (*awsRestxml_deserializeOpCreateFieldLevelEncryptionConfig) ID() string { return "OperationDeserializer" } func (m *awsRestxml_deserializeOpCreateFieldLevelEncryptionConfig) 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, awsRestxml_deserializeOpErrorCreateFieldLevelEncryptionConfig(response, &metadata) } output := &CreateFieldLevelEncryptionConfigOutput{} out.Result = output err = awsRestxml_deserializeOpHttpBindingsCreateFieldLevelEncryptionConfigOutput(output, response) if err != nil { return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} } 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) err = awsRestxml_deserializeDocumentFieldLevelEncryption(&output.FieldLevelEncryption, decoder) 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(), } } return out, metadata, err } func awsRestxml_deserializeOpErrorCreateFieldLevelEncryptionConfig(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("FieldLevelEncryptionConfigAlreadyExists", errorCode): return awsRestxml_deserializeErrorFieldLevelEncryptionConfigAlreadyExists(response, errorBody) case strings.EqualFold("InconsistentQuantities", errorCode): return awsRestxml_deserializeErrorInconsistentQuantities(response, errorBody) case strings.EqualFold("InvalidArgument", errorCode): return awsRestxml_deserializeErrorInvalidArgument(response, errorBody) case strings.EqualFold("NoSuchFieldLevelEncryptionProfile", errorCode): return awsRestxml_deserializeErrorNoSuchFieldLevelEncryptionProfile(response, errorBody) case strings.EqualFold("QueryArgProfileEmpty", errorCode): return awsRestxml_deserializeErrorQueryArgProfileEmpty(response, errorBody) case strings.EqualFold("TooManyFieldLevelEncryptionConfigs", errorCode): return awsRestxml_deserializeErrorTooManyFieldLevelEncryptionConfigs(response, errorBody) case strings.EqualFold("TooManyFieldLevelEncryptionContentTypeProfiles", errorCode): return awsRestxml_deserializeErrorTooManyFieldLevelEncryptionContentTypeProfiles(response, errorBody) case strings.EqualFold("TooManyFieldLevelEncryptionQueryArgProfiles", errorCode): return awsRestxml_deserializeErrorTooManyFieldLevelEncryptionQueryArgProfiles(response, errorBody) default: genericError := &smithy.GenericAPIError{ Code: errorCode, Message: errorMessage, } return genericError } } func awsRestxml_deserializeOpHttpBindingsCreateFieldLevelEncryptionConfigOutput(v *CreateFieldLevelEncryptionConfigOutput, response *smithyhttp.Response) error { if v == nil { return fmt.Errorf("unsupported deserialization for nil %T", v) } if headerValues := response.Header.Values("ETag"); len(headerValues) != 0 { headerValues[0] = strings.TrimSpace(headerValues[0]) v.ETag = ptr.String(headerValues[0]) } if headerValues := response.Header.Values("Location"); len(headerValues) != 0 { headerValues[0] = strings.TrimSpace(headerValues[0]) v.Location = ptr.String(headerValues[0]) } return nil } func awsRestxml_deserializeOpDocumentCreateFieldLevelEncryptionConfigOutput(v **CreateFieldLevelEncryptionConfigOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *CreateFieldLevelEncryptionConfigOutput if *v == nil { sv = &CreateFieldLevelEncryptionConfigOutput{} } 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("FieldLevelEncryption", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentFieldLevelEncryption(&sv.FieldLevelEncryption, nodeDecoder); err != nil { return err } default: // Do nothing and ignore the unexpected tag element err = decoder.Decoder.Skip() if err != nil { return err } } decoder = originalDecoder } *v = sv return nil } type awsRestxml_deserializeOpCreateFieldLevelEncryptionProfile struct { } func (*awsRestxml_deserializeOpCreateFieldLevelEncryptionProfile) ID() string { return "OperationDeserializer" } func (m *awsRestxml_deserializeOpCreateFieldLevelEncryptionProfile) 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, awsRestxml_deserializeOpErrorCreateFieldLevelEncryptionProfile(response, &metadata) } output := &CreateFieldLevelEncryptionProfileOutput{} out.Result = output err = awsRestxml_deserializeOpHttpBindingsCreateFieldLevelEncryptionProfileOutput(output, response) if err != nil { return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} } 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) err = awsRestxml_deserializeDocumentFieldLevelEncryptionProfile(&output.FieldLevelEncryptionProfile, decoder) 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(), } } return out, metadata, err } func awsRestxml_deserializeOpErrorCreateFieldLevelEncryptionProfile(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("FieldLevelEncryptionProfileAlreadyExists", errorCode): return awsRestxml_deserializeErrorFieldLevelEncryptionProfileAlreadyExists(response, errorBody) case strings.EqualFold("FieldLevelEncryptionProfileSizeExceeded", errorCode): return awsRestxml_deserializeErrorFieldLevelEncryptionProfileSizeExceeded(response, errorBody) case strings.EqualFold("InconsistentQuantities", errorCode): return awsRestxml_deserializeErrorInconsistentQuantities(response, errorBody) case strings.EqualFold("InvalidArgument", errorCode): return awsRestxml_deserializeErrorInvalidArgument(response, errorBody) case strings.EqualFold("NoSuchPublicKey", errorCode): return awsRestxml_deserializeErrorNoSuchPublicKey(response, errorBody) case strings.EqualFold("TooManyFieldLevelEncryptionEncryptionEntities", errorCode): return awsRestxml_deserializeErrorTooManyFieldLevelEncryptionEncryptionEntities(response, errorBody) case strings.EqualFold("TooManyFieldLevelEncryptionFieldPatterns", errorCode): return awsRestxml_deserializeErrorTooManyFieldLevelEncryptionFieldPatterns(response, errorBody) case strings.EqualFold("TooManyFieldLevelEncryptionProfiles", errorCode): return awsRestxml_deserializeErrorTooManyFieldLevelEncryptionProfiles(response, errorBody) default: genericError := &smithy.GenericAPIError{ Code: errorCode, Message: errorMessage, } return genericError } } func awsRestxml_deserializeOpHttpBindingsCreateFieldLevelEncryptionProfileOutput(v *CreateFieldLevelEncryptionProfileOutput, response *smithyhttp.Response) error { if v == nil { return fmt.Errorf("unsupported deserialization for nil %T", v) } if headerValues := response.Header.Values("ETag"); len(headerValues) != 0 { headerValues[0] = strings.TrimSpace(headerValues[0]) v.ETag = ptr.String(headerValues[0]) } if headerValues := response.Header.Values("Location"); len(headerValues) != 0 { headerValues[0] = strings.TrimSpace(headerValues[0]) v.Location = ptr.String(headerValues[0]) } return nil } func awsRestxml_deserializeOpDocumentCreateFieldLevelEncryptionProfileOutput(v **CreateFieldLevelEncryptionProfileOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *CreateFieldLevelEncryptionProfileOutput if *v == nil { sv = &CreateFieldLevelEncryptionProfileOutput{} } 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("FieldLevelEncryptionProfile", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentFieldLevelEncryptionProfile(&sv.FieldLevelEncryptionProfile, nodeDecoder); err != nil { return err } default: // Do nothing and ignore the unexpected tag element err = decoder.Decoder.Skip() if err != nil { return err } } decoder = originalDecoder } *v = sv return nil } type awsRestxml_deserializeOpCreateFunction struct { } func (*awsRestxml_deserializeOpCreateFunction) ID() string { return "OperationDeserializer" } func (m *awsRestxml_deserializeOpCreateFunction) 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, awsRestxml_deserializeOpErrorCreateFunction(response, &metadata) } output := &CreateFunctionOutput{} out.Result = output err = awsRestxml_deserializeOpHttpBindingsCreateFunctionOutput(output, response) if err != nil { return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} } 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) err = awsRestxml_deserializeDocumentFunctionSummary(&output.FunctionSummary, decoder) 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(), } } return out, metadata, err } func awsRestxml_deserializeOpErrorCreateFunction(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("FunctionAlreadyExists", errorCode): return awsRestxml_deserializeErrorFunctionAlreadyExists(response, errorBody) case strings.EqualFold("FunctionSizeLimitExceeded", errorCode): return awsRestxml_deserializeErrorFunctionSizeLimitExceeded(response, errorBody) case strings.EqualFold("InvalidArgument", errorCode): return awsRestxml_deserializeErrorInvalidArgument(response, errorBody) case strings.EqualFold("TooManyFunctions", errorCode): return awsRestxml_deserializeErrorTooManyFunctions(response, errorBody) case strings.EqualFold("UnsupportedOperation", errorCode): return awsRestxml_deserializeErrorUnsupportedOperation(response, errorBody) default: genericError := &smithy.GenericAPIError{ Code: errorCode, Message: errorMessage, } return genericError } } func awsRestxml_deserializeOpHttpBindingsCreateFunctionOutput(v *CreateFunctionOutput, response *smithyhttp.Response) error { if v == nil { return fmt.Errorf("unsupported deserialization for nil %T", v) } if headerValues := response.Header.Values("ETag"); len(headerValues) != 0 { headerValues[0] = strings.TrimSpace(headerValues[0]) v.ETag = ptr.String(headerValues[0]) } if headerValues := response.Header.Values("Location"); len(headerValues) != 0 { headerValues[0] = strings.TrimSpace(headerValues[0]) v.Location = ptr.String(headerValues[0]) } return nil } func awsRestxml_deserializeOpDocumentCreateFunctionOutput(v **CreateFunctionOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *CreateFunctionOutput if *v == nil { sv = &CreateFunctionOutput{} } 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("FunctionSummary", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentFunctionSummary(&sv.FunctionSummary, nodeDecoder); err != nil { return err } default: // Do nothing and ignore the unexpected tag element err = decoder.Decoder.Skip() if err != nil { return err } } decoder = originalDecoder } *v = sv return nil } type awsRestxml_deserializeOpCreateInvalidation struct { } func (*awsRestxml_deserializeOpCreateInvalidation) ID() string { return "OperationDeserializer" } func (m *awsRestxml_deserializeOpCreateInvalidation) 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, awsRestxml_deserializeOpErrorCreateInvalidation(response, &metadata) } output := &CreateInvalidationOutput{} out.Result = output err = awsRestxml_deserializeOpHttpBindingsCreateInvalidationOutput(output, response) if err != nil { return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} } 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) err = awsRestxml_deserializeDocumentInvalidation(&output.Invalidation, decoder) 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(), } } return out, metadata, err } func awsRestxml_deserializeOpErrorCreateInvalidation(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("AccessDenied", errorCode): return awsRestxml_deserializeErrorAccessDenied(response, errorBody) case strings.EqualFold("BatchTooLarge", errorCode): return awsRestxml_deserializeErrorBatchTooLarge(response, errorBody) case strings.EqualFold("InconsistentQuantities", errorCode): return awsRestxml_deserializeErrorInconsistentQuantities(response, errorBody) case strings.EqualFold("InvalidArgument", errorCode): return awsRestxml_deserializeErrorInvalidArgument(response, errorBody) case strings.EqualFold("MissingBody", errorCode): return awsRestxml_deserializeErrorMissingBody(response, errorBody) case strings.EqualFold("NoSuchDistribution", errorCode): return awsRestxml_deserializeErrorNoSuchDistribution(response, errorBody) case strings.EqualFold("TooManyInvalidationsInProgress", errorCode): return awsRestxml_deserializeErrorTooManyInvalidationsInProgress(response, errorBody) default: genericError := &smithy.GenericAPIError{ Code: errorCode, Message: errorMessage, } return genericError } } func awsRestxml_deserializeOpHttpBindingsCreateInvalidationOutput(v *CreateInvalidationOutput, response *smithyhttp.Response) error { if v == nil { return fmt.Errorf("unsupported deserialization for nil %T", v) } if headerValues := response.Header.Values("Location"); len(headerValues) != 0 { headerValues[0] = strings.TrimSpace(headerValues[0]) v.Location = ptr.String(headerValues[0]) } return nil } func awsRestxml_deserializeOpDocumentCreateInvalidationOutput(v **CreateInvalidationOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *CreateInvalidationOutput if *v == nil { sv = &CreateInvalidationOutput{} } 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("Invalidation", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentInvalidation(&sv.Invalidation, nodeDecoder); err != nil { return err } default: // Do nothing and ignore the unexpected tag element err = decoder.Decoder.Skip() if err != nil { return err } } decoder = originalDecoder } *v = sv return nil } type awsRestxml_deserializeOpCreateKeyGroup struct { } func (*awsRestxml_deserializeOpCreateKeyGroup) ID() string { return "OperationDeserializer" } func (m *awsRestxml_deserializeOpCreateKeyGroup) 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, awsRestxml_deserializeOpErrorCreateKeyGroup(response, &metadata) } output := &CreateKeyGroupOutput{} out.Result = output err = awsRestxml_deserializeOpHttpBindingsCreateKeyGroupOutput(output, response) if err != nil { return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} } 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) err = awsRestxml_deserializeDocumentKeyGroup(&output.KeyGroup, decoder) 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(), } } return out, metadata, err } func awsRestxml_deserializeOpErrorCreateKeyGroup(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("InvalidArgument", errorCode): return awsRestxml_deserializeErrorInvalidArgument(response, errorBody) case strings.EqualFold("KeyGroupAlreadyExists", errorCode): return awsRestxml_deserializeErrorKeyGroupAlreadyExists(response, errorBody) case strings.EqualFold("TooManyKeyGroups", errorCode): return awsRestxml_deserializeErrorTooManyKeyGroups(response, errorBody) case strings.EqualFold("TooManyPublicKeysInKeyGroup", errorCode): return awsRestxml_deserializeErrorTooManyPublicKeysInKeyGroup(response, errorBody) default: genericError := &smithy.GenericAPIError{ Code: errorCode, Message: errorMessage, } return genericError } } func awsRestxml_deserializeOpHttpBindingsCreateKeyGroupOutput(v *CreateKeyGroupOutput, response *smithyhttp.Response) error { if v == nil { return fmt.Errorf("unsupported deserialization for nil %T", v) } if headerValues := response.Header.Values("ETag"); len(headerValues) != 0 { headerValues[0] = strings.TrimSpace(headerValues[0]) v.ETag = ptr.String(headerValues[0]) } if headerValues := response.Header.Values("Location"); len(headerValues) != 0 { headerValues[0] = strings.TrimSpace(headerValues[0]) v.Location = ptr.String(headerValues[0]) } return nil } func awsRestxml_deserializeOpDocumentCreateKeyGroupOutput(v **CreateKeyGroupOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *CreateKeyGroupOutput if *v == nil { sv = &CreateKeyGroupOutput{} } 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("KeyGroup", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentKeyGroup(&sv.KeyGroup, nodeDecoder); err != nil { return err } default: // Do nothing and ignore the unexpected tag element err = decoder.Decoder.Skip() if err != nil { return err } } decoder = originalDecoder } *v = sv return nil } type awsRestxml_deserializeOpCreateMonitoringSubscription struct { } func (*awsRestxml_deserializeOpCreateMonitoringSubscription) ID() string { return "OperationDeserializer" } func (m *awsRestxml_deserializeOpCreateMonitoringSubscription) 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, awsRestxml_deserializeOpErrorCreateMonitoringSubscription(response, &metadata) } output := &CreateMonitoringSubscriptionOutput{} 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) err = awsRestxml_deserializeDocumentMonitoringSubscription(&output.MonitoringSubscription, decoder) 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(), } } return out, metadata, err } func awsRestxml_deserializeOpErrorCreateMonitoringSubscription(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("AccessDenied", errorCode): return awsRestxml_deserializeErrorAccessDenied(response, errorBody) case strings.EqualFold("MonitoringSubscriptionAlreadyExists", errorCode): return awsRestxml_deserializeErrorMonitoringSubscriptionAlreadyExists(response, errorBody) case strings.EqualFold("NoSuchDistribution", errorCode): return awsRestxml_deserializeErrorNoSuchDistribution(response, errorBody) case strings.EqualFold("UnsupportedOperation", errorCode): return awsRestxml_deserializeErrorUnsupportedOperation(response, errorBody) default: genericError := &smithy.GenericAPIError{ Code: errorCode, Message: errorMessage, } return genericError } } func awsRestxml_deserializeOpDocumentCreateMonitoringSubscriptionOutput(v **CreateMonitoringSubscriptionOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *CreateMonitoringSubscriptionOutput if *v == nil { sv = &CreateMonitoringSubscriptionOutput{} } 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("MonitoringSubscription", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentMonitoringSubscription(&sv.MonitoringSubscription, nodeDecoder); err != nil { return err } default: // Do nothing and ignore the unexpected tag element err = decoder.Decoder.Skip() if err != nil { return err } } decoder = originalDecoder } *v = sv return nil } type awsRestxml_deserializeOpCreateOriginAccessControl struct { } func (*awsRestxml_deserializeOpCreateOriginAccessControl) ID() string { return "OperationDeserializer" } func (m *awsRestxml_deserializeOpCreateOriginAccessControl) 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, awsRestxml_deserializeOpErrorCreateOriginAccessControl(response, &metadata) } output := &CreateOriginAccessControlOutput{} out.Result = output err = awsRestxml_deserializeOpHttpBindingsCreateOriginAccessControlOutput(output, response) if err != nil { return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} } 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) err = awsRestxml_deserializeDocumentOriginAccessControl(&output.OriginAccessControl, decoder) 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(), } } return out, metadata, err } func awsRestxml_deserializeOpErrorCreateOriginAccessControl(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("InvalidArgument", errorCode): return awsRestxml_deserializeErrorInvalidArgument(response, errorBody) case strings.EqualFold("OriginAccessControlAlreadyExists", errorCode): return awsRestxml_deserializeErrorOriginAccessControlAlreadyExists(response, errorBody) case strings.EqualFold("TooManyOriginAccessControls", errorCode): return awsRestxml_deserializeErrorTooManyOriginAccessControls(response, errorBody) default: genericError := &smithy.GenericAPIError{ Code: errorCode, Message: errorMessage, } return genericError } } func awsRestxml_deserializeOpHttpBindingsCreateOriginAccessControlOutput(v *CreateOriginAccessControlOutput, response *smithyhttp.Response) error { if v == nil { return fmt.Errorf("unsupported deserialization for nil %T", v) } if headerValues := response.Header.Values("ETag"); len(headerValues) != 0 { headerValues[0] = strings.TrimSpace(headerValues[0]) v.ETag = ptr.String(headerValues[0]) } if headerValues := response.Header.Values("Location"); len(headerValues) != 0 { headerValues[0] = strings.TrimSpace(headerValues[0]) v.Location = ptr.String(headerValues[0]) } return nil } func awsRestxml_deserializeOpDocumentCreateOriginAccessControlOutput(v **CreateOriginAccessControlOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *CreateOriginAccessControlOutput if *v == nil { sv = &CreateOriginAccessControlOutput{} } 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("OriginAccessControl", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentOriginAccessControl(&sv.OriginAccessControl, nodeDecoder); err != nil { return err } default: // Do nothing and ignore the unexpected tag element err = decoder.Decoder.Skip() if err != nil { return err } } decoder = originalDecoder } *v = sv return nil } type awsRestxml_deserializeOpCreateOriginRequestPolicy struct { } func (*awsRestxml_deserializeOpCreateOriginRequestPolicy) ID() string { return "OperationDeserializer" } func (m *awsRestxml_deserializeOpCreateOriginRequestPolicy) 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, awsRestxml_deserializeOpErrorCreateOriginRequestPolicy(response, &metadata) } output := &CreateOriginRequestPolicyOutput{} out.Result = output err = awsRestxml_deserializeOpHttpBindingsCreateOriginRequestPolicyOutput(output, response) if err != nil { return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} } 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) err = awsRestxml_deserializeDocumentOriginRequestPolicy(&output.OriginRequestPolicy, decoder) 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(), } } return out, metadata, err } func awsRestxml_deserializeOpErrorCreateOriginRequestPolicy(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("AccessDenied", errorCode): return awsRestxml_deserializeErrorAccessDenied(response, errorBody) case strings.EqualFold("InconsistentQuantities", errorCode): return awsRestxml_deserializeErrorInconsistentQuantities(response, errorBody) case strings.EqualFold("InvalidArgument", errorCode): return awsRestxml_deserializeErrorInvalidArgument(response, errorBody) case strings.EqualFold("OriginRequestPolicyAlreadyExists", errorCode): return awsRestxml_deserializeErrorOriginRequestPolicyAlreadyExists(response, errorBody) case strings.EqualFold("TooManyCookiesInOriginRequestPolicy", errorCode): return awsRestxml_deserializeErrorTooManyCookiesInOriginRequestPolicy(response, errorBody) case strings.EqualFold("TooManyHeadersInOriginRequestPolicy", errorCode): return awsRestxml_deserializeErrorTooManyHeadersInOriginRequestPolicy(response, errorBody) case strings.EqualFold("TooManyOriginRequestPolicies", errorCode): return awsRestxml_deserializeErrorTooManyOriginRequestPolicies(response, errorBody) case strings.EqualFold("TooManyQueryStringsInOriginRequestPolicy", errorCode): return awsRestxml_deserializeErrorTooManyQueryStringsInOriginRequestPolicy(response, errorBody) default: genericError := &smithy.GenericAPIError{ Code: errorCode, Message: errorMessage, } return genericError } } func awsRestxml_deserializeOpHttpBindingsCreateOriginRequestPolicyOutput(v *CreateOriginRequestPolicyOutput, response *smithyhttp.Response) error { if v == nil { return fmt.Errorf("unsupported deserialization for nil %T", v) } if headerValues := response.Header.Values("ETag"); len(headerValues) != 0 { headerValues[0] = strings.TrimSpace(headerValues[0]) v.ETag = ptr.String(headerValues[0]) } if headerValues := response.Header.Values("Location"); len(headerValues) != 0 { headerValues[0] = strings.TrimSpace(headerValues[0]) v.Location = ptr.String(headerValues[0]) } return nil } func awsRestxml_deserializeOpDocumentCreateOriginRequestPolicyOutput(v **CreateOriginRequestPolicyOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *CreateOriginRequestPolicyOutput if *v == nil { sv = &CreateOriginRequestPolicyOutput{} } 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("OriginRequestPolicy", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentOriginRequestPolicy(&sv.OriginRequestPolicy, nodeDecoder); err != nil { return err } default: // Do nothing and ignore the unexpected tag element err = decoder.Decoder.Skip() if err != nil { return err } } decoder = originalDecoder } *v = sv return nil } type awsRestxml_deserializeOpCreatePublicKey struct { } func (*awsRestxml_deserializeOpCreatePublicKey) ID() string { return "OperationDeserializer" } func (m *awsRestxml_deserializeOpCreatePublicKey) 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, awsRestxml_deserializeOpErrorCreatePublicKey(response, &metadata) } output := &CreatePublicKeyOutput{} out.Result = output err = awsRestxml_deserializeOpHttpBindingsCreatePublicKeyOutput(output, response) if err != nil { return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} } 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) err = awsRestxml_deserializeDocumentPublicKey(&output.PublicKey, decoder) 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(), } } return out, metadata, err } func awsRestxml_deserializeOpErrorCreatePublicKey(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("InvalidArgument", errorCode): return awsRestxml_deserializeErrorInvalidArgument(response, errorBody) case strings.EqualFold("PublicKeyAlreadyExists", errorCode): return awsRestxml_deserializeErrorPublicKeyAlreadyExists(response, errorBody) case strings.EqualFold("TooManyPublicKeys", errorCode): return awsRestxml_deserializeErrorTooManyPublicKeys(response, errorBody) default: genericError := &smithy.GenericAPIError{ Code: errorCode, Message: errorMessage, } return genericError } } func awsRestxml_deserializeOpHttpBindingsCreatePublicKeyOutput(v *CreatePublicKeyOutput, response *smithyhttp.Response) error { if v == nil { return fmt.Errorf("unsupported deserialization for nil %T", v) } if headerValues := response.Header.Values("ETag"); len(headerValues) != 0 { headerValues[0] = strings.TrimSpace(headerValues[0]) v.ETag = ptr.String(headerValues[0]) } if headerValues := response.Header.Values("Location"); len(headerValues) != 0 { headerValues[0] = strings.TrimSpace(headerValues[0]) v.Location = ptr.String(headerValues[0]) } return nil } func awsRestxml_deserializeOpDocumentCreatePublicKeyOutput(v **CreatePublicKeyOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *CreatePublicKeyOutput if *v == nil { sv = &CreatePublicKeyOutput{} } 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("PublicKey", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentPublicKey(&sv.PublicKey, nodeDecoder); err != nil { return err } default: // Do nothing and ignore the unexpected tag element err = decoder.Decoder.Skip() if err != nil { return err } } decoder = originalDecoder } *v = sv return nil } type awsRestxml_deserializeOpCreateRealtimeLogConfig struct { } func (*awsRestxml_deserializeOpCreateRealtimeLogConfig) ID() string { return "OperationDeserializer" } func (m *awsRestxml_deserializeOpCreateRealtimeLogConfig) 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, awsRestxml_deserializeOpErrorCreateRealtimeLogConfig(response, &metadata) } output := &CreateRealtimeLogConfigOutput{} 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) err = awsRestxml_deserializeOpDocumentCreateRealtimeLogConfigOutput(&output, decoder) 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(), } } return out, metadata, err } func awsRestxml_deserializeOpErrorCreateRealtimeLogConfig(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("AccessDenied", errorCode): return awsRestxml_deserializeErrorAccessDenied(response, errorBody) case strings.EqualFold("InvalidArgument", errorCode): return awsRestxml_deserializeErrorInvalidArgument(response, errorBody) case strings.EqualFold("RealtimeLogConfigAlreadyExists", errorCode): return awsRestxml_deserializeErrorRealtimeLogConfigAlreadyExists(response, errorBody) case strings.EqualFold("TooManyRealtimeLogConfigs", errorCode): return awsRestxml_deserializeErrorTooManyRealtimeLogConfigs(response, errorBody) default: genericError := &smithy.GenericAPIError{ Code: errorCode, Message: errorMessage, } return genericError } } func awsRestxml_deserializeOpDocumentCreateRealtimeLogConfigOutput(v **CreateRealtimeLogConfigOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *CreateRealtimeLogConfigOutput if *v == nil { sv = &CreateRealtimeLogConfigOutput{} } 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("RealtimeLogConfig", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentRealtimeLogConfig(&sv.RealtimeLogConfig, nodeDecoder); err != nil { return err } default: // Do nothing and ignore the unexpected tag element err = decoder.Decoder.Skip() if err != nil { return err } } decoder = originalDecoder } *v = sv return nil } type awsRestxml_deserializeOpCreateResponseHeadersPolicy struct { } func (*awsRestxml_deserializeOpCreateResponseHeadersPolicy) ID() string { return "OperationDeserializer" } func (m *awsRestxml_deserializeOpCreateResponseHeadersPolicy) 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, awsRestxml_deserializeOpErrorCreateResponseHeadersPolicy(response, &metadata) } output := &CreateResponseHeadersPolicyOutput{} out.Result = output err = awsRestxml_deserializeOpHttpBindingsCreateResponseHeadersPolicyOutput(output, response) if err != nil { return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} } 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) err = awsRestxml_deserializeDocumentResponseHeadersPolicy(&output.ResponseHeadersPolicy, decoder) 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(), } } return out, metadata, err } func awsRestxml_deserializeOpErrorCreateResponseHeadersPolicy(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("AccessDenied", errorCode): return awsRestxml_deserializeErrorAccessDenied(response, errorBody) case strings.EqualFold("InconsistentQuantities", errorCode): return awsRestxml_deserializeErrorInconsistentQuantities(response, errorBody) case strings.EqualFold("InvalidArgument", errorCode): return awsRestxml_deserializeErrorInvalidArgument(response, errorBody) case strings.EqualFold("ResponseHeadersPolicyAlreadyExists", errorCode): return awsRestxml_deserializeErrorResponseHeadersPolicyAlreadyExists(response, errorBody) case strings.EqualFold("TooLongCSPInResponseHeadersPolicy", errorCode): return awsRestxml_deserializeErrorTooLongCSPInResponseHeadersPolicy(response, errorBody) case strings.EqualFold("TooManyCustomHeadersInResponseHeadersPolicy", errorCode): return awsRestxml_deserializeErrorTooManyCustomHeadersInResponseHeadersPolicy(response, errorBody) case strings.EqualFold("TooManyRemoveHeadersInResponseHeadersPolicy", errorCode): return awsRestxml_deserializeErrorTooManyRemoveHeadersInResponseHeadersPolicy(response, errorBody) case strings.EqualFold("TooManyResponseHeadersPolicies", errorCode): return awsRestxml_deserializeErrorTooManyResponseHeadersPolicies(response, errorBody) default: genericError := &smithy.GenericAPIError{ Code: errorCode, Message: errorMessage, } return genericError } } func awsRestxml_deserializeOpHttpBindingsCreateResponseHeadersPolicyOutput(v *CreateResponseHeadersPolicyOutput, response *smithyhttp.Response) error { if v == nil { return fmt.Errorf("unsupported deserialization for nil %T", v) } if headerValues := response.Header.Values("ETag"); len(headerValues) != 0 { headerValues[0] = strings.TrimSpace(headerValues[0]) v.ETag = ptr.String(headerValues[0]) } if headerValues := response.Header.Values("Location"); len(headerValues) != 0 { headerValues[0] = strings.TrimSpace(headerValues[0]) v.Location = ptr.String(headerValues[0]) } return nil } func awsRestxml_deserializeOpDocumentCreateResponseHeadersPolicyOutput(v **CreateResponseHeadersPolicyOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *CreateResponseHeadersPolicyOutput if *v == nil { sv = &CreateResponseHeadersPolicyOutput{} } 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("ResponseHeadersPolicy", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentResponseHeadersPolicy(&sv.ResponseHeadersPolicy, nodeDecoder); err != nil { return err } default: // Do nothing and ignore the unexpected tag element err = decoder.Decoder.Skip() if err != nil { return err } } decoder = originalDecoder } *v = sv return nil } type awsRestxml_deserializeOpCreateStreamingDistribution struct { } func (*awsRestxml_deserializeOpCreateStreamingDistribution) ID() string { return "OperationDeserializer" } func (m *awsRestxml_deserializeOpCreateStreamingDistribution) 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, awsRestxml_deserializeOpErrorCreateStreamingDistribution(response, &metadata) } output := &CreateStreamingDistributionOutput{} out.Result = output err = awsRestxml_deserializeOpHttpBindingsCreateStreamingDistributionOutput(output, response) if err != nil { return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} } 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) err = awsRestxml_deserializeDocumentStreamingDistribution(&output.StreamingDistribution, decoder) 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(), } } return out, metadata, err } func awsRestxml_deserializeOpErrorCreateStreamingDistribution(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("AccessDenied", errorCode): return awsRestxml_deserializeErrorAccessDenied(response, errorBody) case strings.EqualFold("CNAMEAlreadyExists", errorCode): return awsRestxml_deserializeErrorCNAMEAlreadyExists(response, errorBody) case strings.EqualFold("InconsistentQuantities", errorCode): return awsRestxml_deserializeErrorInconsistentQuantities(response, errorBody) case strings.EqualFold("InvalidArgument", errorCode): return awsRestxml_deserializeErrorInvalidArgument(response, errorBody) case strings.EqualFold("InvalidOrigin", errorCode): return awsRestxml_deserializeErrorInvalidOrigin(response, errorBody) case strings.EqualFold("InvalidOriginAccessControl", errorCode): return awsRestxml_deserializeErrorInvalidOriginAccessControl(response, errorBody) case strings.EqualFold("InvalidOriginAccessIdentity", errorCode): return awsRestxml_deserializeErrorInvalidOriginAccessIdentity(response, errorBody) case strings.EqualFold("MissingBody", errorCode): return awsRestxml_deserializeErrorMissingBody(response, errorBody) case strings.EqualFold("StreamingDistributionAlreadyExists", errorCode): return awsRestxml_deserializeErrorStreamingDistributionAlreadyExists(response, errorBody) case strings.EqualFold("TooManyStreamingDistributionCNAMEs", errorCode): return awsRestxml_deserializeErrorTooManyStreamingDistributionCNAMEs(response, errorBody) case strings.EqualFold("TooManyStreamingDistributions", errorCode): return awsRestxml_deserializeErrorTooManyStreamingDistributions(response, errorBody) case strings.EqualFold("TooManyTrustedSigners", errorCode): return awsRestxml_deserializeErrorTooManyTrustedSigners(response, errorBody) case strings.EqualFold("TrustedSignerDoesNotExist", errorCode): return awsRestxml_deserializeErrorTrustedSignerDoesNotExist(response, errorBody) default: genericError := &smithy.GenericAPIError{ Code: errorCode, Message: errorMessage, } return genericError } } func awsRestxml_deserializeOpHttpBindingsCreateStreamingDistributionOutput(v *CreateStreamingDistributionOutput, response *smithyhttp.Response) error { if v == nil { return fmt.Errorf("unsupported deserialization for nil %T", v) } if headerValues := response.Header.Values("ETag"); len(headerValues) != 0 { headerValues[0] = strings.TrimSpace(headerValues[0]) v.ETag = ptr.String(headerValues[0]) } if headerValues := response.Header.Values("Location"); len(headerValues) != 0 { headerValues[0] = strings.TrimSpace(headerValues[0]) v.Location = ptr.String(headerValues[0]) } return nil } func awsRestxml_deserializeOpDocumentCreateStreamingDistributionOutput(v **CreateStreamingDistributionOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *CreateStreamingDistributionOutput if *v == nil { sv = &CreateStreamingDistributionOutput{} } 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("StreamingDistribution", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentStreamingDistribution(&sv.StreamingDistribution, nodeDecoder); err != nil { return err } default: // Do nothing and ignore the unexpected tag element err = decoder.Decoder.Skip() if err != nil { return err } } decoder = originalDecoder } *v = sv return nil } type awsRestxml_deserializeOpCreateStreamingDistributionWithTags struct { } func (*awsRestxml_deserializeOpCreateStreamingDistributionWithTags) ID() string { return "OperationDeserializer" } func (m *awsRestxml_deserializeOpCreateStreamingDistributionWithTags) 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, awsRestxml_deserializeOpErrorCreateStreamingDistributionWithTags(response, &metadata) } output := &CreateStreamingDistributionWithTagsOutput{} out.Result = output err = awsRestxml_deserializeOpHttpBindingsCreateStreamingDistributionWithTagsOutput(output, response) if err != nil { return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} } 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) err = awsRestxml_deserializeDocumentStreamingDistribution(&output.StreamingDistribution, decoder) 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(), } } return out, metadata, err } func awsRestxml_deserializeOpErrorCreateStreamingDistributionWithTags(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("AccessDenied", errorCode): return awsRestxml_deserializeErrorAccessDenied(response, errorBody) case strings.EqualFold("CNAMEAlreadyExists", errorCode): return awsRestxml_deserializeErrorCNAMEAlreadyExists(response, errorBody) case strings.EqualFold("InconsistentQuantities", errorCode): return awsRestxml_deserializeErrorInconsistentQuantities(response, errorBody) case strings.EqualFold("InvalidArgument", errorCode): return awsRestxml_deserializeErrorInvalidArgument(response, errorBody) case strings.EqualFold("InvalidOrigin", errorCode): return awsRestxml_deserializeErrorInvalidOrigin(response, errorBody) case strings.EqualFold("InvalidOriginAccessControl", errorCode): return awsRestxml_deserializeErrorInvalidOriginAccessControl(response, errorBody) case strings.EqualFold("InvalidOriginAccessIdentity", errorCode): return awsRestxml_deserializeErrorInvalidOriginAccessIdentity(response, errorBody) case strings.EqualFold("InvalidTagging", errorCode): return awsRestxml_deserializeErrorInvalidTagging(response, errorBody) case strings.EqualFold("MissingBody", errorCode): return awsRestxml_deserializeErrorMissingBody(response, errorBody) case strings.EqualFold("StreamingDistributionAlreadyExists", errorCode): return awsRestxml_deserializeErrorStreamingDistributionAlreadyExists(response, errorBody) case strings.EqualFold("TooManyStreamingDistributionCNAMEs", errorCode): return awsRestxml_deserializeErrorTooManyStreamingDistributionCNAMEs(response, errorBody) case strings.EqualFold("TooManyStreamingDistributions", errorCode): return awsRestxml_deserializeErrorTooManyStreamingDistributions(response, errorBody) case strings.EqualFold("TooManyTrustedSigners", errorCode): return awsRestxml_deserializeErrorTooManyTrustedSigners(response, errorBody) case strings.EqualFold("TrustedSignerDoesNotExist", errorCode): return awsRestxml_deserializeErrorTrustedSignerDoesNotExist(response, errorBody) default: genericError := &smithy.GenericAPIError{ Code: errorCode, Message: errorMessage, } return genericError } } func awsRestxml_deserializeOpHttpBindingsCreateStreamingDistributionWithTagsOutput(v *CreateStreamingDistributionWithTagsOutput, response *smithyhttp.Response) error { if v == nil { return fmt.Errorf("unsupported deserialization for nil %T", v) } if headerValues := response.Header.Values("ETag"); len(headerValues) != 0 { headerValues[0] = strings.TrimSpace(headerValues[0]) v.ETag = ptr.String(headerValues[0]) } if headerValues := response.Header.Values("Location"); len(headerValues) != 0 { headerValues[0] = strings.TrimSpace(headerValues[0]) v.Location = ptr.String(headerValues[0]) } return nil } func awsRestxml_deserializeOpDocumentCreateStreamingDistributionWithTagsOutput(v **CreateStreamingDistributionWithTagsOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *CreateStreamingDistributionWithTagsOutput if *v == nil { sv = &CreateStreamingDistributionWithTagsOutput{} } 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("StreamingDistribution", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentStreamingDistribution(&sv.StreamingDistribution, nodeDecoder); err != nil { return err } default: // Do nothing and ignore the unexpected tag element err = decoder.Decoder.Skip() if err != nil { return err } } decoder = originalDecoder } *v = sv return nil } type awsRestxml_deserializeOpDeleteCachePolicy struct { } func (*awsRestxml_deserializeOpDeleteCachePolicy) ID() string { return "OperationDeserializer" } func (m *awsRestxml_deserializeOpDeleteCachePolicy) 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, awsRestxml_deserializeOpErrorDeleteCachePolicy(response, &metadata) } output := &DeleteCachePolicyOutput{} 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 awsRestxml_deserializeOpErrorDeleteCachePolicy(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("AccessDenied", errorCode): return awsRestxml_deserializeErrorAccessDenied(response, errorBody) case strings.EqualFold("CachePolicyInUse", errorCode): return awsRestxml_deserializeErrorCachePolicyInUse(response, errorBody) case strings.EqualFold("IllegalDelete", errorCode): return awsRestxml_deserializeErrorIllegalDelete(response, errorBody) case strings.EqualFold("InvalidIfMatchVersion", errorCode): return awsRestxml_deserializeErrorInvalidIfMatchVersion(response, errorBody) case strings.EqualFold("NoSuchCachePolicy", errorCode): return awsRestxml_deserializeErrorNoSuchCachePolicy(response, errorBody) case strings.EqualFold("PreconditionFailed", errorCode): return awsRestxml_deserializeErrorPreconditionFailed(response, errorBody) default: genericError := &smithy.GenericAPIError{ Code: errorCode, Message: errorMessage, } return genericError } } type awsRestxml_deserializeOpDeleteCloudFrontOriginAccessIdentity struct { } func (*awsRestxml_deserializeOpDeleteCloudFrontOriginAccessIdentity) ID() string { return "OperationDeserializer" } func (m *awsRestxml_deserializeOpDeleteCloudFrontOriginAccessIdentity) 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, awsRestxml_deserializeOpErrorDeleteCloudFrontOriginAccessIdentity(response, &metadata) } output := &DeleteCloudFrontOriginAccessIdentityOutput{} 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 awsRestxml_deserializeOpErrorDeleteCloudFrontOriginAccessIdentity(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("AccessDenied", errorCode): return awsRestxml_deserializeErrorAccessDenied(response, errorBody) case strings.EqualFold("CloudFrontOriginAccessIdentityInUse", errorCode): return awsRestxml_deserializeErrorCloudFrontOriginAccessIdentityInUse(response, errorBody) case strings.EqualFold("InvalidIfMatchVersion", errorCode): return awsRestxml_deserializeErrorInvalidIfMatchVersion(response, errorBody) case strings.EqualFold("NoSuchCloudFrontOriginAccessIdentity", errorCode): return awsRestxml_deserializeErrorNoSuchCloudFrontOriginAccessIdentity(response, errorBody) case strings.EqualFold("PreconditionFailed", errorCode): return awsRestxml_deserializeErrorPreconditionFailed(response, errorBody) default: genericError := &smithy.GenericAPIError{ Code: errorCode, Message: errorMessage, } return genericError } } type awsRestxml_deserializeOpDeleteContinuousDeploymentPolicy struct { } func (*awsRestxml_deserializeOpDeleteContinuousDeploymentPolicy) ID() string { return "OperationDeserializer" } func (m *awsRestxml_deserializeOpDeleteContinuousDeploymentPolicy) 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, awsRestxml_deserializeOpErrorDeleteContinuousDeploymentPolicy(response, &metadata) } output := &DeleteContinuousDeploymentPolicyOutput{} 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 awsRestxml_deserializeOpErrorDeleteContinuousDeploymentPolicy(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("AccessDenied", errorCode): return awsRestxml_deserializeErrorAccessDenied(response, errorBody) case strings.EqualFold("ContinuousDeploymentPolicyInUse", errorCode): return awsRestxml_deserializeErrorContinuousDeploymentPolicyInUse(response, errorBody) case strings.EqualFold("InvalidArgument", errorCode): return awsRestxml_deserializeErrorInvalidArgument(response, errorBody) case strings.EqualFold("InvalidIfMatchVersion", errorCode): return awsRestxml_deserializeErrorInvalidIfMatchVersion(response, errorBody) case strings.EqualFold("NoSuchContinuousDeploymentPolicy", errorCode): return awsRestxml_deserializeErrorNoSuchContinuousDeploymentPolicy(response, errorBody) case strings.EqualFold("PreconditionFailed", errorCode): return awsRestxml_deserializeErrorPreconditionFailed(response, errorBody) default: genericError := &smithy.GenericAPIError{ Code: errorCode, Message: errorMessage, } return genericError } } type awsRestxml_deserializeOpDeleteDistribution struct { } func (*awsRestxml_deserializeOpDeleteDistribution) ID() string { return "OperationDeserializer" } func (m *awsRestxml_deserializeOpDeleteDistribution) 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, awsRestxml_deserializeOpErrorDeleteDistribution(response, &metadata) } output := &DeleteDistributionOutput{} 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 awsRestxml_deserializeOpErrorDeleteDistribution(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("AccessDenied", errorCode): return awsRestxml_deserializeErrorAccessDenied(response, errorBody) case strings.EqualFold("DistributionNotDisabled", errorCode): return awsRestxml_deserializeErrorDistributionNotDisabled(response, errorBody) case strings.EqualFold("InvalidIfMatchVersion", errorCode): return awsRestxml_deserializeErrorInvalidIfMatchVersion(response, errorBody) case strings.EqualFold("NoSuchDistribution", errorCode): return awsRestxml_deserializeErrorNoSuchDistribution(response, errorBody) case strings.EqualFold("PreconditionFailed", errorCode): return awsRestxml_deserializeErrorPreconditionFailed(response, errorBody) default: genericError := &smithy.GenericAPIError{ Code: errorCode, Message: errorMessage, } return genericError } } type awsRestxml_deserializeOpDeleteFieldLevelEncryptionConfig struct { } func (*awsRestxml_deserializeOpDeleteFieldLevelEncryptionConfig) ID() string { return "OperationDeserializer" } func (m *awsRestxml_deserializeOpDeleteFieldLevelEncryptionConfig) 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, awsRestxml_deserializeOpErrorDeleteFieldLevelEncryptionConfig(response, &metadata) } output := &DeleteFieldLevelEncryptionConfigOutput{} 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 awsRestxml_deserializeOpErrorDeleteFieldLevelEncryptionConfig(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("AccessDenied", errorCode): return awsRestxml_deserializeErrorAccessDenied(response, errorBody) case strings.EqualFold("FieldLevelEncryptionConfigInUse", errorCode): return awsRestxml_deserializeErrorFieldLevelEncryptionConfigInUse(response, errorBody) case strings.EqualFold("InvalidIfMatchVersion", errorCode): return awsRestxml_deserializeErrorInvalidIfMatchVersion(response, errorBody) case strings.EqualFold("NoSuchFieldLevelEncryptionConfig", errorCode): return awsRestxml_deserializeErrorNoSuchFieldLevelEncryptionConfig(response, errorBody) case strings.EqualFold("PreconditionFailed", errorCode): return awsRestxml_deserializeErrorPreconditionFailed(response, errorBody) default: genericError := &smithy.GenericAPIError{ Code: errorCode, Message: errorMessage, } return genericError } } type awsRestxml_deserializeOpDeleteFieldLevelEncryptionProfile struct { } func (*awsRestxml_deserializeOpDeleteFieldLevelEncryptionProfile) ID() string { return "OperationDeserializer" } func (m *awsRestxml_deserializeOpDeleteFieldLevelEncryptionProfile) 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, awsRestxml_deserializeOpErrorDeleteFieldLevelEncryptionProfile(response, &metadata) } output := &DeleteFieldLevelEncryptionProfileOutput{} 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 awsRestxml_deserializeOpErrorDeleteFieldLevelEncryptionProfile(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("AccessDenied", errorCode): return awsRestxml_deserializeErrorAccessDenied(response, errorBody) case strings.EqualFold("FieldLevelEncryptionProfileInUse", errorCode): return awsRestxml_deserializeErrorFieldLevelEncryptionProfileInUse(response, errorBody) case strings.EqualFold("InvalidIfMatchVersion", errorCode): return awsRestxml_deserializeErrorInvalidIfMatchVersion(response, errorBody) case strings.EqualFold("NoSuchFieldLevelEncryptionProfile", errorCode): return awsRestxml_deserializeErrorNoSuchFieldLevelEncryptionProfile(response, errorBody) case strings.EqualFold("PreconditionFailed", errorCode): return awsRestxml_deserializeErrorPreconditionFailed(response, errorBody) default: genericError := &smithy.GenericAPIError{ Code: errorCode, Message: errorMessage, } return genericError } } type awsRestxml_deserializeOpDeleteFunction struct { } func (*awsRestxml_deserializeOpDeleteFunction) ID() string { return "OperationDeserializer" } func (m *awsRestxml_deserializeOpDeleteFunction) 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, awsRestxml_deserializeOpErrorDeleteFunction(response, &metadata) } output := &DeleteFunctionOutput{} 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 awsRestxml_deserializeOpErrorDeleteFunction(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("FunctionInUse", errorCode): return awsRestxml_deserializeErrorFunctionInUse(response, errorBody) case strings.EqualFold("InvalidIfMatchVersion", errorCode): return awsRestxml_deserializeErrorInvalidIfMatchVersion(response, errorBody) case strings.EqualFold("NoSuchFunctionExists", errorCode): return awsRestxml_deserializeErrorNoSuchFunctionExists(response, errorBody) case strings.EqualFold("PreconditionFailed", errorCode): return awsRestxml_deserializeErrorPreconditionFailed(response, errorBody) case strings.EqualFold("UnsupportedOperation", errorCode): return awsRestxml_deserializeErrorUnsupportedOperation(response, errorBody) default: genericError := &smithy.GenericAPIError{ Code: errorCode, Message: errorMessage, } return genericError } } type awsRestxml_deserializeOpDeleteKeyGroup struct { } func (*awsRestxml_deserializeOpDeleteKeyGroup) ID() string { return "OperationDeserializer" } func (m *awsRestxml_deserializeOpDeleteKeyGroup) 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, awsRestxml_deserializeOpErrorDeleteKeyGroup(response, &metadata) } output := &DeleteKeyGroupOutput{} 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 awsRestxml_deserializeOpErrorDeleteKeyGroup(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("InvalidIfMatchVersion", errorCode): return awsRestxml_deserializeErrorInvalidIfMatchVersion(response, errorBody) case strings.EqualFold("NoSuchResource", errorCode): return awsRestxml_deserializeErrorNoSuchResource(response, errorBody) case strings.EqualFold("PreconditionFailed", errorCode): return awsRestxml_deserializeErrorPreconditionFailed(response, errorBody) case strings.EqualFold("ResourceInUse", errorCode): return awsRestxml_deserializeErrorResourceInUse(response, errorBody) default: genericError := &smithy.GenericAPIError{ Code: errorCode, Message: errorMessage, } return genericError } } type awsRestxml_deserializeOpDeleteMonitoringSubscription struct { } func (*awsRestxml_deserializeOpDeleteMonitoringSubscription) ID() string { return "OperationDeserializer" } func (m *awsRestxml_deserializeOpDeleteMonitoringSubscription) 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, awsRestxml_deserializeOpErrorDeleteMonitoringSubscription(response, &metadata) } output := &DeleteMonitoringSubscriptionOutput{} out.Result = output return out, metadata, err } func awsRestxml_deserializeOpErrorDeleteMonitoringSubscription(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("AccessDenied", errorCode): return awsRestxml_deserializeErrorAccessDenied(response, errorBody) case strings.EqualFold("NoSuchDistribution", errorCode): return awsRestxml_deserializeErrorNoSuchDistribution(response, errorBody) case strings.EqualFold("NoSuchMonitoringSubscription", errorCode): return awsRestxml_deserializeErrorNoSuchMonitoringSubscription(response, errorBody) case strings.EqualFold("UnsupportedOperation", errorCode): return awsRestxml_deserializeErrorUnsupportedOperation(response, errorBody) default: genericError := &smithy.GenericAPIError{ Code: errorCode, Message: errorMessage, } return genericError } } type awsRestxml_deserializeOpDeleteOriginAccessControl struct { } func (*awsRestxml_deserializeOpDeleteOriginAccessControl) ID() string { return "OperationDeserializer" } func (m *awsRestxml_deserializeOpDeleteOriginAccessControl) 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, awsRestxml_deserializeOpErrorDeleteOriginAccessControl(response, &metadata) } output := &DeleteOriginAccessControlOutput{} 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 awsRestxml_deserializeOpErrorDeleteOriginAccessControl(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("AccessDenied", errorCode): return awsRestxml_deserializeErrorAccessDenied(response, errorBody) case strings.EqualFold("InvalidIfMatchVersion", errorCode): return awsRestxml_deserializeErrorInvalidIfMatchVersion(response, errorBody) case strings.EqualFold("NoSuchOriginAccessControl", errorCode): return awsRestxml_deserializeErrorNoSuchOriginAccessControl(response, errorBody) case strings.EqualFold("OriginAccessControlInUse", errorCode): return awsRestxml_deserializeErrorOriginAccessControlInUse(response, errorBody) case strings.EqualFold("PreconditionFailed", errorCode): return awsRestxml_deserializeErrorPreconditionFailed(response, errorBody) default: genericError := &smithy.GenericAPIError{ Code: errorCode, Message: errorMessage, } return genericError } } type awsRestxml_deserializeOpDeleteOriginRequestPolicy struct { } func (*awsRestxml_deserializeOpDeleteOriginRequestPolicy) ID() string { return "OperationDeserializer" } func (m *awsRestxml_deserializeOpDeleteOriginRequestPolicy) 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, awsRestxml_deserializeOpErrorDeleteOriginRequestPolicy(response, &metadata) } output := &DeleteOriginRequestPolicyOutput{} 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 awsRestxml_deserializeOpErrorDeleteOriginRequestPolicy(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("AccessDenied", errorCode): return awsRestxml_deserializeErrorAccessDenied(response, errorBody) case strings.EqualFold("IllegalDelete", errorCode): return awsRestxml_deserializeErrorIllegalDelete(response, errorBody) case strings.EqualFold("InvalidIfMatchVersion", errorCode): return awsRestxml_deserializeErrorInvalidIfMatchVersion(response, errorBody) case strings.EqualFold("NoSuchOriginRequestPolicy", errorCode): return awsRestxml_deserializeErrorNoSuchOriginRequestPolicy(response, errorBody) case strings.EqualFold("OriginRequestPolicyInUse", errorCode): return awsRestxml_deserializeErrorOriginRequestPolicyInUse(response, errorBody) case strings.EqualFold("PreconditionFailed", errorCode): return awsRestxml_deserializeErrorPreconditionFailed(response, errorBody) default: genericError := &smithy.GenericAPIError{ Code: errorCode, Message: errorMessage, } return genericError } } type awsRestxml_deserializeOpDeletePublicKey struct { } func (*awsRestxml_deserializeOpDeletePublicKey) ID() string { return "OperationDeserializer" } func (m *awsRestxml_deserializeOpDeletePublicKey) 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, awsRestxml_deserializeOpErrorDeletePublicKey(response, &metadata) } output := &DeletePublicKeyOutput{} 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 awsRestxml_deserializeOpErrorDeletePublicKey(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("AccessDenied", errorCode): return awsRestxml_deserializeErrorAccessDenied(response, errorBody) case strings.EqualFold("InvalidIfMatchVersion", errorCode): return awsRestxml_deserializeErrorInvalidIfMatchVersion(response, errorBody) case strings.EqualFold("NoSuchPublicKey", errorCode): return awsRestxml_deserializeErrorNoSuchPublicKey(response, errorBody) case strings.EqualFold("PreconditionFailed", errorCode): return awsRestxml_deserializeErrorPreconditionFailed(response, errorBody) case strings.EqualFold("PublicKeyInUse", errorCode): return awsRestxml_deserializeErrorPublicKeyInUse(response, errorBody) default: genericError := &smithy.GenericAPIError{ Code: errorCode, Message: errorMessage, } return genericError } } type awsRestxml_deserializeOpDeleteRealtimeLogConfig struct { } func (*awsRestxml_deserializeOpDeleteRealtimeLogConfig) ID() string { return "OperationDeserializer" } func (m *awsRestxml_deserializeOpDeleteRealtimeLogConfig) 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, awsRestxml_deserializeOpErrorDeleteRealtimeLogConfig(response, &metadata) } output := &DeleteRealtimeLogConfigOutput{} 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 awsRestxml_deserializeOpErrorDeleteRealtimeLogConfig(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("AccessDenied", errorCode): return awsRestxml_deserializeErrorAccessDenied(response, errorBody) case strings.EqualFold("InvalidArgument", errorCode): return awsRestxml_deserializeErrorInvalidArgument(response, errorBody) case strings.EqualFold("NoSuchRealtimeLogConfig", errorCode): return awsRestxml_deserializeErrorNoSuchRealtimeLogConfig(response, errorBody) case strings.EqualFold("RealtimeLogConfigInUse", errorCode): return awsRestxml_deserializeErrorRealtimeLogConfigInUse(response, errorBody) default: genericError := &smithy.GenericAPIError{ Code: errorCode, Message: errorMessage, } return genericError } } type awsRestxml_deserializeOpDeleteResponseHeadersPolicy struct { } func (*awsRestxml_deserializeOpDeleteResponseHeadersPolicy) ID() string { return "OperationDeserializer" } func (m *awsRestxml_deserializeOpDeleteResponseHeadersPolicy) 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, awsRestxml_deserializeOpErrorDeleteResponseHeadersPolicy(response, &metadata) } output := &DeleteResponseHeadersPolicyOutput{} 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 awsRestxml_deserializeOpErrorDeleteResponseHeadersPolicy(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("AccessDenied", errorCode): return awsRestxml_deserializeErrorAccessDenied(response, errorBody) case strings.EqualFold("IllegalDelete", errorCode): return awsRestxml_deserializeErrorIllegalDelete(response, errorBody) case strings.EqualFold("InvalidIfMatchVersion", errorCode): return awsRestxml_deserializeErrorInvalidIfMatchVersion(response, errorBody) case strings.EqualFold("NoSuchResponseHeadersPolicy", errorCode): return awsRestxml_deserializeErrorNoSuchResponseHeadersPolicy(response, errorBody) case strings.EqualFold("PreconditionFailed", errorCode): return awsRestxml_deserializeErrorPreconditionFailed(response, errorBody) case strings.EqualFold("ResponseHeadersPolicyInUse", errorCode): return awsRestxml_deserializeErrorResponseHeadersPolicyInUse(response, errorBody) default: genericError := &smithy.GenericAPIError{ Code: errorCode, Message: errorMessage, } return genericError } } type awsRestxml_deserializeOpDeleteStreamingDistribution struct { } func (*awsRestxml_deserializeOpDeleteStreamingDistribution) ID() string { return "OperationDeserializer" } func (m *awsRestxml_deserializeOpDeleteStreamingDistribution) 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, awsRestxml_deserializeOpErrorDeleteStreamingDistribution(response, &metadata) } output := &DeleteStreamingDistributionOutput{} 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 awsRestxml_deserializeOpErrorDeleteStreamingDistribution(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("AccessDenied", errorCode): return awsRestxml_deserializeErrorAccessDenied(response, errorBody) case strings.EqualFold("InvalidIfMatchVersion", errorCode): return awsRestxml_deserializeErrorInvalidIfMatchVersion(response, errorBody) case strings.EqualFold("NoSuchStreamingDistribution", errorCode): return awsRestxml_deserializeErrorNoSuchStreamingDistribution(response, errorBody) case strings.EqualFold("PreconditionFailed", errorCode): return awsRestxml_deserializeErrorPreconditionFailed(response, errorBody) case strings.EqualFold("StreamingDistributionNotDisabled", errorCode): return awsRestxml_deserializeErrorStreamingDistributionNotDisabled(response, errorBody) default: genericError := &smithy.GenericAPIError{ Code: errorCode, Message: errorMessage, } return genericError } } type awsRestxml_deserializeOpDescribeFunction struct { } func (*awsRestxml_deserializeOpDescribeFunction) ID() string { return "OperationDeserializer" } func (m *awsRestxml_deserializeOpDescribeFunction) 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, awsRestxml_deserializeOpErrorDescribeFunction(response, &metadata) } output := &DescribeFunctionOutput{} out.Result = output err = awsRestxml_deserializeOpHttpBindingsDescribeFunctionOutput(output, response) if err != nil { return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} } 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) err = awsRestxml_deserializeDocumentFunctionSummary(&output.FunctionSummary, decoder) 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(), } } return out, metadata, err } func awsRestxml_deserializeOpErrorDescribeFunction(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("NoSuchFunctionExists", errorCode): return awsRestxml_deserializeErrorNoSuchFunctionExists(response, errorBody) case strings.EqualFold("UnsupportedOperation", errorCode): return awsRestxml_deserializeErrorUnsupportedOperation(response, errorBody) default: genericError := &smithy.GenericAPIError{ Code: errorCode, Message: errorMessage, } return genericError } } func awsRestxml_deserializeOpHttpBindingsDescribeFunctionOutput(v *DescribeFunctionOutput, response *smithyhttp.Response) error { if v == nil { return fmt.Errorf("unsupported deserialization for nil %T", v) } if headerValues := response.Header.Values("ETag"); len(headerValues) != 0 { headerValues[0] = strings.TrimSpace(headerValues[0]) v.ETag = ptr.String(headerValues[0]) } return nil } func awsRestxml_deserializeOpDocumentDescribeFunctionOutput(v **DescribeFunctionOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *DescribeFunctionOutput if *v == nil { sv = &DescribeFunctionOutput{} } 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("FunctionSummary", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentFunctionSummary(&sv.FunctionSummary, nodeDecoder); err != nil { return err } default: // Do nothing and ignore the unexpected tag element err = decoder.Decoder.Skip() if err != nil { return err } } decoder = originalDecoder } *v = sv return nil } type awsRestxml_deserializeOpGetCachePolicy struct { } func (*awsRestxml_deserializeOpGetCachePolicy) ID() string { return "OperationDeserializer" } func (m *awsRestxml_deserializeOpGetCachePolicy) 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, awsRestxml_deserializeOpErrorGetCachePolicy(response, &metadata) } output := &GetCachePolicyOutput{} out.Result = output err = awsRestxml_deserializeOpHttpBindingsGetCachePolicyOutput(output, response) if err != nil { return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} } 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) err = awsRestxml_deserializeDocumentCachePolicy(&output.CachePolicy, decoder) 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(), } } return out, metadata, err } func awsRestxml_deserializeOpErrorGetCachePolicy(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("AccessDenied", errorCode): return awsRestxml_deserializeErrorAccessDenied(response, errorBody) case strings.EqualFold("NoSuchCachePolicy", errorCode): return awsRestxml_deserializeErrorNoSuchCachePolicy(response, errorBody) default: genericError := &smithy.GenericAPIError{ Code: errorCode, Message: errorMessage, } return genericError } } func awsRestxml_deserializeOpHttpBindingsGetCachePolicyOutput(v *GetCachePolicyOutput, response *smithyhttp.Response) error { if v == nil { return fmt.Errorf("unsupported deserialization for nil %T", v) } if headerValues := response.Header.Values("ETag"); len(headerValues) != 0 { headerValues[0] = strings.TrimSpace(headerValues[0]) v.ETag = ptr.String(headerValues[0]) } return nil } func awsRestxml_deserializeOpDocumentGetCachePolicyOutput(v **GetCachePolicyOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *GetCachePolicyOutput if *v == nil { sv = &GetCachePolicyOutput{} } 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("CachePolicy", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentCachePolicy(&sv.CachePolicy, nodeDecoder); err != nil { return err } default: // Do nothing and ignore the unexpected tag element err = decoder.Decoder.Skip() if err != nil { return err } } decoder = originalDecoder } *v = sv return nil } type awsRestxml_deserializeOpGetCachePolicyConfig struct { } func (*awsRestxml_deserializeOpGetCachePolicyConfig) ID() string { return "OperationDeserializer" } func (m *awsRestxml_deserializeOpGetCachePolicyConfig) 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, awsRestxml_deserializeOpErrorGetCachePolicyConfig(response, &metadata) } output := &GetCachePolicyConfigOutput{} out.Result = output err = awsRestxml_deserializeOpHttpBindingsGetCachePolicyConfigOutput(output, response) if err != nil { return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} } 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) err = awsRestxml_deserializeDocumentCachePolicyConfig(&output.CachePolicyConfig, decoder) 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(), } } return out, metadata, err } func awsRestxml_deserializeOpErrorGetCachePolicyConfig(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("AccessDenied", errorCode): return awsRestxml_deserializeErrorAccessDenied(response, errorBody) case strings.EqualFold("NoSuchCachePolicy", errorCode): return awsRestxml_deserializeErrorNoSuchCachePolicy(response, errorBody) default: genericError := &smithy.GenericAPIError{ Code: errorCode, Message: errorMessage, } return genericError } } func awsRestxml_deserializeOpHttpBindingsGetCachePolicyConfigOutput(v *GetCachePolicyConfigOutput, response *smithyhttp.Response) error { if v == nil { return fmt.Errorf("unsupported deserialization for nil %T", v) } if headerValues := response.Header.Values("ETag"); len(headerValues) != 0 { headerValues[0] = strings.TrimSpace(headerValues[0]) v.ETag = ptr.String(headerValues[0]) } return nil } func awsRestxml_deserializeOpDocumentGetCachePolicyConfigOutput(v **GetCachePolicyConfigOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *GetCachePolicyConfigOutput if *v == nil { sv = &GetCachePolicyConfigOutput{} } 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("CachePolicyConfig", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentCachePolicyConfig(&sv.CachePolicyConfig, nodeDecoder); err != nil { return err } default: // Do nothing and ignore the unexpected tag element err = decoder.Decoder.Skip() if err != nil { return err } } decoder = originalDecoder } *v = sv return nil } type awsRestxml_deserializeOpGetCloudFrontOriginAccessIdentity struct { } func (*awsRestxml_deserializeOpGetCloudFrontOriginAccessIdentity) ID() string { return "OperationDeserializer" } func (m *awsRestxml_deserializeOpGetCloudFrontOriginAccessIdentity) 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, awsRestxml_deserializeOpErrorGetCloudFrontOriginAccessIdentity(response, &metadata) } output := &GetCloudFrontOriginAccessIdentityOutput{} out.Result = output err = awsRestxml_deserializeOpHttpBindingsGetCloudFrontOriginAccessIdentityOutput(output, response) if err != nil { return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} } 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) err = awsRestxml_deserializeDocumentCloudFrontOriginAccessIdentity(&output.CloudFrontOriginAccessIdentity, decoder) 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(), } } return out, metadata, err } func awsRestxml_deserializeOpErrorGetCloudFrontOriginAccessIdentity(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("AccessDenied", errorCode): return awsRestxml_deserializeErrorAccessDenied(response, errorBody) case strings.EqualFold("NoSuchCloudFrontOriginAccessIdentity", errorCode): return awsRestxml_deserializeErrorNoSuchCloudFrontOriginAccessIdentity(response, errorBody) default: genericError := &smithy.GenericAPIError{ Code: errorCode, Message: errorMessage, } return genericError } } func awsRestxml_deserializeOpHttpBindingsGetCloudFrontOriginAccessIdentityOutput(v *GetCloudFrontOriginAccessIdentityOutput, response *smithyhttp.Response) error { if v == nil { return fmt.Errorf("unsupported deserialization for nil %T", v) } if headerValues := response.Header.Values("ETag"); len(headerValues) != 0 { headerValues[0] = strings.TrimSpace(headerValues[0]) v.ETag = ptr.String(headerValues[0]) } return nil } func awsRestxml_deserializeOpDocumentGetCloudFrontOriginAccessIdentityOutput(v **GetCloudFrontOriginAccessIdentityOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *GetCloudFrontOriginAccessIdentityOutput if *v == nil { sv = &GetCloudFrontOriginAccessIdentityOutput{} } 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("CloudFrontOriginAccessIdentity", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentCloudFrontOriginAccessIdentity(&sv.CloudFrontOriginAccessIdentity, nodeDecoder); err != nil { return err } default: // Do nothing and ignore the unexpected tag element err = decoder.Decoder.Skip() if err != nil { return err } } decoder = originalDecoder } *v = sv return nil } type awsRestxml_deserializeOpGetCloudFrontOriginAccessIdentityConfig struct { } func (*awsRestxml_deserializeOpGetCloudFrontOriginAccessIdentityConfig) ID() string { return "OperationDeserializer" } func (m *awsRestxml_deserializeOpGetCloudFrontOriginAccessIdentityConfig) 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, awsRestxml_deserializeOpErrorGetCloudFrontOriginAccessIdentityConfig(response, &metadata) } output := &GetCloudFrontOriginAccessIdentityConfigOutput{} out.Result = output err = awsRestxml_deserializeOpHttpBindingsGetCloudFrontOriginAccessIdentityConfigOutput(output, response) if err != nil { return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} } 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) err = awsRestxml_deserializeDocumentCloudFrontOriginAccessIdentityConfig(&output.CloudFrontOriginAccessIdentityConfig, decoder) 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(), } } return out, metadata, err } func awsRestxml_deserializeOpErrorGetCloudFrontOriginAccessIdentityConfig(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("AccessDenied", errorCode): return awsRestxml_deserializeErrorAccessDenied(response, errorBody) case strings.EqualFold("NoSuchCloudFrontOriginAccessIdentity", errorCode): return awsRestxml_deserializeErrorNoSuchCloudFrontOriginAccessIdentity(response, errorBody) default: genericError := &smithy.GenericAPIError{ Code: errorCode, Message: errorMessage, } return genericError } } func awsRestxml_deserializeOpHttpBindingsGetCloudFrontOriginAccessIdentityConfigOutput(v *GetCloudFrontOriginAccessIdentityConfigOutput, response *smithyhttp.Response) error { if v == nil { return fmt.Errorf("unsupported deserialization for nil %T", v) } if headerValues := response.Header.Values("ETag"); len(headerValues) != 0 { headerValues[0] = strings.TrimSpace(headerValues[0]) v.ETag = ptr.String(headerValues[0]) } return nil } func awsRestxml_deserializeOpDocumentGetCloudFrontOriginAccessIdentityConfigOutput(v **GetCloudFrontOriginAccessIdentityConfigOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *GetCloudFrontOriginAccessIdentityConfigOutput if *v == nil { sv = &GetCloudFrontOriginAccessIdentityConfigOutput{} } 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("CloudFrontOriginAccessIdentityConfig", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentCloudFrontOriginAccessIdentityConfig(&sv.CloudFrontOriginAccessIdentityConfig, nodeDecoder); err != nil { return err } default: // Do nothing and ignore the unexpected tag element err = decoder.Decoder.Skip() if err != nil { return err } } decoder = originalDecoder } *v = sv return nil } type awsRestxml_deserializeOpGetContinuousDeploymentPolicy struct { } func (*awsRestxml_deserializeOpGetContinuousDeploymentPolicy) ID() string { return "OperationDeserializer" } func (m *awsRestxml_deserializeOpGetContinuousDeploymentPolicy) 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, awsRestxml_deserializeOpErrorGetContinuousDeploymentPolicy(response, &metadata) } output := &GetContinuousDeploymentPolicyOutput{} out.Result = output err = awsRestxml_deserializeOpHttpBindingsGetContinuousDeploymentPolicyOutput(output, response) if err != nil { return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} } 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) err = awsRestxml_deserializeDocumentContinuousDeploymentPolicy(&output.ContinuousDeploymentPolicy, decoder) 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(), } } return out, metadata, err } func awsRestxml_deserializeOpErrorGetContinuousDeploymentPolicy(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("AccessDenied", errorCode): return awsRestxml_deserializeErrorAccessDenied(response, errorBody) case strings.EqualFold("NoSuchContinuousDeploymentPolicy", errorCode): return awsRestxml_deserializeErrorNoSuchContinuousDeploymentPolicy(response, errorBody) default: genericError := &smithy.GenericAPIError{ Code: errorCode, Message: errorMessage, } return genericError } } func awsRestxml_deserializeOpHttpBindingsGetContinuousDeploymentPolicyOutput(v *GetContinuousDeploymentPolicyOutput, response *smithyhttp.Response) error { if v == nil { return fmt.Errorf("unsupported deserialization for nil %T", v) } if headerValues := response.Header.Values("ETag"); len(headerValues) != 0 { headerValues[0] = strings.TrimSpace(headerValues[0]) v.ETag = ptr.String(headerValues[0]) } return nil } func awsRestxml_deserializeOpDocumentGetContinuousDeploymentPolicyOutput(v **GetContinuousDeploymentPolicyOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *GetContinuousDeploymentPolicyOutput if *v == nil { sv = &GetContinuousDeploymentPolicyOutput{} } 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("ContinuousDeploymentPolicy", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentContinuousDeploymentPolicy(&sv.ContinuousDeploymentPolicy, nodeDecoder); err != nil { return err } default: // Do nothing and ignore the unexpected tag element err = decoder.Decoder.Skip() if err != nil { return err } } decoder = originalDecoder } *v = sv return nil } type awsRestxml_deserializeOpGetContinuousDeploymentPolicyConfig struct { } func (*awsRestxml_deserializeOpGetContinuousDeploymentPolicyConfig) ID() string { return "OperationDeserializer" } func (m *awsRestxml_deserializeOpGetContinuousDeploymentPolicyConfig) 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, awsRestxml_deserializeOpErrorGetContinuousDeploymentPolicyConfig(response, &metadata) } output := &GetContinuousDeploymentPolicyConfigOutput{} out.Result = output err = awsRestxml_deserializeOpHttpBindingsGetContinuousDeploymentPolicyConfigOutput(output, response) if err != nil { return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} } 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) err = awsRestxml_deserializeDocumentContinuousDeploymentPolicyConfig(&output.ContinuousDeploymentPolicyConfig, decoder) 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(), } } return out, metadata, err } func awsRestxml_deserializeOpErrorGetContinuousDeploymentPolicyConfig(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("AccessDenied", errorCode): return awsRestxml_deserializeErrorAccessDenied(response, errorBody) case strings.EqualFold("NoSuchContinuousDeploymentPolicy", errorCode): return awsRestxml_deserializeErrorNoSuchContinuousDeploymentPolicy(response, errorBody) default: genericError := &smithy.GenericAPIError{ Code: errorCode, Message: errorMessage, } return genericError } } func awsRestxml_deserializeOpHttpBindingsGetContinuousDeploymentPolicyConfigOutput(v *GetContinuousDeploymentPolicyConfigOutput, response *smithyhttp.Response) error { if v == nil { return fmt.Errorf("unsupported deserialization for nil %T", v) } if headerValues := response.Header.Values("ETag"); len(headerValues) != 0 { headerValues[0] = strings.TrimSpace(headerValues[0]) v.ETag = ptr.String(headerValues[0]) } return nil } func awsRestxml_deserializeOpDocumentGetContinuousDeploymentPolicyConfigOutput(v **GetContinuousDeploymentPolicyConfigOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *GetContinuousDeploymentPolicyConfigOutput if *v == nil { sv = &GetContinuousDeploymentPolicyConfigOutput{} } 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("ContinuousDeploymentPolicyConfig", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentContinuousDeploymentPolicyConfig(&sv.ContinuousDeploymentPolicyConfig, nodeDecoder); err != nil { return err } default: // Do nothing and ignore the unexpected tag element err = decoder.Decoder.Skip() if err != nil { return err } } decoder = originalDecoder } *v = sv return nil } type awsRestxml_deserializeOpGetDistribution struct { } func (*awsRestxml_deserializeOpGetDistribution) ID() string { return "OperationDeserializer" } func (m *awsRestxml_deserializeOpGetDistribution) 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, awsRestxml_deserializeOpErrorGetDistribution(response, &metadata) } output := &GetDistributionOutput{} out.Result = output err = awsRestxml_deserializeOpHttpBindingsGetDistributionOutput(output, response) if err != nil { return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} } 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) err = awsRestxml_deserializeDocumentDistribution(&output.Distribution, decoder) 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(), } } return out, metadata, err } func awsRestxml_deserializeOpErrorGetDistribution(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("AccessDenied", errorCode): return awsRestxml_deserializeErrorAccessDenied(response, errorBody) case strings.EqualFold("NoSuchDistribution", errorCode): return awsRestxml_deserializeErrorNoSuchDistribution(response, errorBody) default: genericError := &smithy.GenericAPIError{ Code: errorCode, Message: errorMessage, } return genericError } } func awsRestxml_deserializeOpHttpBindingsGetDistributionOutput(v *GetDistributionOutput, response *smithyhttp.Response) error { if v == nil { return fmt.Errorf("unsupported deserialization for nil %T", v) } if headerValues := response.Header.Values("ETag"); len(headerValues) != 0 { headerValues[0] = strings.TrimSpace(headerValues[0]) v.ETag = ptr.String(headerValues[0]) } return nil } func awsRestxml_deserializeOpDocumentGetDistributionOutput(v **GetDistributionOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *GetDistributionOutput if *v == nil { sv = &GetDistributionOutput{} } 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("Distribution", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentDistribution(&sv.Distribution, nodeDecoder); err != nil { return err } default: // Do nothing and ignore the unexpected tag element err = decoder.Decoder.Skip() if err != nil { return err } } decoder = originalDecoder } *v = sv return nil } type awsRestxml_deserializeOpGetDistributionConfig struct { } func (*awsRestxml_deserializeOpGetDistributionConfig) ID() string { return "OperationDeserializer" } func (m *awsRestxml_deserializeOpGetDistributionConfig) 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, awsRestxml_deserializeOpErrorGetDistributionConfig(response, &metadata) } output := &GetDistributionConfigOutput{} out.Result = output err = awsRestxml_deserializeOpHttpBindingsGetDistributionConfigOutput(output, response) if err != nil { return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} } 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) err = awsRestxml_deserializeDocumentDistributionConfig(&output.DistributionConfig, decoder) 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(), } } return out, metadata, err } func awsRestxml_deserializeOpErrorGetDistributionConfig(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("AccessDenied", errorCode): return awsRestxml_deserializeErrorAccessDenied(response, errorBody) case strings.EqualFold("NoSuchDistribution", errorCode): return awsRestxml_deserializeErrorNoSuchDistribution(response, errorBody) default: genericError := &smithy.GenericAPIError{ Code: errorCode, Message: errorMessage, } return genericError } } func awsRestxml_deserializeOpHttpBindingsGetDistributionConfigOutput(v *GetDistributionConfigOutput, response *smithyhttp.Response) error { if v == nil { return fmt.Errorf("unsupported deserialization for nil %T", v) } if headerValues := response.Header.Values("ETag"); len(headerValues) != 0 { headerValues[0] = strings.TrimSpace(headerValues[0]) v.ETag = ptr.String(headerValues[0]) } return nil } func awsRestxml_deserializeOpDocumentGetDistributionConfigOutput(v **GetDistributionConfigOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *GetDistributionConfigOutput if *v == nil { sv = &GetDistributionConfigOutput{} } 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("DistributionConfig", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentDistributionConfig(&sv.DistributionConfig, nodeDecoder); err != nil { return err } default: // Do nothing and ignore the unexpected tag element err = decoder.Decoder.Skip() if err != nil { return err } } decoder = originalDecoder } *v = sv return nil } type awsRestxml_deserializeOpGetFieldLevelEncryption struct { } func (*awsRestxml_deserializeOpGetFieldLevelEncryption) ID() string { return "OperationDeserializer" } func (m *awsRestxml_deserializeOpGetFieldLevelEncryption) 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, awsRestxml_deserializeOpErrorGetFieldLevelEncryption(response, &metadata) } output := &GetFieldLevelEncryptionOutput{} out.Result = output err = awsRestxml_deserializeOpHttpBindingsGetFieldLevelEncryptionOutput(output, response) if err != nil { return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} } 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) err = awsRestxml_deserializeDocumentFieldLevelEncryption(&output.FieldLevelEncryption, decoder) 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(), } } return out, metadata, err } func awsRestxml_deserializeOpErrorGetFieldLevelEncryption(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("AccessDenied", errorCode): return awsRestxml_deserializeErrorAccessDenied(response, errorBody) case strings.EqualFold("NoSuchFieldLevelEncryptionConfig", errorCode): return awsRestxml_deserializeErrorNoSuchFieldLevelEncryptionConfig(response, errorBody) default: genericError := &smithy.GenericAPIError{ Code: errorCode, Message: errorMessage, } return genericError } } func awsRestxml_deserializeOpHttpBindingsGetFieldLevelEncryptionOutput(v *GetFieldLevelEncryptionOutput, response *smithyhttp.Response) error { if v == nil { return fmt.Errorf("unsupported deserialization for nil %T", v) } if headerValues := response.Header.Values("ETag"); len(headerValues) != 0 { headerValues[0] = strings.TrimSpace(headerValues[0]) v.ETag = ptr.String(headerValues[0]) } return nil } func awsRestxml_deserializeOpDocumentGetFieldLevelEncryptionOutput(v **GetFieldLevelEncryptionOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *GetFieldLevelEncryptionOutput if *v == nil { sv = &GetFieldLevelEncryptionOutput{} } 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("FieldLevelEncryption", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentFieldLevelEncryption(&sv.FieldLevelEncryption, nodeDecoder); err != nil { return err } default: // Do nothing and ignore the unexpected tag element err = decoder.Decoder.Skip() if err != nil { return err } } decoder = originalDecoder } *v = sv return nil } type awsRestxml_deserializeOpGetFieldLevelEncryptionConfig struct { } func (*awsRestxml_deserializeOpGetFieldLevelEncryptionConfig) ID() string { return "OperationDeserializer" } func (m *awsRestxml_deserializeOpGetFieldLevelEncryptionConfig) 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, awsRestxml_deserializeOpErrorGetFieldLevelEncryptionConfig(response, &metadata) } output := &GetFieldLevelEncryptionConfigOutput{} out.Result = output err = awsRestxml_deserializeOpHttpBindingsGetFieldLevelEncryptionConfigOutput(output, response) if err != nil { return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} } 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) err = awsRestxml_deserializeDocumentFieldLevelEncryptionConfig(&output.FieldLevelEncryptionConfig, decoder) 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(), } } return out, metadata, err } func awsRestxml_deserializeOpErrorGetFieldLevelEncryptionConfig(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("AccessDenied", errorCode): return awsRestxml_deserializeErrorAccessDenied(response, errorBody) case strings.EqualFold("NoSuchFieldLevelEncryptionConfig", errorCode): return awsRestxml_deserializeErrorNoSuchFieldLevelEncryptionConfig(response, errorBody) default: genericError := &smithy.GenericAPIError{ Code: errorCode, Message: errorMessage, } return genericError } } func awsRestxml_deserializeOpHttpBindingsGetFieldLevelEncryptionConfigOutput(v *GetFieldLevelEncryptionConfigOutput, response *smithyhttp.Response) error { if v == nil { return fmt.Errorf("unsupported deserialization for nil %T", v) } if headerValues := response.Header.Values("ETag"); len(headerValues) != 0 { headerValues[0] = strings.TrimSpace(headerValues[0]) v.ETag = ptr.String(headerValues[0]) } return nil } func awsRestxml_deserializeOpDocumentGetFieldLevelEncryptionConfigOutput(v **GetFieldLevelEncryptionConfigOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *GetFieldLevelEncryptionConfigOutput if *v == nil { sv = &GetFieldLevelEncryptionConfigOutput{} } 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("FieldLevelEncryptionConfig", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentFieldLevelEncryptionConfig(&sv.FieldLevelEncryptionConfig, nodeDecoder); err != nil { return err } default: // Do nothing and ignore the unexpected tag element err = decoder.Decoder.Skip() if err != nil { return err } } decoder = originalDecoder } *v = sv return nil } type awsRestxml_deserializeOpGetFieldLevelEncryptionProfile struct { } func (*awsRestxml_deserializeOpGetFieldLevelEncryptionProfile) ID() string { return "OperationDeserializer" } func (m *awsRestxml_deserializeOpGetFieldLevelEncryptionProfile) 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, awsRestxml_deserializeOpErrorGetFieldLevelEncryptionProfile(response, &metadata) } output := &GetFieldLevelEncryptionProfileOutput{} out.Result = output err = awsRestxml_deserializeOpHttpBindingsGetFieldLevelEncryptionProfileOutput(output, response) if err != nil { return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} } 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) err = awsRestxml_deserializeDocumentFieldLevelEncryptionProfile(&output.FieldLevelEncryptionProfile, decoder) 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(), } } return out, metadata, err } func awsRestxml_deserializeOpErrorGetFieldLevelEncryptionProfile(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("AccessDenied", errorCode): return awsRestxml_deserializeErrorAccessDenied(response, errorBody) case strings.EqualFold("NoSuchFieldLevelEncryptionProfile", errorCode): return awsRestxml_deserializeErrorNoSuchFieldLevelEncryptionProfile(response, errorBody) default: genericError := &smithy.GenericAPIError{ Code: errorCode, Message: errorMessage, } return genericError } } func awsRestxml_deserializeOpHttpBindingsGetFieldLevelEncryptionProfileOutput(v *GetFieldLevelEncryptionProfileOutput, response *smithyhttp.Response) error { if v == nil { return fmt.Errorf("unsupported deserialization for nil %T", v) } if headerValues := response.Header.Values("ETag"); len(headerValues) != 0 { headerValues[0] = strings.TrimSpace(headerValues[0]) v.ETag = ptr.String(headerValues[0]) } return nil } func awsRestxml_deserializeOpDocumentGetFieldLevelEncryptionProfileOutput(v **GetFieldLevelEncryptionProfileOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *GetFieldLevelEncryptionProfileOutput if *v == nil { sv = &GetFieldLevelEncryptionProfileOutput{} } 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("FieldLevelEncryptionProfile", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentFieldLevelEncryptionProfile(&sv.FieldLevelEncryptionProfile, nodeDecoder); err != nil { return err } default: // Do nothing and ignore the unexpected tag element err = decoder.Decoder.Skip() if err != nil { return err } } decoder = originalDecoder } *v = sv return nil } type awsRestxml_deserializeOpGetFieldLevelEncryptionProfileConfig struct { } func (*awsRestxml_deserializeOpGetFieldLevelEncryptionProfileConfig) ID() string { return "OperationDeserializer" } func (m *awsRestxml_deserializeOpGetFieldLevelEncryptionProfileConfig) 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, awsRestxml_deserializeOpErrorGetFieldLevelEncryptionProfileConfig(response, &metadata) } output := &GetFieldLevelEncryptionProfileConfigOutput{} out.Result = output err = awsRestxml_deserializeOpHttpBindingsGetFieldLevelEncryptionProfileConfigOutput(output, response) if err != nil { return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} } 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) err = awsRestxml_deserializeDocumentFieldLevelEncryptionProfileConfig(&output.FieldLevelEncryptionProfileConfig, decoder) 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(), } } return out, metadata, err } func awsRestxml_deserializeOpErrorGetFieldLevelEncryptionProfileConfig(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("AccessDenied", errorCode): return awsRestxml_deserializeErrorAccessDenied(response, errorBody) case strings.EqualFold("NoSuchFieldLevelEncryptionProfile", errorCode): return awsRestxml_deserializeErrorNoSuchFieldLevelEncryptionProfile(response, errorBody) default: genericError := &smithy.GenericAPIError{ Code: errorCode, Message: errorMessage, } return genericError } } func awsRestxml_deserializeOpHttpBindingsGetFieldLevelEncryptionProfileConfigOutput(v *GetFieldLevelEncryptionProfileConfigOutput, response *smithyhttp.Response) error { if v == nil { return fmt.Errorf("unsupported deserialization for nil %T", v) } if headerValues := response.Header.Values("ETag"); len(headerValues) != 0 { headerValues[0] = strings.TrimSpace(headerValues[0]) v.ETag = ptr.String(headerValues[0]) } return nil } func awsRestxml_deserializeOpDocumentGetFieldLevelEncryptionProfileConfigOutput(v **GetFieldLevelEncryptionProfileConfigOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *GetFieldLevelEncryptionProfileConfigOutput if *v == nil { sv = &GetFieldLevelEncryptionProfileConfigOutput{} } 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("FieldLevelEncryptionProfileConfig", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentFieldLevelEncryptionProfileConfig(&sv.FieldLevelEncryptionProfileConfig, nodeDecoder); err != nil { return err } default: // Do nothing and ignore the unexpected tag element err = decoder.Decoder.Skip() if err != nil { return err } } decoder = originalDecoder } *v = sv return nil } type awsRestxml_deserializeOpGetFunction struct { } func (*awsRestxml_deserializeOpGetFunction) ID() string { return "OperationDeserializer" } func (m *awsRestxml_deserializeOpGetFunction) 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, awsRestxml_deserializeOpErrorGetFunction(response, &metadata) } output := &GetFunctionOutput{} out.Result = output err = awsRestxml_deserializeOpHttpBindingsGetFunctionOutput(output, response) if err != nil { return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} } err = awsRestxml_deserializeOpDocumentGetFunctionOutput(output, response.Body, response.ContentLength) if err != nil { return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to deserialize response payload, %w", err)} } return out, metadata, err } func awsRestxml_deserializeOpErrorGetFunction(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("NoSuchFunctionExists", errorCode): return awsRestxml_deserializeErrorNoSuchFunctionExists(response, errorBody) case strings.EqualFold("UnsupportedOperation", errorCode): return awsRestxml_deserializeErrorUnsupportedOperation(response, errorBody) default: genericError := &smithy.GenericAPIError{ Code: errorCode, Message: errorMessage, } return genericError } } func awsRestxml_deserializeOpHttpBindingsGetFunctionOutput(v *GetFunctionOutput, response *smithyhttp.Response) error { if v == nil { return fmt.Errorf("unsupported deserialization for nil %T", v) } if headerValues := response.Header.Values("Content-Type"); len(headerValues) != 0 { headerValues[0] = strings.TrimSpace(headerValues[0]) v.ContentType = ptr.String(headerValues[0]) } if headerValues := response.Header.Values("ETag"); len(headerValues) != 0 { headerValues[0] = strings.TrimSpace(headerValues[0]) v.ETag = ptr.String(headerValues[0]) } return nil } func awsRestxml_deserializeOpDocumentGetFunctionOutput(v *GetFunctionOutput, body io.ReadCloser, contentLength int64) error { if v == nil { return fmt.Errorf("unsupported deserialization of nil %T", v) } var buf bytes.Buffer if contentLength > 0 { buf.Grow(int(contentLength)) } else { buf.Grow(512) } _, err := buf.ReadFrom(body) if err != nil { return err } if buf.Len() > 0 { v.FunctionCode = buf.Bytes() } return nil } type awsRestxml_deserializeOpGetInvalidation struct { } func (*awsRestxml_deserializeOpGetInvalidation) ID() string { return "OperationDeserializer" } func (m *awsRestxml_deserializeOpGetInvalidation) 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, awsRestxml_deserializeOpErrorGetInvalidation(response, &metadata) } output := &GetInvalidationOutput{} 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) err = awsRestxml_deserializeDocumentInvalidation(&output.Invalidation, decoder) 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(), } } return out, metadata, err } func awsRestxml_deserializeOpErrorGetInvalidation(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("AccessDenied", errorCode): return awsRestxml_deserializeErrorAccessDenied(response, errorBody) case strings.EqualFold("NoSuchDistribution", errorCode): return awsRestxml_deserializeErrorNoSuchDistribution(response, errorBody) case strings.EqualFold("NoSuchInvalidation", errorCode): return awsRestxml_deserializeErrorNoSuchInvalidation(response, errorBody) default: genericError := &smithy.GenericAPIError{ Code: errorCode, Message: errorMessage, } return genericError } } func awsRestxml_deserializeOpDocumentGetInvalidationOutput(v **GetInvalidationOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *GetInvalidationOutput if *v == nil { sv = &GetInvalidationOutput{} } 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("Invalidation", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentInvalidation(&sv.Invalidation, nodeDecoder); err != nil { return err } default: // Do nothing and ignore the unexpected tag element err = decoder.Decoder.Skip() if err != nil { return err } } decoder = originalDecoder } *v = sv return nil } type awsRestxml_deserializeOpGetKeyGroup struct { } func (*awsRestxml_deserializeOpGetKeyGroup) ID() string { return "OperationDeserializer" } func (m *awsRestxml_deserializeOpGetKeyGroup) 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, awsRestxml_deserializeOpErrorGetKeyGroup(response, &metadata) } output := &GetKeyGroupOutput{} out.Result = output err = awsRestxml_deserializeOpHttpBindingsGetKeyGroupOutput(output, response) if err != nil { return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} } 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) err = awsRestxml_deserializeDocumentKeyGroup(&output.KeyGroup, decoder) 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(), } } return out, metadata, err } func awsRestxml_deserializeOpErrorGetKeyGroup(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("NoSuchResource", errorCode): return awsRestxml_deserializeErrorNoSuchResource(response, errorBody) default: genericError := &smithy.GenericAPIError{ Code: errorCode, Message: errorMessage, } return genericError } } func awsRestxml_deserializeOpHttpBindingsGetKeyGroupOutput(v *GetKeyGroupOutput, response *smithyhttp.Response) error { if v == nil { return fmt.Errorf("unsupported deserialization for nil %T", v) } if headerValues := response.Header.Values("ETag"); len(headerValues) != 0 { headerValues[0] = strings.TrimSpace(headerValues[0]) v.ETag = ptr.String(headerValues[0]) } return nil } func awsRestxml_deserializeOpDocumentGetKeyGroupOutput(v **GetKeyGroupOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *GetKeyGroupOutput if *v == nil { sv = &GetKeyGroupOutput{} } 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("KeyGroup", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentKeyGroup(&sv.KeyGroup, nodeDecoder); err != nil { return err } default: // Do nothing and ignore the unexpected tag element err = decoder.Decoder.Skip() if err != nil { return err } } decoder = originalDecoder } *v = sv return nil } type awsRestxml_deserializeOpGetKeyGroupConfig struct { } func (*awsRestxml_deserializeOpGetKeyGroupConfig) ID() string { return "OperationDeserializer" } func (m *awsRestxml_deserializeOpGetKeyGroupConfig) 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, awsRestxml_deserializeOpErrorGetKeyGroupConfig(response, &metadata) } output := &GetKeyGroupConfigOutput{} out.Result = output err = awsRestxml_deserializeOpHttpBindingsGetKeyGroupConfigOutput(output, response) if err != nil { return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} } 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) err = awsRestxml_deserializeDocumentKeyGroupConfig(&output.KeyGroupConfig, decoder) 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(), } } return out, metadata, err } func awsRestxml_deserializeOpErrorGetKeyGroupConfig(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("NoSuchResource", errorCode): return awsRestxml_deserializeErrorNoSuchResource(response, errorBody) default: genericError := &smithy.GenericAPIError{ Code: errorCode, Message: errorMessage, } return genericError } } func awsRestxml_deserializeOpHttpBindingsGetKeyGroupConfigOutput(v *GetKeyGroupConfigOutput, response *smithyhttp.Response) error { if v == nil { return fmt.Errorf("unsupported deserialization for nil %T", v) } if headerValues := response.Header.Values("ETag"); len(headerValues) != 0 { headerValues[0] = strings.TrimSpace(headerValues[0]) v.ETag = ptr.String(headerValues[0]) } return nil } func awsRestxml_deserializeOpDocumentGetKeyGroupConfigOutput(v **GetKeyGroupConfigOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *GetKeyGroupConfigOutput if *v == nil { sv = &GetKeyGroupConfigOutput{} } 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("KeyGroupConfig", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentKeyGroupConfig(&sv.KeyGroupConfig, nodeDecoder); err != nil { return err } default: // Do nothing and ignore the unexpected tag element err = decoder.Decoder.Skip() if err != nil { return err } } decoder = originalDecoder } *v = sv return nil } type awsRestxml_deserializeOpGetMonitoringSubscription struct { } func (*awsRestxml_deserializeOpGetMonitoringSubscription) ID() string { return "OperationDeserializer" } func (m *awsRestxml_deserializeOpGetMonitoringSubscription) 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, awsRestxml_deserializeOpErrorGetMonitoringSubscription(response, &metadata) } output := &GetMonitoringSubscriptionOutput{} 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) err = awsRestxml_deserializeDocumentMonitoringSubscription(&output.MonitoringSubscription, decoder) 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(), } } return out, metadata, err } func awsRestxml_deserializeOpErrorGetMonitoringSubscription(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("AccessDenied", errorCode): return awsRestxml_deserializeErrorAccessDenied(response, errorBody) case strings.EqualFold("NoSuchDistribution", errorCode): return awsRestxml_deserializeErrorNoSuchDistribution(response, errorBody) case strings.EqualFold("NoSuchMonitoringSubscription", errorCode): return awsRestxml_deserializeErrorNoSuchMonitoringSubscription(response, errorBody) case strings.EqualFold("UnsupportedOperation", errorCode): return awsRestxml_deserializeErrorUnsupportedOperation(response, errorBody) default: genericError := &smithy.GenericAPIError{ Code: errorCode, Message: errorMessage, } return genericError } } func awsRestxml_deserializeOpDocumentGetMonitoringSubscriptionOutput(v **GetMonitoringSubscriptionOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *GetMonitoringSubscriptionOutput if *v == nil { sv = &GetMonitoringSubscriptionOutput{} } 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("MonitoringSubscription", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentMonitoringSubscription(&sv.MonitoringSubscription, nodeDecoder); err != nil { return err } default: // Do nothing and ignore the unexpected tag element err = decoder.Decoder.Skip() if err != nil { return err } } decoder = originalDecoder } *v = sv return nil } type awsRestxml_deserializeOpGetOriginAccessControl struct { } func (*awsRestxml_deserializeOpGetOriginAccessControl) ID() string { return "OperationDeserializer" } func (m *awsRestxml_deserializeOpGetOriginAccessControl) 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, awsRestxml_deserializeOpErrorGetOriginAccessControl(response, &metadata) } output := &GetOriginAccessControlOutput{} out.Result = output err = awsRestxml_deserializeOpHttpBindingsGetOriginAccessControlOutput(output, response) if err != nil { return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} } 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) err = awsRestxml_deserializeDocumentOriginAccessControl(&output.OriginAccessControl, decoder) 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(), } } return out, metadata, err } func awsRestxml_deserializeOpErrorGetOriginAccessControl(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("AccessDenied", errorCode): return awsRestxml_deserializeErrorAccessDenied(response, errorBody) case strings.EqualFold("NoSuchOriginAccessControl", errorCode): return awsRestxml_deserializeErrorNoSuchOriginAccessControl(response, errorBody) default: genericError := &smithy.GenericAPIError{ Code: errorCode, Message: errorMessage, } return genericError } } func awsRestxml_deserializeOpHttpBindingsGetOriginAccessControlOutput(v *GetOriginAccessControlOutput, response *smithyhttp.Response) error { if v == nil { return fmt.Errorf("unsupported deserialization for nil %T", v) } if headerValues := response.Header.Values("ETag"); len(headerValues) != 0 { headerValues[0] = strings.TrimSpace(headerValues[0]) v.ETag = ptr.String(headerValues[0]) } return nil } func awsRestxml_deserializeOpDocumentGetOriginAccessControlOutput(v **GetOriginAccessControlOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *GetOriginAccessControlOutput if *v == nil { sv = &GetOriginAccessControlOutput{} } 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("OriginAccessControl", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentOriginAccessControl(&sv.OriginAccessControl, nodeDecoder); err != nil { return err } default: // Do nothing and ignore the unexpected tag element err = decoder.Decoder.Skip() if err != nil { return err } } decoder = originalDecoder } *v = sv return nil } type awsRestxml_deserializeOpGetOriginAccessControlConfig struct { } func (*awsRestxml_deserializeOpGetOriginAccessControlConfig) ID() string { return "OperationDeserializer" } func (m *awsRestxml_deserializeOpGetOriginAccessControlConfig) 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, awsRestxml_deserializeOpErrorGetOriginAccessControlConfig(response, &metadata) } output := &GetOriginAccessControlConfigOutput{} out.Result = output err = awsRestxml_deserializeOpHttpBindingsGetOriginAccessControlConfigOutput(output, response) if err != nil { return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} } 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) err = awsRestxml_deserializeDocumentOriginAccessControlConfig(&output.OriginAccessControlConfig, decoder) 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(), } } return out, metadata, err } func awsRestxml_deserializeOpErrorGetOriginAccessControlConfig(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("AccessDenied", errorCode): return awsRestxml_deserializeErrorAccessDenied(response, errorBody) case strings.EqualFold("NoSuchOriginAccessControl", errorCode): return awsRestxml_deserializeErrorNoSuchOriginAccessControl(response, errorBody) default: genericError := &smithy.GenericAPIError{ Code: errorCode, Message: errorMessage, } return genericError } } func awsRestxml_deserializeOpHttpBindingsGetOriginAccessControlConfigOutput(v *GetOriginAccessControlConfigOutput, response *smithyhttp.Response) error { if v == nil { return fmt.Errorf("unsupported deserialization for nil %T", v) } if headerValues := response.Header.Values("ETag"); len(headerValues) != 0 { headerValues[0] = strings.TrimSpace(headerValues[0]) v.ETag = ptr.String(headerValues[0]) } return nil } func awsRestxml_deserializeOpDocumentGetOriginAccessControlConfigOutput(v **GetOriginAccessControlConfigOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *GetOriginAccessControlConfigOutput if *v == nil { sv = &GetOriginAccessControlConfigOutput{} } 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("OriginAccessControlConfig", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentOriginAccessControlConfig(&sv.OriginAccessControlConfig, nodeDecoder); err != nil { return err } default: // Do nothing and ignore the unexpected tag element err = decoder.Decoder.Skip() if err != nil { return err } } decoder = originalDecoder } *v = sv return nil } type awsRestxml_deserializeOpGetOriginRequestPolicy struct { } func (*awsRestxml_deserializeOpGetOriginRequestPolicy) ID() string { return "OperationDeserializer" } func (m *awsRestxml_deserializeOpGetOriginRequestPolicy) 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, awsRestxml_deserializeOpErrorGetOriginRequestPolicy(response, &metadata) } output := &GetOriginRequestPolicyOutput{} out.Result = output err = awsRestxml_deserializeOpHttpBindingsGetOriginRequestPolicyOutput(output, response) if err != nil { return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} } 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) err = awsRestxml_deserializeDocumentOriginRequestPolicy(&output.OriginRequestPolicy, decoder) 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(), } } return out, metadata, err } func awsRestxml_deserializeOpErrorGetOriginRequestPolicy(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("AccessDenied", errorCode): return awsRestxml_deserializeErrorAccessDenied(response, errorBody) case strings.EqualFold("NoSuchOriginRequestPolicy", errorCode): return awsRestxml_deserializeErrorNoSuchOriginRequestPolicy(response, errorBody) default: genericError := &smithy.GenericAPIError{ Code: errorCode, Message: errorMessage, } return genericError } } func awsRestxml_deserializeOpHttpBindingsGetOriginRequestPolicyOutput(v *GetOriginRequestPolicyOutput, response *smithyhttp.Response) error { if v == nil { return fmt.Errorf("unsupported deserialization for nil %T", v) } if headerValues := response.Header.Values("ETag"); len(headerValues) != 0 { headerValues[0] = strings.TrimSpace(headerValues[0]) v.ETag = ptr.String(headerValues[0]) } return nil } func awsRestxml_deserializeOpDocumentGetOriginRequestPolicyOutput(v **GetOriginRequestPolicyOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *GetOriginRequestPolicyOutput if *v == nil { sv = &GetOriginRequestPolicyOutput{} } 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("OriginRequestPolicy", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentOriginRequestPolicy(&sv.OriginRequestPolicy, nodeDecoder); err != nil { return err } default: // Do nothing and ignore the unexpected tag element err = decoder.Decoder.Skip() if err != nil { return err } } decoder = originalDecoder } *v = sv return nil } type awsRestxml_deserializeOpGetOriginRequestPolicyConfig struct { } func (*awsRestxml_deserializeOpGetOriginRequestPolicyConfig) ID() string { return "OperationDeserializer" } func (m *awsRestxml_deserializeOpGetOriginRequestPolicyConfig) 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, awsRestxml_deserializeOpErrorGetOriginRequestPolicyConfig(response, &metadata) } output := &GetOriginRequestPolicyConfigOutput{} out.Result = output err = awsRestxml_deserializeOpHttpBindingsGetOriginRequestPolicyConfigOutput(output, response) if err != nil { return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} } 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) err = awsRestxml_deserializeDocumentOriginRequestPolicyConfig(&output.OriginRequestPolicyConfig, decoder) 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(), } } return out, metadata, err } func awsRestxml_deserializeOpErrorGetOriginRequestPolicyConfig(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("AccessDenied", errorCode): return awsRestxml_deserializeErrorAccessDenied(response, errorBody) case strings.EqualFold("NoSuchOriginRequestPolicy", errorCode): return awsRestxml_deserializeErrorNoSuchOriginRequestPolicy(response, errorBody) default: genericError := &smithy.GenericAPIError{ Code: errorCode, Message: errorMessage, } return genericError } } func awsRestxml_deserializeOpHttpBindingsGetOriginRequestPolicyConfigOutput(v *GetOriginRequestPolicyConfigOutput, response *smithyhttp.Response) error { if v == nil { return fmt.Errorf("unsupported deserialization for nil %T", v) } if headerValues := response.Header.Values("ETag"); len(headerValues) != 0 { headerValues[0] = strings.TrimSpace(headerValues[0]) v.ETag = ptr.String(headerValues[0]) } return nil } func awsRestxml_deserializeOpDocumentGetOriginRequestPolicyConfigOutput(v **GetOriginRequestPolicyConfigOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *GetOriginRequestPolicyConfigOutput if *v == nil { sv = &GetOriginRequestPolicyConfigOutput{} } 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("OriginRequestPolicyConfig", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentOriginRequestPolicyConfig(&sv.OriginRequestPolicyConfig, nodeDecoder); err != nil { return err } default: // Do nothing and ignore the unexpected tag element err = decoder.Decoder.Skip() if err != nil { return err } } decoder = originalDecoder } *v = sv return nil } type awsRestxml_deserializeOpGetPublicKey struct { } func (*awsRestxml_deserializeOpGetPublicKey) ID() string { return "OperationDeserializer" } func (m *awsRestxml_deserializeOpGetPublicKey) 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, awsRestxml_deserializeOpErrorGetPublicKey(response, &metadata) } output := &GetPublicKeyOutput{} out.Result = output err = awsRestxml_deserializeOpHttpBindingsGetPublicKeyOutput(output, response) if err != nil { return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} } 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) err = awsRestxml_deserializeDocumentPublicKey(&output.PublicKey, decoder) 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(), } } return out, metadata, err } func awsRestxml_deserializeOpErrorGetPublicKey(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("AccessDenied", errorCode): return awsRestxml_deserializeErrorAccessDenied(response, errorBody) case strings.EqualFold("NoSuchPublicKey", errorCode): return awsRestxml_deserializeErrorNoSuchPublicKey(response, errorBody) default: genericError := &smithy.GenericAPIError{ Code: errorCode, Message: errorMessage, } return genericError } } func awsRestxml_deserializeOpHttpBindingsGetPublicKeyOutput(v *GetPublicKeyOutput, response *smithyhttp.Response) error { if v == nil { return fmt.Errorf("unsupported deserialization for nil %T", v) } if headerValues := response.Header.Values("ETag"); len(headerValues) != 0 { headerValues[0] = strings.TrimSpace(headerValues[0]) v.ETag = ptr.String(headerValues[0]) } return nil } func awsRestxml_deserializeOpDocumentGetPublicKeyOutput(v **GetPublicKeyOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *GetPublicKeyOutput if *v == nil { sv = &GetPublicKeyOutput{} } 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("PublicKey", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentPublicKey(&sv.PublicKey, nodeDecoder); err != nil { return err } default: // Do nothing and ignore the unexpected tag element err = decoder.Decoder.Skip() if err != nil { return err } } decoder = originalDecoder } *v = sv return nil } type awsRestxml_deserializeOpGetPublicKeyConfig struct { } func (*awsRestxml_deserializeOpGetPublicKeyConfig) ID() string { return "OperationDeserializer" } func (m *awsRestxml_deserializeOpGetPublicKeyConfig) 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, awsRestxml_deserializeOpErrorGetPublicKeyConfig(response, &metadata) } output := &GetPublicKeyConfigOutput{} out.Result = output err = awsRestxml_deserializeOpHttpBindingsGetPublicKeyConfigOutput(output, response) if err != nil { return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} } 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) err = awsRestxml_deserializeDocumentPublicKeyConfig(&output.PublicKeyConfig, decoder) 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(), } } return out, metadata, err } func awsRestxml_deserializeOpErrorGetPublicKeyConfig(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("AccessDenied", errorCode): return awsRestxml_deserializeErrorAccessDenied(response, errorBody) case strings.EqualFold("NoSuchPublicKey", errorCode): return awsRestxml_deserializeErrorNoSuchPublicKey(response, errorBody) default: genericError := &smithy.GenericAPIError{ Code: errorCode, Message: errorMessage, } return genericError } } func awsRestxml_deserializeOpHttpBindingsGetPublicKeyConfigOutput(v *GetPublicKeyConfigOutput, response *smithyhttp.Response) error { if v == nil { return fmt.Errorf("unsupported deserialization for nil %T", v) } if headerValues := response.Header.Values("ETag"); len(headerValues) != 0 { headerValues[0] = strings.TrimSpace(headerValues[0]) v.ETag = ptr.String(headerValues[0]) } return nil } func awsRestxml_deserializeOpDocumentGetPublicKeyConfigOutput(v **GetPublicKeyConfigOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *GetPublicKeyConfigOutput if *v == nil { sv = &GetPublicKeyConfigOutput{} } 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("PublicKeyConfig", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentPublicKeyConfig(&sv.PublicKeyConfig, nodeDecoder); err != nil { return err } default: // Do nothing and ignore the unexpected tag element err = decoder.Decoder.Skip() if err != nil { return err } } decoder = originalDecoder } *v = sv return nil } type awsRestxml_deserializeOpGetRealtimeLogConfig struct { } func (*awsRestxml_deserializeOpGetRealtimeLogConfig) ID() string { return "OperationDeserializer" } func (m *awsRestxml_deserializeOpGetRealtimeLogConfig) 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, awsRestxml_deserializeOpErrorGetRealtimeLogConfig(response, &metadata) } output := &GetRealtimeLogConfigOutput{} 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) err = awsRestxml_deserializeOpDocumentGetRealtimeLogConfigOutput(&output, decoder) 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(), } } return out, metadata, err } func awsRestxml_deserializeOpErrorGetRealtimeLogConfig(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("AccessDenied", errorCode): return awsRestxml_deserializeErrorAccessDenied(response, errorBody) case strings.EqualFold("InvalidArgument", errorCode): return awsRestxml_deserializeErrorInvalidArgument(response, errorBody) case strings.EqualFold("NoSuchRealtimeLogConfig", errorCode): return awsRestxml_deserializeErrorNoSuchRealtimeLogConfig(response, errorBody) default: genericError := &smithy.GenericAPIError{ Code: errorCode, Message: errorMessage, } return genericError } } func awsRestxml_deserializeOpDocumentGetRealtimeLogConfigOutput(v **GetRealtimeLogConfigOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *GetRealtimeLogConfigOutput if *v == nil { sv = &GetRealtimeLogConfigOutput{} } 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("RealtimeLogConfig", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentRealtimeLogConfig(&sv.RealtimeLogConfig, nodeDecoder); err != nil { return err } default: // Do nothing and ignore the unexpected tag element err = decoder.Decoder.Skip() if err != nil { return err } } decoder = originalDecoder } *v = sv return nil } type awsRestxml_deserializeOpGetResponseHeadersPolicy struct { } func (*awsRestxml_deserializeOpGetResponseHeadersPolicy) ID() string { return "OperationDeserializer" } func (m *awsRestxml_deserializeOpGetResponseHeadersPolicy) 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, awsRestxml_deserializeOpErrorGetResponseHeadersPolicy(response, &metadata) } output := &GetResponseHeadersPolicyOutput{} out.Result = output err = awsRestxml_deserializeOpHttpBindingsGetResponseHeadersPolicyOutput(output, response) if err != nil { return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} } 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) err = awsRestxml_deserializeDocumentResponseHeadersPolicy(&output.ResponseHeadersPolicy, decoder) 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(), } } return out, metadata, err } func awsRestxml_deserializeOpErrorGetResponseHeadersPolicy(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("AccessDenied", errorCode): return awsRestxml_deserializeErrorAccessDenied(response, errorBody) case strings.EqualFold("NoSuchResponseHeadersPolicy", errorCode): return awsRestxml_deserializeErrorNoSuchResponseHeadersPolicy(response, errorBody) default: genericError := &smithy.GenericAPIError{ Code: errorCode, Message: errorMessage, } return genericError } } func awsRestxml_deserializeOpHttpBindingsGetResponseHeadersPolicyOutput(v *GetResponseHeadersPolicyOutput, response *smithyhttp.Response) error { if v == nil { return fmt.Errorf("unsupported deserialization for nil %T", v) } if headerValues := response.Header.Values("ETag"); len(headerValues) != 0 { headerValues[0] = strings.TrimSpace(headerValues[0]) v.ETag = ptr.String(headerValues[0]) } return nil } func awsRestxml_deserializeOpDocumentGetResponseHeadersPolicyOutput(v **GetResponseHeadersPolicyOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *GetResponseHeadersPolicyOutput if *v == nil { sv = &GetResponseHeadersPolicyOutput{} } 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("ResponseHeadersPolicy", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentResponseHeadersPolicy(&sv.ResponseHeadersPolicy, nodeDecoder); err != nil { return err } default: // Do nothing and ignore the unexpected tag element err = decoder.Decoder.Skip() if err != nil { return err } } decoder = originalDecoder } *v = sv return nil } type awsRestxml_deserializeOpGetResponseHeadersPolicyConfig struct { } func (*awsRestxml_deserializeOpGetResponseHeadersPolicyConfig) ID() string { return "OperationDeserializer" } func (m *awsRestxml_deserializeOpGetResponseHeadersPolicyConfig) 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, awsRestxml_deserializeOpErrorGetResponseHeadersPolicyConfig(response, &metadata) } output := &GetResponseHeadersPolicyConfigOutput{} out.Result = output err = awsRestxml_deserializeOpHttpBindingsGetResponseHeadersPolicyConfigOutput(output, response) if err != nil { return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} } 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) err = awsRestxml_deserializeDocumentResponseHeadersPolicyConfig(&output.ResponseHeadersPolicyConfig, decoder) 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(), } } return out, metadata, err } func awsRestxml_deserializeOpErrorGetResponseHeadersPolicyConfig(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("AccessDenied", errorCode): return awsRestxml_deserializeErrorAccessDenied(response, errorBody) case strings.EqualFold("NoSuchResponseHeadersPolicy", errorCode): return awsRestxml_deserializeErrorNoSuchResponseHeadersPolicy(response, errorBody) default: genericError := &smithy.GenericAPIError{ Code: errorCode, Message: errorMessage, } return genericError } } func awsRestxml_deserializeOpHttpBindingsGetResponseHeadersPolicyConfigOutput(v *GetResponseHeadersPolicyConfigOutput, response *smithyhttp.Response) error { if v == nil { return fmt.Errorf("unsupported deserialization for nil %T", v) } if headerValues := response.Header.Values("ETag"); len(headerValues) != 0 { headerValues[0] = strings.TrimSpace(headerValues[0]) v.ETag = ptr.String(headerValues[0]) } return nil } func awsRestxml_deserializeOpDocumentGetResponseHeadersPolicyConfigOutput(v **GetResponseHeadersPolicyConfigOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *GetResponseHeadersPolicyConfigOutput if *v == nil { sv = &GetResponseHeadersPolicyConfigOutput{} } 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("ResponseHeadersPolicyConfig", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentResponseHeadersPolicyConfig(&sv.ResponseHeadersPolicyConfig, nodeDecoder); err != nil { return err } default: // Do nothing and ignore the unexpected tag element err = decoder.Decoder.Skip() if err != nil { return err } } decoder = originalDecoder } *v = sv return nil } type awsRestxml_deserializeOpGetStreamingDistribution struct { } func (*awsRestxml_deserializeOpGetStreamingDistribution) ID() string { return "OperationDeserializer" } func (m *awsRestxml_deserializeOpGetStreamingDistribution) 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, awsRestxml_deserializeOpErrorGetStreamingDistribution(response, &metadata) } output := &GetStreamingDistributionOutput{} out.Result = output err = awsRestxml_deserializeOpHttpBindingsGetStreamingDistributionOutput(output, response) if err != nil { return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} } 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) err = awsRestxml_deserializeDocumentStreamingDistribution(&output.StreamingDistribution, decoder) 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(), } } return out, metadata, err } func awsRestxml_deserializeOpErrorGetStreamingDistribution(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("AccessDenied", errorCode): return awsRestxml_deserializeErrorAccessDenied(response, errorBody) case strings.EqualFold("NoSuchStreamingDistribution", errorCode): return awsRestxml_deserializeErrorNoSuchStreamingDistribution(response, errorBody) default: genericError := &smithy.GenericAPIError{ Code: errorCode, Message: errorMessage, } return genericError } } func awsRestxml_deserializeOpHttpBindingsGetStreamingDistributionOutput(v *GetStreamingDistributionOutput, response *smithyhttp.Response) error { if v == nil { return fmt.Errorf("unsupported deserialization for nil %T", v) } if headerValues := response.Header.Values("ETag"); len(headerValues) != 0 { headerValues[0] = strings.TrimSpace(headerValues[0]) v.ETag = ptr.String(headerValues[0]) } return nil } func awsRestxml_deserializeOpDocumentGetStreamingDistributionOutput(v **GetStreamingDistributionOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *GetStreamingDistributionOutput if *v == nil { sv = &GetStreamingDistributionOutput{} } 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("StreamingDistribution", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentStreamingDistribution(&sv.StreamingDistribution, nodeDecoder); err != nil { return err } default: // Do nothing and ignore the unexpected tag element err = decoder.Decoder.Skip() if err != nil { return err } } decoder = originalDecoder } *v = sv return nil } type awsRestxml_deserializeOpGetStreamingDistributionConfig struct { } func (*awsRestxml_deserializeOpGetStreamingDistributionConfig) ID() string { return "OperationDeserializer" } func (m *awsRestxml_deserializeOpGetStreamingDistributionConfig) 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, awsRestxml_deserializeOpErrorGetStreamingDistributionConfig(response, &metadata) } output := &GetStreamingDistributionConfigOutput{} out.Result = output err = awsRestxml_deserializeOpHttpBindingsGetStreamingDistributionConfigOutput(output, response) if err != nil { return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} } 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) err = awsRestxml_deserializeDocumentStreamingDistributionConfig(&output.StreamingDistributionConfig, decoder) 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(), } } return out, metadata, err } func awsRestxml_deserializeOpErrorGetStreamingDistributionConfig(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("AccessDenied", errorCode): return awsRestxml_deserializeErrorAccessDenied(response, errorBody) case strings.EqualFold("NoSuchStreamingDistribution", errorCode): return awsRestxml_deserializeErrorNoSuchStreamingDistribution(response, errorBody) default: genericError := &smithy.GenericAPIError{ Code: errorCode, Message: errorMessage, } return genericError } } func awsRestxml_deserializeOpHttpBindingsGetStreamingDistributionConfigOutput(v *GetStreamingDistributionConfigOutput, response *smithyhttp.Response) error { if v == nil { return fmt.Errorf("unsupported deserialization for nil %T", v) } if headerValues := response.Header.Values("ETag"); len(headerValues) != 0 { headerValues[0] = strings.TrimSpace(headerValues[0]) v.ETag = ptr.String(headerValues[0]) } return nil } func awsRestxml_deserializeOpDocumentGetStreamingDistributionConfigOutput(v **GetStreamingDistributionConfigOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *GetStreamingDistributionConfigOutput if *v == nil { sv = &GetStreamingDistributionConfigOutput{} } 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("StreamingDistributionConfig", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentStreamingDistributionConfig(&sv.StreamingDistributionConfig, nodeDecoder); err != nil { return err } default: // Do nothing and ignore the unexpected tag element err = decoder.Decoder.Skip() if err != nil { return err } } decoder = originalDecoder } *v = sv return nil } type awsRestxml_deserializeOpListCachePolicies struct { } func (*awsRestxml_deserializeOpListCachePolicies) ID() string { return "OperationDeserializer" } func (m *awsRestxml_deserializeOpListCachePolicies) 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, awsRestxml_deserializeOpErrorListCachePolicies(response, &metadata) } output := &ListCachePoliciesOutput{} 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) err = awsRestxml_deserializeDocumentCachePolicyList(&output.CachePolicyList, decoder) 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(), } } return out, metadata, err } func awsRestxml_deserializeOpErrorListCachePolicies(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("AccessDenied", errorCode): return awsRestxml_deserializeErrorAccessDenied(response, errorBody) case strings.EqualFold("InvalidArgument", errorCode): return awsRestxml_deserializeErrorInvalidArgument(response, errorBody) case strings.EqualFold("NoSuchCachePolicy", errorCode): return awsRestxml_deserializeErrorNoSuchCachePolicy(response, errorBody) default: genericError := &smithy.GenericAPIError{ Code: errorCode, Message: errorMessage, } return genericError } } func awsRestxml_deserializeOpDocumentListCachePoliciesOutput(v **ListCachePoliciesOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *ListCachePoliciesOutput if *v == nil { sv = &ListCachePoliciesOutput{} } 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("CachePolicyList", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentCachePolicyList(&sv.CachePolicyList, nodeDecoder); err != nil { return err } default: // Do nothing and ignore the unexpected tag element err = decoder.Decoder.Skip() if err != nil { return err } } decoder = originalDecoder } *v = sv return nil } type awsRestxml_deserializeOpListCloudFrontOriginAccessIdentities struct { } func (*awsRestxml_deserializeOpListCloudFrontOriginAccessIdentities) ID() string { return "OperationDeserializer" } func (m *awsRestxml_deserializeOpListCloudFrontOriginAccessIdentities) 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, awsRestxml_deserializeOpErrorListCloudFrontOriginAccessIdentities(response, &metadata) } output := &ListCloudFrontOriginAccessIdentitiesOutput{} 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) err = awsRestxml_deserializeDocumentCloudFrontOriginAccessIdentityList(&output.CloudFrontOriginAccessIdentityList, decoder) 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(), } } return out, metadata, err } func awsRestxml_deserializeOpErrorListCloudFrontOriginAccessIdentities(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("InvalidArgument", errorCode): return awsRestxml_deserializeErrorInvalidArgument(response, errorBody) default: genericError := &smithy.GenericAPIError{ Code: errorCode, Message: errorMessage, } return genericError } } func awsRestxml_deserializeOpDocumentListCloudFrontOriginAccessIdentitiesOutput(v **ListCloudFrontOriginAccessIdentitiesOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *ListCloudFrontOriginAccessIdentitiesOutput if *v == nil { sv = &ListCloudFrontOriginAccessIdentitiesOutput{} } 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("CloudFrontOriginAccessIdentityList", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentCloudFrontOriginAccessIdentityList(&sv.CloudFrontOriginAccessIdentityList, nodeDecoder); err != nil { return err } default: // Do nothing and ignore the unexpected tag element err = decoder.Decoder.Skip() if err != nil { return err } } decoder = originalDecoder } *v = sv return nil } type awsRestxml_deserializeOpListConflictingAliases struct { } func (*awsRestxml_deserializeOpListConflictingAliases) ID() string { return "OperationDeserializer" } func (m *awsRestxml_deserializeOpListConflictingAliases) 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, awsRestxml_deserializeOpErrorListConflictingAliases(response, &metadata) } output := &ListConflictingAliasesOutput{} 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) err = awsRestxml_deserializeDocumentConflictingAliasesList(&output.ConflictingAliasesList, decoder) 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(), } } return out, metadata, err } func awsRestxml_deserializeOpErrorListConflictingAliases(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("InvalidArgument", errorCode): return awsRestxml_deserializeErrorInvalidArgument(response, errorBody) case strings.EqualFold("NoSuchDistribution", errorCode): return awsRestxml_deserializeErrorNoSuchDistribution(response, errorBody) default: genericError := &smithy.GenericAPIError{ Code: errorCode, Message: errorMessage, } return genericError } } func awsRestxml_deserializeOpDocumentListConflictingAliasesOutput(v **ListConflictingAliasesOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *ListConflictingAliasesOutput if *v == nil { sv = &ListConflictingAliasesOutput{} } 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("ConflictingAliasesList", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentConflictingAliasesList(&sv.ConflictingAliasesList, nodeDecoder); err != nil { return err } default: // Do nothing and ignore the unexpected tag element err = decoder.Decoder.Skip() if err != nil { return err } } decoder = originalDecoder } *v = sv return nil } type awsRestxml_deserializeOpListContinuousDeploymentPolicies struct { } func (*awsRestxml_deserializeOpListContinuousDeploymentPolicies) ID() string { return "OperationDeserializer" } func (m *awsRestxml_deserializeOpListContinuousDeploymentPolicies) 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, awsRestxml_deserializeOpErrorListContinuousDeploymentPolicies(response, &metadata) } output := &ListContinuousDeploymentPoliciesOutput{} 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) err = awsRestxml_deserializeDocumentContinuousDeploymentPolicyList(&output.ContinuousDeploymentPolicyList, decoder) 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(), } } return out, metadata, err } func awsRestxml_deserializeOpErrorListContinuousDeploymentPolicies(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("AccessDenied", errorCode): return awsRestxml_deserializeErrorAccessDenied(response, errorBody) case strings.EqualFold("InvalidArgument", errorCode): return awsRestxml_deserializeErrorInvalidArgument(response, errorBody) case strings.EqualFold("NoSuchContinuousDeploymentPolicy", errorCode): return awsRestxml_deserializeErrorNoSuchContinuousDeploymentPolicy(response, errorBody) default: genericError := &smithy.GenericAPIError{ Code: errorCode, Message: errorMessage, } return genericError } } func awsRestxml_deserializeOpDocumentListContinuousDeploymentPoliciesOutput(v **ListContinuousDeploymentPoliciesOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *ListContinuousDeploymentPoliciesOutput if *v == nil { sv = &ListContinuousDeploymentPoliciesOutput{} } 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("ContinuousDeploymentPolicyList", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentContinuousDeploymentPolicyList(&sv.ContinuousDeploymentPolicyList, nodeDecoder); err != nil { return err } default: // Do nothing and ignore the unexpected tag element err = decoder.Decoder.Skip() if err != nil { return err } } decoder = originalDecoder } *v = sv return nil } type awsRestxml_deserializeOpListDistributions struct { } func (*awsRestxml_deserializeOpListDistributions) ID() string { return "OperationDeserializer" } func (m *awsRestxml_deserializeOpListDistributions) 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, awsRestxml_deserializeOpErrorListDistributions(response, &metadata) } output := &ListDistributionsOutput{} 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) err = awsRestxml_deserializeDocumentDistributionList(&output.DistributionList, decoder) 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(), } } return out, metadata, err } func awsRestxml_deserializeOpErrorListDistributions(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("InvalidArgument", errorCode): return awsRestxml_deserializeErrorInvalidArgument(response, errorBody) default: genericError := &smithy.GenericAPIError{ Code: errorCode, Message: errorMessage, } return genericError } } func awsRestxml_deserializeOpDocumentListDistributionsOutput(v **ListDistributionsOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *ListDistributionsOutput if *v == nil { sv = &ListDistributionsOutput{} } 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("DistributionList", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentDistributionList(&sv.DistributionList, nodeDecoder); err != nil { return err } default: // Do nothing and ignore the unexpected tag element err = decoder.Decoder.Skip() if err != nil { return err } } decoder = originalDecoder } *v = sv return nil } type awsRestxml_deserializeOpListDistributionsByCachePolicyId struct { } func (*awsRestxml_deserializeOpListDistributionsByCachePolicyId) ID() string { return "OperationDeserializer" } func (m *awsRestxml_deserializeOpListDistributionsByCachePolicyId) 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, awsRestxml_deserializeOpErrorListDistributionsByCachePolicyId(response, &metadata) } output := &ListDistributionsByCachePolicyIdOutput{} 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) err = awsRestxml_deserializeDocumentDistributionIdList(&output.DistributionIdList, decoder) 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(), } } return out, metadata, err } func awsRestxml_deserializeOpErrorListDistributionsByCachePolicyId(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("AccessDenied", errorCode): return awsRestxml_deserializeErrorAccessDenied(response, errorBody) case strings.EqualFold("InvalidArgument", errorCode): return awsRestxml_deserializeErrorInvalidArgument(response, errorBody) case strings.EqualFold("NoSuchCachePolicy", errorCode): return awsRestxml_deserializeErrorNoSuchCachePolicy(response, errorBody) default: genericError := &smithy.GenericAPIError{ Code: errorCode, Message: errorMessage, } return genericError } } func awsRestxml_deserializeOpDocumentListDistributionsByCachePolicyIdOutput(v **ListDistributionsByCachePolicyIdOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *ListDistributionsByCachePolicyIdOutput if *v == nil { sv = &ListDistributionsByCachePolicyIdOutput{} } 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("DistributionIdList", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentDistributionIdList(&sv.DistributionIdList, nodeDecoder); err != nil { return err } default: // Do nothing and ignore the unexpected tag element err = decoder.Decoder.Skip() if err != nil { return err } } decoder = originalDecoder } *v = sv return nil } type awsRestxml_deserializeOpListDistributionsByKeyGroup struct { } func (*awsRestxml_deserializeOpListDistributionsByKeyGroup) ID() string { return "OperationDeserializer" } func (m *awsRestxml_deserializeOpListDistributionsByKeyGroup) 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, awsRestxml_deserializeOpErrorListDistributionsByKeyGroup(response, &metadata) } output := &ListDistributionsByKeyGroupOutput{} 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) err = awsRestxml_deserializeDocumentDistributionIdList(&output.DistributionIdList, decoder) 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(), } } return out, metadata, err } func awsRestxml_deserializeOpErrorListDistributionsByKeyGroup(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("InvalidArgument", errorCode): return awsRestxml_deserializeErrorInvalidArgument(response, errorBody) case strings.EqualFold("NoSuchResource", errorCode): return awsRestxml_deserializeErrorNoSuchResource(response, errorBody) default: genericError := &smithy.GenericAPIError{ Code: errorCode, Message: errorMessage, } return genericError } } func awsRestxml_deserializeOpDocumentListDistributionsByKeyGroupOutput(v **ListDistributionsByKeyGroupOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *ListDistributionsByKeyGroupOutput if *v == nil { sv = &ListDistributionsByKeyGroupOutput{} } 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("DistributionIdList", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentDistributionIdList(&sv.DistributionIdList, nodeDecoder); err != nil { return err } default: // Do nothing and ignore the unexpected tag element err = decoder.Decoder.Skip() if err != nil { return err } } decoder = originalDecoder } *v = sv return nil } type awsRestxml_deserializeOpListDistributionsByOriginRequestPolicyId struct { } func (*awsRestxml_deserializeOpListDistributionsByOriginRequestPolicyId) ID() string { return "OperationDeserializer" } func (m *awsRestxml_deserializeOpListDistributionsByOriginRequestPolicyId) 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, awsRestxml_deserializeOpErrorListDistributionsByOriginRequestPolicyId(response, &metadata) } output := &ListDistributionsByOriginRequestPolicyIdOutput{} 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) err = awsRestxml_deserializeDocumentDistributionIdList(&output.DistributionIdList, decoder) 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(), } } return out, metadata, err } func awsRestxml_deserializeOpErrorListDistributionsByOriginRequestPolicyId(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("AccessDenied", errorCode): return awsRestxml_deserializeErrorAccessDenied(response, errorBody) case strings.EqualFold("InvalidArgument", errorCode): return awsRestxml_deserializeErrorInvalidArgument(response, errorBody) case strings.EqualFold("NoSuchOriginRequestPolicy", errorCode): return awsRestxml_deserializeErrorNoSuchOriginRequestPolicy(response, errorBody) default: genericError := &smithy.GenericAPIError{ Code: errorCode, Message: errorMessage, } return genericError } } func awsRestxml_deserializeOpDocumentListDistributionsByOriginRequestPolicyIdOutput(v **ListDistributionsByOriginRequestPolicyIdOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *ListDistributionsByOriginRequestPolicyIdOutput if *v == nil { sv = &ListDistributionsByOriginRequestPolicyIdOutput{} } 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("DistributionIdList", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentDistributionIdList(&sv.DistributionIdList, nodeDecoder); err != nil { return err } default: // Do nothing and ignore the unexpected tag element err = decoder.Decoder.Skip() if err != nil { return err } } decoder = originalDecoder } *v = sv return nil } type awsRestxml_deserializeOpListDistributionsByRealtimeLogConfig struct { } func (*awsRestxml_deserializeOpListDistributionsByRealtimeLogConfig) ID() string { return "OperationDeserializer" } func (m *awsRestxml_deserializeOpListDistributionsByRealtimeLogConfig) 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, awsRestxml_deserializeOpErrorListDistributionsByRealtimeLogConfig(response, &metadata) } output := &ListDistributionsByRealtimeLogConfigOutput{} 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) err = awsRestxml_deserializeDocumentDistributionList(&output.DistributionList, decoder) 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(), } } return out, metadata, err } func awsRestxml_deserializeOpErrorListDistributionsByRealtimeLogConfig(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("InvalidArgument", errorCode): return awsRestxml_deserializeErrorInvalidArgument(response, errorBody) default: genericError := &smithy.GenericAPIError{ Code: errorCode, Message: errorMessage, } return genericError } } func awsRestxml_deserializeOpDocumentListDistributionsByRealtimeLogConfigOutput(v **ListDistributionsByRealtimeLogConfigOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *ListDistributionsByRealtimeLogConfigOutput if *v == nil { sv = &ListDistributionsByRealtimeLogConfigOutput{} } 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("DistributionList", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentDistributionList(&sv.DistributionList, nodeDecoder); err != nil { return err } default: // Do nothing and ignore the unexpected tag element err = decoder.Decoder.Skip() if err != nil { return err } } decoder = originalDecoder } *v = sv return nil } type awsRestxml_deserializeOpListDistributionsByResponseHeadersPolicyId struct { } func (*awsRestxml_deserializeOpListDistributionsByResponseHeadersPolicyId) ID() string { return "OperationDeserializer" } func (m *awsRestxml_deserializeOpListDistributionsByResponseHeadersPolicyId) 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, awsRestxml_deserializeOpErrorListDistributionsByResponseHeadersPolicyId(response, &metadata) } output := &ListDistributionsByResponseHeadersPolicyIdOutput{} 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) err = awsRestxml_deserializeDocumentDistributionIdList(&output.DistributionIdList, decoder) 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(), } } return out, metadata, err } func awsRestxml_deserializeOpErrorListDistributionsByResponseHeadersPolicyId(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("AccessDenied", errorCode): return awsRestxml_deserializeErrorAccessDenied(response, errorBody) case strings.EqualFold("InvalidArgument", errorCode): return awsRestxml_deserializeErrorInvalidArgument(response, errorBody) case strings.EqualFold("NoSuchResponseHeadersPolicy", errorCode): return awsRestxml_deserializeErrorNoSuchResponseHeadersPolicy(response, errorBody) default: genericError := &smithy.GenericAPIError{ Code: errorCode, Message: errorMessage, } return genericError } } func awsRestxml_deserializeOpDocumentListDistributionsByResponseHeadersPolicyIdOutput(v **ListDistributionsByResponseHeadersPolicyIdOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *ListDistributionsByResponseHeadersPolicyIdOutput if *v == nil { sv = &ListDistributionsByResponseHeadersPolicyIdOutput{} } 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("DistributionIdList", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentDistributionIdList(&sv.DistributionIdList, nodeDecoder); err != nil { return err } default: // Do nothing and ignore the unexpected tag element err = decoder.Decoder.Skip() if err != nil { return err } } decoder = originalDecoder } *v = sv return nil } type awsRestxml_deserializeOpListDistributionsByWebACLId struct { } func (*awsRestxml_deserializeOpListDistributionsByWebACLId) ID() string { return "OperationDeserializer" } func (m *awsRestxml_deserializeOpListDistributionsByWebACLId) 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, awsRestxml_deserializeOpErrorListDistributionsByWebACLId(response, &metadata) } output := &ListDistributionsByWebACLIdOutput{} 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) err = awsRestxml_deserializeDocumentDistributionList(&output.DistributionList, decoder) 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(), } } return out, metadata, err } func awsRestxml_deserializeOpErrorListDistributionsByWebACLId(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("InvalidArgument", errorCode): return awsRestxml_deserializeErrorInvalidArgument(response, errorBody) case strings.EqualFold("InvalidWebACLId", errorCode): return awsRestxml_deserializeErrorInvalidWebACLId(response, errorBody) default: genericError := &smithy.GenericAPIError{ Code: errorCode, Message: errorMessage, } return genericError } } func awsRestxml_deserializeOpDocumentListDistributionsByWebACLIdOutput(v **ListDistributionsByWebACLIdOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *ListDistributionsByWebACLIdOutput if *v == nil { sv = &ListDistributionsByWebACLIdOutput{} } 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("DistributionList", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentDistributionList(&sv.DistributionList, nodeDecoder); err != nil { return err } default: // Do nothing and ignore the unexpected tag element err = decoder.Decoder.Skip() if err != nil { return err } } decoder = originalDecoder } *v = sv return nil } type awsRestxml_deserializeOpListFieldLevelEncryptionConfigs struct { } func (*awsRestxml_deserializeOpListFieldLevelEncryptionConfigs) ID() string { return "OperationDeserializer" } func (m *awsRestxml_deserializeOpListFieldLevelEncryptionConfigs) 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, awsRestxml_deserializeOpErrorListFieldLevelEncryptionConfigs(response, &metadata) } output := &ListFieldLevelEncryptionConfigsOutput{} 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) err = awsRestxml_deserializeDocumentFieldLevelEncryptionList(&output.FieldLevelEncryptionList, decoder) 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(), } } return out, metadata, err } func awsRestxml_deserializeOpErrorListFieldLevelEncryptionConfigs(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("InvalidArgument", errorCode): return awsRestxml_deserializeErrorInvalidArgument(response, errorBody) default: genericError := &smithy.GenericAPIError{ Code: errorCode, Message: errorMessage, } return genericError } } func awsRestxml_deserializeOpDocumentListFieldLevelEncryptionConfigsOutput(v **ListFieldLevelEncryptionConfigsOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *ListFieldLevelEncryptionConfigsOutput if *v == nil { sv = &ListFieldLevelEncryptionConfigsOutput{} } 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("FieldLevelEncryptionList", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentFieldLevelEncryptionList(&sv.FieldLevelEncryptionList, nodeDecoder); err != nil { return err } default: // Do nothing and ignore the unexpected tag element err = decoder.Decoder.Skip() if err != nil { return err } } decoder = originalDecoder } *v = sv return nil } type awsRestxml_deserializeOpListFieldLevelEncryptionProfiles struct { } func (*awsRestxml_deserializeOpListFieldLevelEncryptionProfiles) ID() string { return "OperationDeserializer" } func (m *awsRestxml_deserializeOpListFieldLevelEncryptionProfiles) 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, awsRestxml_deserializeOpErrorListFieldLevelEncryptionProfiles(response, &metadata) } output := &ListFieldLevelEncryptionProfilesOutput{} 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) err = awsRestxml_deserializeDocumentFieldLevelEncryptionProfileList(&output.FieldLevelEncryptionProfileList, decoder) 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(), } } return out, metadata, err } func awsRestxml_deserializeOpErrorListFieldLevelEncryptionProfiles(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("InvalidArgument", errorCode): return awsRestxml_deserializeErrorInvalidArgument(response, errorBody) default: genericError := &smithy.GenericAPIError{ Code: errorCode, Message: errorMessage, } return genericError } } func awsRestxml_deserializeOpDocumentListFieldLevelEncryptionProfilesOutput(v **ListFieldLevelEncryptionProfilesOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *ListFieldLevelEncryptionProfilesOutput if *v == nil { sv = &ListFieldLevelEncryptionProfilesOutput{} } 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("FieldLevelEncryptionProfileList", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentFieldLevelEncryptionProfileList(&sv.FieldLevelEncryptionProfileList, nodeDecoder); err != nil { return err } default: // Do nothing and ignore the unexpected tag element err = decoder.Decoder.Skip() if err != nil { return err } } decoder = originalDecoder } *v = sv return nil } type awsRestxml_deserializeOpListFunctions struct { } func (*awsRestxml_deserializeOpListFunctions) ID() string { return "OperationDeserializer" } func (m *awsRestxml_deserializeOpListFunctions) 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, awsRestxml_deserializeOpErrorListFunctions(response, &metadata) } output := &ListFunctionsOutput{} 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) err = awsRestxml_deserializeDocumentFunctionList(&output.FunctionList, decoder) 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(), } } return out, metadata, err } func awsRestxml_deserializeOpErrorListFunctions(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("InvalidArgument", errorCode): return awsRestxml_deserializeErrorInvalidArgument(response, errorBody) case strings.EqualFold("UnsupportedOperation", errorCode): return awsRestxml_deserializeErrorUnsupportedOperation(response, errorBody) default: genericError := &smithy.GenericAPIError{ Code: errorCode, Message: errorMessage, } return genericError } } func awsRestxml_deserializeOpDocumentListFunctionsOutput(v **ListFunctionsOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *ListFunctionsOutput if *v == nil { sv = &ListFunctionsOutput{} } 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("FunctionList", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentFunctionList(&sv.FunctionList, nodeDecoder); err != nil { return err } default: // Do nothing and ignore the unexpected tag element err = decoder.Decoder.Skip() if err != nil { return err } } decoder = originalDecoder } *v = sv return nil } type awsRestxml_deserializeOpListInvalidations struct { } func (*awsRestxml_deserializeOpListInvalidations) ID() string { return "OperationDeserializer" } func (m *awsRestxml_deserializeOpListInvalidations) 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, awsRestxml_deserializeOpErrorListInvalidations(response, &metadata) } output := &ListInvalidationsOutput{} 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) err = awsRestxml_deserializeDocumentInvalidationList(&output.InvalidationList, decoder) 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(), } } return out, metadata, err } func awsRestxml_deserializeOpErrorListInvalidations(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("AccessDenied", errorCode): return awsRestxml_deserializeErrorAccessDenied(response, errorBody) case strings.EqualFold("InvalidArgument", errorCode): return awsRestxml_deserializeErrorInvalidArgument(response, errorBody) case strings.EqualFold("NoSuchDistribution", errorCode): return awsRestxml_deserializeErrorNoSuchDistribution(response, errorBody) default: genericError := &smithy.GenericAPIError{ Code: errorCode, Message: errorMessage, } return genericError } } func awsRestxml_deserializeOpDocumentListInvalidationsOutput(v **ListInvalidationsOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *ListInvalidationsOutput if *v == nil { sv = &ListInvalidationsOutput{} } 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("InvalidationList", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentInvalidationList(&sv.InvalidationList, nodeDecoder); err != nil { return err } default: // Do nothing and ignore the unexpected tag element err = decoder.Decoder.Skip() if err != nil { return err } } decoder = originalDecoder } *v = sv return nil } type awsRestxml_deserializeOpListKeyGroups struct { } func (*awsRestxml_deserializeOpListKeyGroups) ID() string { return "OperationDeserializer" } func (m *awsRestxml_deserializeOpListKeyGroups) 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, awsRestxml_deserializeOpErrorListKeyGroups(response, &metadata) } output := &ListKeyGroupsOutput{} 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) err = awsRestxml_deserializeDocumentKeyGroupList(&output.KeyGroupList, decoder) 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(), } } return out, metadata, err } func awsRestxml_deserializeOpErrorListKeyGroups(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("InvalidArgument", errorCode): return awsRestxml_deserializeErrorInvalidArgument(response, errorBody) default: genericError := &smithy.GenericAPIError{ Code: errorCode, Message: errorMessage, } return genericError } } func awsRestxml_deserializeOpDocumentListKeyGroupsOutput(v **ListKeyGroupsOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *ListKeyGroupsOutput if *v == nil { sv = &ListKeyGroupsOutput{} } 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("KeyGroupList", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentKeyGroupList(&sv.KeyGroupList, nodeDecoder); err != nil { return err } default: // Do nothing and ignore the unexpected tag element err = decoder.Decoder.Skip() if err != nil { return err } } decoder = originalDecoder } *v = sv return nil } type awsRestxml_deserializeOpListOriginAccessControls struct { } func (*awsRestxml_deserializeOpListOriginAccessControls) ID() string { return "OperationDeserializer" } func (m *awsRestxml_deserializeOpListOriginAccessControls) 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, awsRestxml_deserializeOpErrorListOriginAccessControls(response, &metadata) } output := &ListOriginAccessControlsOutput{} 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) err = awsRestxml_deserializeDocumentOriginAccessControlList(&output.OriginAccessControlList, decoder) 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(), } } return out, metadata, err } func awsRestxml_deserializeOpErrorListOriginAccessControls(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("InvalidArgument", errorCode): return awsRestxml_deserializeErrorInvalidArgument(response, errorBody) default: genericError := &smithy.GenericAPIError{ Code: errorCode, Message: errorMessage, } return genericError } } func awsRestxml_deserializeOpDocumentListOriginAccessControlsOutput(v **ListOriginAccessControlsOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *ListOriginAccessControlsOutput if *v == nil { sv = &ListOriginAccessControlsOutput{} } 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("OriginAccessControlList", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentOriginAccessControlList(&sv.OriginAccessControlList, nodeDecoder); err != nil { return err } default: // Do nothing and ignore the unexpected tag element err = decoder.Decoder.Skip() if err != nil { return err } } decoder = originalDecoder } *v = sv return nil } type awsRestxml_deserializeOpListOriginRequestPolicies struct { } func (*awsRestxml_deserializeOpListOriginRequestPolicies) ID() string { return "OperationDeserializer" } func (m *awsRestxml_deserializeOpListOriginRequestPolicies) 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, awsRestxml_deserializeOpErrorListOriginRequestPolicies(response, &metadata) } output := &ListOriginRequestPoliciesOutput{} 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) err = awsRestxml_deserializeDocumentOriginRequestPolicyList(&output.OriginRequestPolicyList, decoder) 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(), } } return out, metadata, err } func awsRestxml_deserializeOpErrorListOriginRequestPolicies(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("AccessDenied", errorCode): return awsRestxml_deserializeErrorAccessDenied(response, errorBody) case strings.EqualFold("InvalidArgument", errorCode): return awsRestxml_deserializeErrorInvalidArgument(response, errorBody) case strings.EqualFold("NoSuchOriginRequestPolicy", errorCode): return awsRestxml_deserializeErrorNoSuchOriginRequestPolicy(response, errorBody) default: genericError := &smithy.GenericAPIError{ Code: errorCode, Message: errorMessage, } return genericError } } func awsRestxml_deserializeOpDocumentListOriginRequestPoliciesOutput(v **ListOriginRequestPoliciesOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *ListOriginRequestPoliciesOutput if *v == nil { sv = &ListOriginRequestPoliciesOutput{} } 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("OriginRequestPolicyList", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentOriginRequestPolicyList(&sv.OriginRequestPolicyList, nodeDecoder); err != nil { return err } default: // Do nothing and ignore the unexpected tag element err = decoder.Decoder.Skip() if err != nil { return err } } decoder = originalDecoder } *v = sv return nil } type awsRestxml_deserializeOpListPublicKeys struct { } func (*awsRestxml_deserializeOpListPublicKeys) ID() string { return "OperationDeserializer" } func (m *awsRestxml_deserializeOpListPublicKeys) 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, awsRestxml_deserializeOpErrorListPublicKeys(response, &metadata) } output := &ListPublicKeysOutput{} 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) err = awsRestxml_deserializeDocumentPublicKeyList(&output.PublicKeyList, decoder) 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(), } } return out, metadata, err } func awsRestxml_deserializeOpErrorListPublicKeys(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("InvalidArgument", errorCode): return awsRestxml_deserializeErrorInvalidArgument(response, errorBody) default: genericError := &smithy.GenericAPIError{ Code: errorCode, Message: errorMessage, } return genericError } } func awsRestxml_deserializeOpDocumentListPublicKeysOutput(v **ListPublicKeysOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *ListPublicKeysOutput if *v == nil { sv = &ListPublicKeysOutput{} } 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("PublicKeyList", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentPublicKeyList(&sv.PublicKeyList, nodeDecoder); err != nil { return err } default: // Do nothing and ignore the unexpected tag element err = decoder.Decoder.Skip() if err != nil { return err } } decoder = originalDecoder } *v = sv return nil } type awsRestxml_deserializeOpListRealtimeLogConfigs struct { } func (*awsRestxml_deserializeOpListRealtimeLogConfigs) ID() string { return "OperationDeserializer" } func (m *awsRestxml_deserializeOpListRealtimeLogConfigs) 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, awsRestxml_deserializeOpErrorListRealtimeLogConfigs(response, &metadata) } output := &ListRealtimeLogConfigsOutput{} 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) err = awsRestxml_deserializeDocumentRealtimeLogConfigs(&output.RealtimeLogConfigs, decoder) 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(), } } return out, metadata, err } func awsRestxml_deserializeOpErrorListRealtimeLogConfigs(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("AccessDenied", errorCode): return awsRestxml_deserializeErrorAccessDenied(response, errorBody) case strings.EqualFold("InvalidArgument", errorCode): return awsRestxml_deserializeErrorInvalidArgument(response, errorBody) case strings.EqualFold("NoSuchRealtimeLogConfig", errorCode): return awsRestxml_deserializeErrorNoSuchRealtimeLogConfig(response, errorBody) default: genericError := &smithy.GenericAPIError{ Code: errorCode, Message: errorMessage, } return genericError } } func awsRestxml_deserializeOpDocumentListRealtimeLogConfigsOutput(v **ListRealtimeLogConfigsOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *ListRealtimeLogConfigsOutput if *v == nil { sv = &ListRealtimeLogConfigsOutput{} } 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("RealtimeLogConfigs", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentRealtimeLogConfigs(&sv.RealtimeLogConfigs, nodeDecoder); err != nil { return err } default: // Do nothing and ignore the unexpected tag element err = decoder.Decoder.Skip() if err != nil { return err } } decoder = originalDecoder } *v = sv return nil } type awsRestxml_deserializeOpListResponseHeadersPolicies struct { } func (*awsRestxml_deserializeOpListResponseHeadersPolicies) ID() string { return "OperationDeserializer" } func (m *awsRestxml_deserializeOpListResponseHeadersPolicies) 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, awsRestxml_deserializeOpErrorListResponseHeadersPolicies(response, &metadata) } output := &ListResponseHeadersPoliciesOutput{} 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) err = awsRestxml_deserializeDocumentResponseHeadersPolicyList(&output.ResponseHeadersPolicyList, decoder) 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(), } } return out, metadata, err } func awsRestxml_deserializeOpErrorListResponseHeadersPolicies(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("AccessDenied", errorCode): return awsRestxml_deserializeErrorAccessDenied(response, errorBody) case strings.EqualFold("InvalidArgument", errorCode): return awsRestxml_deserializeErrorInvalidArgument(response, errorBody) case strings.EqualFold("NoSuchResponseHeadersPolicy", errorCode): return awsRestxml_deserializeErrorNoSuchResponseHeadersPolicy(response, errorBody) default: genericError := &smithy.GenericAPIError{ Code: errorCode, Message: errorMessage, } return genericError } } func awsRestxml_deserializeOpDocumentListResponseHeadersPoliciesOutput(v **ListResponseHeadersPoliciesOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *ListResponseHeadersPoliciesOutput if *v == nil { sv = &ListResponseHeadersPoliciesOutput{} } 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("ResponseHeadersPolicyList", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentResponseHeadersPolicyList(&sv.ResponseHeadersPolicyList, nodeDecoder); err != nil { return err } default: // Do nothing and ignore the unexpected tag element err = decoder.Decoder.Skip() if err != nil { return err } } decoder = originalDecoder } *v = sv return nil } type awsRestxml_deserializeOpListStreamingDistributions struct { } func (*awsRestxml_deserializeOpListStreamingDistributions) ID() string { return "OperationDeserializer" } func (m *awsRestxml_deserializeOpListStreamingDistributions) 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, awsRestxml_deserializeOpErrorListStreamingDistributions(response, &metadata) } output := &ListStreamingDistributionsOutput{} 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) err = awsRestxml_deserializeDocumentStreamingDistributionList(&output.StreamingDistributionList, decoder) 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(), } } return out, metadata, err } func awsRestxml_deserializeOpErrorListStreamingDistributions(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("InvalidArgument", errorCode): return awsRestxml_deserializeErrorInvalidArgument(response, errorBody) default: genericError := &smithy.GenericAPIError{ Code: errorCode, Message: errorMessage, } return genericError } } func awsRestxml_deserializeOpDocumentListStreamingDistributionsOutput(v **ListStreamingDistributionsOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *ListStreamingDistributionsOutput if *v == nil { sv = &ListStreamingDistributionsOutput{} } 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("StreamingDistributionList", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentStreamingDistributionList(&sv.StreamingDistributionList, nodeDecoder); err != nil { return err } default: // Do nothing and ignore the unexpected tag element err = decoder.Decoder.Skip() if err != nil { return err } } decoder = originalDecoder } *v = sv return nil } type awsRestxml_deserializeOpListTagsForResource struct { } func (*awsRestxml_deserializeOpListTagsForResource) ID() string { return "OperationDeserializer" } func (m *awsRestxml_deserializeOpListTagsForResource) 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, awsRestxml_deserializeOpErrorListTagsForResource(response, &metadata) } output := &ListTagsForResourceOutput{} 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) err = awsRestxml_deserializeDocumentTags(&output.Tags, decoder) 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(), } } return out, metadata, err } func awsRestxml_deserializeOpErrorListTagsForResource(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("AccessDenied", errorCode): return awsRestxml_deserializeErrorAccessDenied(response, errorBody) case strings.EqualFold("InvalidArgument", errorCode): return awsRestxml_deserializeErrorInvalidArgument(response, errorBody) case strings.EqualFold("InvalidTagging", errorCode): return awsRestxml_deserializeErrorInvalidTagging(response, errorBody) case strings.EqualFold("NoSuchResource", errorCode): return awsRestxml_deserializeErrorNoSuchResource(response, errorBody) default: genericError := &smithy.GenericAPIError{ Code: errorCode, Message: errorMessage, } return genericError } } func awsRestxml_deserializeOpDocumentListTagsForResourceOutput(v **ListTagsForResourceOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *ListTagsForResourceOutput if *v == nil { sv = &ListTagsForResourceOutput{} } 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("Tags", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentTags(&sv.Tags, nodeDecoder); err != nil { return err } default: // Do nothing and ignore the unexpected tag element err = decoder.Decoder.Skip() if err != nil { return err } } decoder = originalDecoder } *v = sv return nil } type awsRestxml_deserializeOpPublishFunction struct { } func (*awsRestxml_deserializeOpPublishFunction) ID() string { return "OperationDeserializer" } func (m *awsRestxml_deserializeOpPublishFunction) 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, awsRestxml_deserializeOpErrorPublishFunction(response, &metadata) } output := &PublishFunctionOutput{} 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) err = awsRestxml_deserializeDocumentFunctionSummary(&output.FunctionSummary, decoder) 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(), } } return out, metadata, err } func awsRestxml_deserializeOpErrorPublishFunction(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("InvalidArgument", errorCode): return awsRestxml_deserializeErrorInvalidArgument(response, errorBody) case strings.EqualFold("InvalidIfMatchVersion", errorCode): return awsRestxml_deserializeErrorInvalidIfMatchVersion(response, errorBody) case strings.EqualFold("NoSuchFunctionExists", errorCode): return awsRestxml_deserializeErrorNoSuchFunctionExists(response, errorBody) case strings.EqualFold("PreconditionFailed", errorCode): return awsRestxml_deserializeErrorPreconditionFailed(response, errorBody) case strings.EqualFold("UnsupportedOperation", errorCode): return awsRestxml_deserializeErrorUnsupportedOperation(response, errorBody) default: genericError := &smithy.GenericAPIError{ Code: errorCode, Message: errorMessage, } return genericError } } func awsRestxml_deserializeOpDocumentPublishFunctionOutput(v **PublishFunctionOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *PublishFunctionOutput if *v == nil { sv = &PublishFunctionOutput{} } 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("FunctionSummary", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentFunctionSummary(&sv.FunctionSummary, nodeDecoder); err != nil { return err } default: // Do nothing and ignore the unexpected tag element err = decoder.Decoder.Skip() if err != nil { return err } } decoder = originalDecoder } *v = sv return nil } type awsRestxml_deserializeOpTagResource struct { } func (*awsRestxml_deserializeOpTagResource) ID() string { return "OperationDeserializer" } func (m *awsRestxml_deserializeOpTagResource) 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, awsRestxml_deserializeOpErrorTagResource(response, &metadata) } output := &TagResourceOutput{} 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 awsRestxml_deserializeOpErrorTagResource(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("AccessDenied", errorCode): return awsRestxml_deserializeErrorAccessDenied(response, errorBody) case strings.EqualFold("InvalidArgument", errorCode): return awsRestxml_deserializeErrorInvalidArgument(response, errorBody) case strings.EqualFold("InvalidTagging", errorCode): return awsRestxml_deserializeErrorInvalidTagging(response, errorBody) case strings.EqualFold("NoSuchResource", errorCode): return awsRestxml_deserializeErrorNoSuchResource(response, errorBody) default: genericError := &smithy.GenericAPIError{ Code: errorCode, Message: errorMessage, } return genericError } } type awsRestxml_deserializeOpTestFunction struct { } func (*awsRestxml_deserializeOpTestFunction) ID() string { return "OperationDeserializer" } func (m *awsRestxml_deserializeOpTestFunction) 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, awsRestxml_deserializeOpErrorTestFunction(response, &metadata) } output := &TestFunctionOutput{} 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) err = awsRestxml_deserializeDocumentTestResult(&output.TestResult, decoder) 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(), } } return out, metadata, err } func awsRestxml_deserializeOpErrorTestFunction(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("InvalidArgument", errorCode): return awsRestxml_deserializeErrorInvalidArgument(response, errorBody) case strings.EqualFold("InvalidIfMatchVersion", errorCode): return awsRestxml_deserializeErrorInvalidIfMatchVersion(response, errorBody) case strings.EqualFold("NoSuchFunctionExists", errorCode): return awsRestxml_deserializeErrorNoSuchFunctionExists(response, errorBody) case strings.EqualFold("TestFunctionFailed", errorCode): return awsRestxml_deserializeErrorTestFunctionFailed(response, errorBody) case strings.EqualFold("UnsupportedOperation", errorCode): return awsRestxml_deserializeErrorUnsupportedOperation(response, errorBody) default: genericError := &smithy.GenericAPIError{ Code: errorCode, Message: errorMessage, } return genericError } } func awsRestxml_deserializeOpDocumentTestFunctionOutput(v **TestFunctionOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *TestFunctionOutput if *v == nil { sv = &TestFunctionOutput{} } 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("TestResult", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentTestResult(&sv.TestResult, nodeDecoder); err != nil { return err } default: // Do nothing and ignore the unexpected tag element err = decoder.Decoder.Skip() if err != nil { return err } } decoder = originalDecoder } *v = sv return nil } type awsRestxml_deserializeOpUntagResource struct { } func (*awsRestxml_deserializeOpUntagResource) ID() string { return "OperationDeserializer" } func (m *awsRestxml_deserializeOpUntagResource) 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, awsRestxml_deserializeOpErrorUntagResource(response, &metadata) } output := &UntagResourceOutput{} 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 awsRestxml_deserializeOpErrorUntagResource(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("AccessDenied", errorCode): return awsRestxml_deserializeErrorAccessDenied(response, errorBody) case strings.EqualFold("InvalidArgument", errorCode): return awsRestxml_deserializeErrorInvalidArgument(response, errorBody) case strings.EqualFold("InvalidTagging", errorCode): return awsRestxml_deserializeErrorInvalidTagging(response, errorBody) case strings.EqualFold("NoSuchResource", errorCode): return awsRestxml_deserializeErrorNoSuchResource(response, errorBody) default: genericError := &smithy.GenericAPIError{ Code: errorCode, Message: errorMessage, } return genericError } } type awsRestxml_deserializeOpUpdateCachePolicy struct { } func (*awsRestxml_deserializeOpUpdateCachePolicy) ID() string { return "OperationDeserializer" } func (m *awsRestxml_deserializeOpUpdateCachePolicy) 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, awsRestxml_deserializeOpErrorUpdateCachePolicy(response, &metadata) } output := &UpdateCachePolicyOutput{} out.Result = output err = awsRestxml_deserializeOpHttpBindingsUpdateCachePolicyOutput(output, response) if err != nil { return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} } 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) err = awsRestxml_deserializeDocumentCachePolicy(&output.CachePolicy, decoder) 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(), } } return out, metadata, err } func awsRestxml_deserializeOpErrorUpdateCachePolicy(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("AccessDenied", errorCode): return awsRestxml_deserializeErrorAccessDenied(response, errorBody) case strings.EqualFold("CachePolicyAlreadyExists", errorCode): return awsRestxml_deserializeErrorCachePolicyAlreadyExists(response, errorBody) case strings.EqualFold("IllegalUpdate", errorCode): return awsRestxml_deserializeErrorIllegalUpdate(response, errorBody) case strings.EqualFold("InconsistentQuantities", errorCode): return awsRestxml_deserializeErrorInconsistentQuantities(response, errorBody) case strings.EqualFold("InvalidArgument", errorCode): return awsRestxml_deserializeErrorInvalidArgument(response, errorBody) case strings.EqualFold("InvalidIfMatchVersion", errorCode): return awsRestxml_deserializeErrorInvalidIfMatchVersion(response, errorBody) case strings.EqualFold("NoSuchCachePolicy", errorCode): return awsRestxml_deserializeErrorNoSuchCachePolicy(response, errorBody) case strings.EqualFold("PreconditionFailed", errorCode): return awsRestxml_deserializeErrorPreconditionFailed(response, errorBody) case strings.EqualFold("TooManyCookiesInCachePolicy", errorCode): return awsRestxml_deserializeErrorTooManyCookiesInCachePolicy(response, errorBody) case strings.EqualFold("TooManyHeadersInCachePolicy", errorCode): return awsRestxml_deserializeErrorTooManyHeadersInCachePolicy(response, errorBody) case strings.EqualFold("TooManyQueryStringsInCachePolicy", errorCode): return awsRestxml_deserializeErrorTooManyQueryStringsInCachePolicy(response, errorBody) default: genericError := &smithy.GenericAPIError{ Code: errorCode, Message: errorMessage, } return genericError } } func awsRestxml_deserializeOpHttpBindingsUpdateCachePolicyOutput(v *UpdateCachePolicyOutput, response *smithyhttp.Response) error { if v == nil { return fmt.Errorf("unsupported deserialization for nil %T", v) } if headerValues := response.Header.Values("ETag"); len(headerValues) != 0 { headerValues[0] = strings.TrimSpace(headerValues[0]) v.ETag = ptr.String(headerValues[0]) } return nil } func awsRestxml_deserializeOpDocumentUpdateCachePolicyOutput(v **UpdateCachePolicyOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *UpdateCachePolicyOutput if *v == nil { sv = &UpdateCachePolicyOutput{} } 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("CachePolicy", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentCachePolicy(&sv.CachePolicy, nodeDecoder); err != nil { return err } default: // Do nothing and ignore the unexpected tag element err = decoder.Decoder.Skip() if err != nil { return err } } decoder = originalDecoder } *v = sv return nil } type awsRestxml_deserializeOpUpdateCloudFrontOriginAccessIdentity struct { } func (*awsRestxml_deserializeOpUpdateCloudFrontOriginAccessIdentity) ID() string { return "OperationDeserializer" } func (m *awsRestxml_deserializeOpUpdateCloudFrontOriginAccessIdentity) 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, awsRestxml_deserializeOpErrorUpdateCloudFrontOriginAccessIdentity(response, &metadata) } output := &UpdateCloudFrontOriginAccessIdentityOutput{} out.Result = output err = awsRestxml_deserializeOpHttpBindingsUpdateCloudFrontOriginAccessIdentityOutput(output, response) if err != nil { return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} } 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) err = awsRestxml_deserializeDocumentCloudFrontOriginAccessIdentity(&output.CloudFrontOriginAccessIdentity, decoder) 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(), } } return out, metadata, err } func awsRestxml_deserializeOpErrorUpdateCloudFrontOriginAccessIdentity(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("AccessDenied", errorCode): return awsRestxml_deserializeErrorAccessDenied(response, errorBody) case strings.EqualFold("IllegalUpdate", errorCode): return awsRestxml_deserializeErrorIllegalUpdate(response, errorBody) case strings.EqualFold("InconsistentQuantities", errorCode): return awsRestxml_deserializeErrorInconsistentQuantities(response, errorBody) case strings.EqualFold("InvalidArgument", errorCode): return awsRestxml_deserializeErrorInvalidArgument(response, errorBody) case strings.EqualFold("InvalidIfMatchVersion", errorCode): return awsRestxml_deserializeErrorInvalidIfMatchVersion(response, errorBody) case strings.EqualFold("MissingBody", errorCode): return awsRestxml_deserializeErrorMissingBody(response, errorBody) case strings.EqualFold("NoSuchCloudFrontOriginAccessIdentity", errorCode): return awsRestxml_deserializeErrorNoSuchCloudFrontOriginAccessIdentity(response, errorBody) case strings.EqualFold("PreconditionFailed", errorCode): return awsRestxml_deserializeErrorPreconditionFailed(response, errorBody) default: genericError := &smithy.GenericAPIError{ Code: errorCode, Message: errorMessage, } return genericError } } func awsRestxml_deserializeOpHttpBindingsUpdateCloudFrontOriginAccessIdentityOutput(v *UpdateCloudFrontOriginAccessIdentityOutput, response *smithyhttp.Response) error { if v == nil { return fmt.Errorf("unsupported deserialization for nil %T", v) } if headerValues := response.Header.Values("ETag"); len(headerValues) != 0 { headerValues[0] = strings.TrimSpace(headerValues[0]) v.ETag = ptr.String(headerValues[0]) } return nil } func awsRestxml_deserializeOpDocumentUpdateCloudFrontOriginAccessIdentityOutput(v **UpdateCloudFrontOriginAccessIdentityOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *UpdateCloudFrontOriginAccessIdentityOutput if *v == nil { sv = &UpdateCloudFrontOriginAccessIdentityOutput{} } 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("CloudFrontOriginAccessIdentity", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentCloudFrontOriginAccessIdentity(&sv.CloudFrontOriginAccessIdentity, nodeDecoder); err != nil { return err } default: // Do nothing and ignore the unexpected tag element err = decoder.Decoder.Skip() if err != nil { return err } } decoder = originalDecoder } *v = sv return nil } type awsRestxml_deserializeOpUpdateContinuousDeploymentPolicy struct { } func (*awsRestxml_deserializeOpUpdateContinuousDeploymentPolicy) ID() string { return "OperationDeserializer" } func (m *awsRestxml_deserializeOpUpdateContinuousDeploymentPolicy) 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, awsRestxml_deserializeOpErrorUpdateContinuousDeploymentPolicy(response, &metadata) } output := &UpdateContinuousDeploymentPolicyOutput{} out.Result = output err = awsRestxml_deserializeOpHttpBindingsUpdateContinuousDeploymentPolicyOutput(output, response) if err != nil { return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} } 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) err = awsRestxml_deserializeDocumentContinuousDeploymentPolicy(&output.ContinuousDeploymentPolicy, decoder) 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(), } } return out, metadata, err } func awsRestxml_deserializeOpErrorUpdateContinuousDeploymentPolicy(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("AccessDenied", errorCode): return awsRestxml_deserializeErrorAccessDenied(response, errorBody) case strings.EqualFold("InconsistentQuantities", errorCode): return awsRestxml_deserializeErrorInconsistentQuantities(response, errorBody) case strings.EqualFold("InvalidArgument", errorCode): return awsRestxml_deserializeErrorInvalidArgument(response, errorBody) case strings.EqualFold("InvalidIfMatchVersion", errorCode): return awsRestxml_deserializeErrorInvalidIfMatchVersion(response, errorBody) case strings.EqualFold("NoSuchContinuousDeploymentPolicy", errorCode): return awsRestxml_deserializeErrorNoSuchContinuousDeploymentPolicy(response, errorBody) case strings.EqualFold("PreconditionFailed", errorCode): return awsRestxml_deserializeErrorPreconditionFailed(response, errorBody) case strings.EqualFold("StagingDistributionInUse", errorCode): return awsRestxml_deserializeErrorStagingDistributionInUse(response, errorBody) default: genericError := &smithy.GenericAPIError{ Code: errorCode, Message: errorMessage, } return genericError } } func awsRestxml_deserializeOpHttpBindingsUpdateContinuousDeploymentPolicyOutput(v *UpdateContinuousDeploymentPolicyOutput, response *smithyhttp.Response) error { if v == nil { return fmt.Errorf("unsupported deserialization for nil %T", v) } if headerValues := response.Header.Values("ETag"); len(headerValues) != 0 { headerValues[0] = strings.TrimSpace(headerValues[0]) v.ETag = ptr.String(headerValues[0]) } return nil } func awsRestxml_deserializeOpDocumentUpdateContinuousDeploymentPolicyOutput(v **UpdateContinuousDeploymentPolicyOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *UpdateContinuousDeploymentPolicyOutput if *v == nil { sv = &UpdateContinuousDeploymentPolicyOutput{} } 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("ContinuousDeploymentPolicy", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentContinuousDeploymentPolicy(&sv.ContinuousDeploymentPolicy, nodeDecoder); err != nil { return err } default: // Do nothing and ignore the unexpected tag element err = decoder.Decoder.Skip() if err != nil { return err } } decoder = originalDecoder } *v = sv return nil } type awsRestxml_deserializeOpUpdateDistribution struct { } func (*awsRestxml_deserializeOpUpdateDistribution) ID() string { return "OperationDeserializer" } func (m *awsRestxml_deserializeOpUpdateDistribution) 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, awsRestxml_deserializeOpErrorUpdateDistribution(response, &metadata) } output := &UpdateDistributionOutput{} out.Result = output err = awsRestxml_deserializeOpHttpBindingsUpdateDistributionOutput(output, response) if err != nil { return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} } 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) err = awsRestxml_deserializeDocumentDistribution(&output.Distribution, decoder) 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(), } } return out, metadata, err } func awsRestxml_deserializeOpErrorUpdateDistribution(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("AccessDenied", errorCode): return awsRestxml_deserializeErrorAccessDenied(response, errorBody) case strings.EqualFold("CNAMEAlreadyExists", errorCode): return awsRestxml_deserializeErrorCNAMEAlreadyExists(response, errorBody) case strings.EqualFold("ContinuousDeploymentPolicyInUse", errorCode): return awsRestxml_deserializeErrorContinuousDeploymentPolicyInUse(response, errorBody) case strings.EqualFold("IllegalFieldLevelEncryptionConfigAssociationWithCacheBehavior", errorCode): return awsRestxml_deserializeErrorIllegalFieldLevelEncryptionConfigAssociationWithCacheBehavior(response, errorBody) case strings.EqualFold("IllegalOriginAccessConfiguration", errorCode): return awsRestxml_deserializeErrorIllegalOriginAccessConfiguration(response, errorBody) case strings.EqualFold("IllegalUpdate", errorCode): return awsRestxml_deserializeErrorIllegalUpdate(response, errorBody) case strings.EqualFold("InconsistentQuantities", errorCode): return awsRestxml_deserializeErrorInconsistentQuantities(response, errorBody) case strings.EqualFold("InvalidArgument", errorCode): return awsRestxml_deserializeErrorInvalidArgument(response, errorBody) case strings.EqualFold("InvalidDefaultRootObject", errorCode): return awsRestxml_deserializeErrorInvalidDefaultRootObject(response, errorBody) case strings.EqualFold("InvalidDomainNameForOriginAccessControl", errorCode): return awsRestxml_deserializeErrorInvalidDomainNameForOriginAccessControl(response, errorBody) case strings.EqualFold("InvalidErrorCode", errorCode): return awsRestxml_deserializeErrorInvalidErrorCode(response, errorBody) case strings.EqualFold("InvalidForwardCookies", errorCode): return awsRestxml_deserializeErrorInvalidForwardCookies(response, errorBody) case strings.EqualFold("InvalidFunctionAssociation", errorCode): return awsRestxml_deserializeErrorInvalidFunctionAssociation(response, errorBody) case strings.EqualFold("InvalidGeoRestrictionParameter", errorCode): return awsRestxml_deserializeErrorInvalidGeoRestrictionParameter(response, errorBody) case strings.EqualFold("InvalidHeadersForS3Origin", errorCode): return awsRestxml_deserializeErrorInvalidHeadersForS3Origin(response, errorBody) case strings.EqualFold("InvalidIfMatchVersion", errorCode): return awsRestxml_deserializeErrorInvalidIfMatchVersion(response, errorBody) case strings.EqualFold("InvalidLambdaFunctionAssociation", errorCode): return awsRestxml_deserializeErrorInvalidLambdaFunctionAssociation(response, errorBody) case strings.EqualFold("InvalidLocationCode", errorCode): return awsRestxml_deserializeErrorInvalidLocationCode(response, errorBody) case strings.EqualFold("InvalidMinimumProtocolVersion", errorCode): return awsRestxml_deserializeErrorInvalidMinimumProtocolVersion(response, errorBody) case strings.EqualFold("InvalidOriginAccessControl", errorCode): return awsRestxml_deserializeErrorInvalidOriginAccessControl(response, errorBody) case strings.EqualFold("InvalidOriginAccessIdentity", errorCode): return awsRestxml_deserializeErrorInvalidOriginAccessIdentity(response, errorBody) case strings.EqualFold("InvalidOriginKeepaliveTimeout", errorCode): return awsRestxml_deserializeErrorInvalidOriginKeepaliveTimeout(response, errorBody) case strings.EqualFold("InvalidOriginReadTimeout", errorCode): return awsRestxml_deserializeErrorInvalidOriginReadTimeout(response, errorBody) case strings.EqualFold("InvalidQueryStringParameters", errorCode): return awsRestxml_deserializeErrorInvalidQueryStringParameters(response, errorBody) case strings.EqualFold("InvalidRelativePath", errorCode): return awsRestxml_deserializeErrorInvalidRelativePath(response, errorBody) case strings.EqualFold("InvalidRequiredProtocol", errorCode): return awsRestxml_deserializeErrorInvalidRequiredProtocol(response, errorBody) case strings.EqualFold("InvalidResponseCode", errorCode): return awsRestxml_deserializeErrorInvalidResponseCode(response, errorBody) case strings.EqualFold("InvalidTTLOrder", errorCode): return awsRestxml_deserializeErrorInvalidTTLOrder(response, errorBody) case strings.EqualFold("InvalidViewerCertificate", errorCode): return awsRestxml_deserializeErrorInvalidViewerCertificate(response, errorBody) case strings.EqualFold("InvalidWebACLId", errorCode): return awsRestxml_deserializeErrorInvalidWebACLId(response, errorBody) case strings.EqualFold("MissingBody", errorCode): return awsRestxml_deserializeErrorMissingBody(response, errorBody) case strings.EqualFold("NoSuchCachePolicy", errorCode): return awsRestxml_deserializeErrorNoSuchCachePolicy(response, errorBody) case strings.EqualFold("NoSuchContinuousDeploymentPolicy", errorCode): return awsRestxml_deserializeErrorNoSuchContinuousDeploymentPolicy(response, errorBody) case strings.EqualFold("NoSuchDistribution", errorCode): return awsRestxml_deserializeErrorNoSuchDistribution(response, errorBody) case strings.EqualFold("NoSuchFieldLevelEncryptionConfig", errorCode): return awsRestxml_deserializeErrorNoSuchFieldLevelEncryptionConfig(response, errorBody) case strings.EqualFold("NoSuchOrigin", errorCode): return awsRestxml_deserializeErrorNoSuchOrigin(response, errorBody) case strings.EqualFold("NoSuchOriginRequestPolicy", errorCode): return awsRestxml_deserializeErrorNoSuchOriginRequestPolicy(response, errorBody) case strings.EqualFold("NoSuchRealtimeLogConfig", errorCode): return awsRestxml_deserializeErrorNoSuchRealtimeLogConfig(response, errorBody) case strings.EqualFold("NoSuchResponseHeadersPolicy", errorCode): return awsRestxml_deserializeErrorNoSuchResponseHeadersPolicy(response, errorBody) case strings.EqualFold("PreconditionFailed", errorCode): return awsRestxml_deserializeErrorPreconditionFailed(response, errorBody) case strings.EqualFold("RealtimeLogConfigOwnerMismatch", errorCode): return awsRestxml_deserializeErrorRealtimeLogConfigOwnerMismatch(response, errorBody) case strings.EqualFold("StagingDistributionInUse", errorCode): return awsRestxml_deserializeErrorStagingDistributionInUse(response, errorBody) case strings.EqualFold("TooManyCacheBehaviors", errorCode): return awsRestxml_deserializeErrorTooManyCacheBehaviors(response, errorBody) case strings.EqualFold("TooManyCertificates", errorCode): return awsRestxml_deserializeErrorTooManyCertificates(response, errorBody) case strings.EqualFold("TooManyCookieNamesInWhiteList", errorCode): return awsRestxml_deserializeErrorTooManyCookieNamesInWhiteList(response, errorBody) case strings.EqualFold("TooManyDistributionCNAMEs", errorCode): return awsRestxml_deserializeErrorTooManyDistributionCNAMEs(response, errorBody) case strings.EqualFold("TooManyDistributionsAssociatedToCachePolicy", errorCode): return awsRestxml_deserializeErrorTooManyDistributionsAssociatedToCachePolicy(response, errorBody) case strings.EqualFold("TooManyDistributionsAssociatedToFieldLevelEncryptionConfig", errorCode): return awsRestxml_deserializeErrorTooManyDistributionsAssociatedToFieldLevelEncryptionConfig(response, errorBody) case strings.EqualFold("TooManyDistributionsAssociatedToKeyGroup", errorCode): return awsRestxml_deserializeErrorTooManyDistributionsAssociatedToKeyGroup(response, errorBody) case strings.EqualFold("TooManyDistributionsAssociatedToOriginAccessControl", errorCode): return awsRestxml_deserializeErrorTooManyDistributionsAssociatedToOriginAccessControl(response, errorBody) case strings.EqualFold("TooManyDistributionsAssociatedToOriginRequestPolicy", errorCode): return awsRestxml_deserializeErrorTooManyDistributionsAssociatedToOriginRequestPolicy(response, errorBody) case strings.EqualFold("TooManyDistributionsAssociatedToResponseHeadersPolicy", errorCode): return awsRestxml_deserializeErrorTooManyDistributionsAssociatedToResponseHeadersPolicy(response, errorBody) case strings.EqualFold("TooManyDistributionsWithFunctionAssociations", errorCode): return awsRestxml_deserializeErrorTooManyDistributionsWithFunctionAssociations(response, errorBody) case strings.EqualFold("TooManyDistributionsWithLambdaAssociations", errorCode): return awsRestxml_deserializeErrorTooManyDistributionsWithLambdaAssociations(response, errorBody) case strings.EqualFold("TooManyDistributionsWithSingleFunctionARN", errorCode): return awsRestxml_deserializeErrorTooManyDistributionsWithSingleFunctionARN(response, errorBody) case strings.EqualFold("TooManyFunctionAssociations", errorCode): return awsRestxml_deserializeErrorTooManyFunctionAssociations(response, errorBody) case strings.EqualFold("TooManyHeadersInForwardedValues", errorCode): return awsRestxml_deserializeErrorTooManyHeadersInForwardedValues(response, errorBody) case strings.EqualFold("TooManyKeyGroupsAssociatedToDistribution", errorCode): return awsRestxml_deserializeErrorTooManyKeyGroupsAssociatedToDistribution(response, errorBody) case strings.EqualFold("TooManyLambdaFunctionAssociations", errorCode): return awsRestxml_deserializeErrorTooManyLambdaFunctionAssociations(response, errorBody) case strings.EqualFold("TooManyOriginCustomHeaders", errorCode): return awsRestxml_deserializeErrorTooManyOriginCustomHeaders(response, errorBody) case strings.EqualFold("TooManyOriginGroupsPerDistribution", errorCode): return awsRestxml_deserializeErrorTooManyOriginGroupsPerDistribution(response, errorBody) case strings.EqualFold("TooManyOrigins", errorCode): return awsRestxml_deserializeErrorTooManyOrigins(response, errorBody) case strings.EqualFold("TooManyQueryStringParameters", errorCode): return awsRestxml_deserializeErrorTooManyQueryStringParameters(response, errorBody) case strings.EqualFold("TooManyTrustedSigners", errorCode): return awsRestxml_deserializeErrorTooManyTrustedSigners(response, errorBody) case strings.EqualFold("TrustedKeyGroupDoesNotExist", errorCode): return awsRestxml_deserializeErrorTrustedKeyGroupDoesNotExist(response, errorBody) case strings.EqualFold("TrustedSignerDoesNotExist", errorCode): return awsRestxml_deserializeErrorTrustedSignerDoesNotExist(response, errorBody) default: genericError := &smithy.GenericAPIError{ Code: errorCode, Message: errorMessage, } return genericError } } func awsRestxml_deserializeOpHttpBindingsUpdateDistributionOutput(v *UpdateDistributionOutput, response *smithyhttp.Response) error { if v == nil { return fmt.Errorf("unsupported deserialization for nil %T", v) } if headerValues := response.Header.Values("ETag"); len(headerValues) != 0 { headerValues[0] = strings.TrimSpace(headerValues[0]) v.ETag = ptr.String(headerValues[0]) } return nil } func awsRestxml_deserializeOpDocumentUpdateDistributionOutput(v **UpdateDistributionOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *UpdateDistributionOutput if *v == nil { sv = &UpdateDistributionOutput{} } 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("Distribution", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentDistribution(&sv.Distribution, nodeDecoder); err != nil { return err } default: // Do nothing and ignore the unexpected tag element err = decoder.Decoder.Skip() if err != nil { return err } } decoder = originalDecoder } *v = sv return nil } type awsRestxml_deserializeOpUpdateDistributionWithStagingConfig struct { } func (*awsRestxml_deserializeOpUpdateDistributionWithStagingConfig) ID() string { return "OperationDeserializer" } func (m *awsRestxml_deserializeOpUpdateDistributionWithStagingConfig) 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, awsRestxml_deserializeOpErrorUpdateDistributionWithStagingConfig(response, &metadata) } output := &UpdateDistributionWithStagingConfigOutput{} out.Result = output err = awsRestxml_deserializeOpHttpBindingsUpdateDistributionWithStagingConfigOutput(output, response) if err != nil { return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} } 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) err = awsRestxml_deserializeDocumentDistribution(&output.Distribution, decoder) 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(), } } return out, metadata, err } func awsRestxml_deserializeOpErrorUpdateDistributionWithStagingConfig(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("AccessDenied", errorCode): return awsRestxml_deserializeErrorAccessDenied(response, errorBody) case strings.EqualFold("CNAMEAlreadyExists", errorCode): return awsRestxml_deserializeErrorCNAMEAlreadyExists(response, errorBody) case strings.EqualFold("IllegalFieldLevelEncryptionConfigAssociationWithCacheBehavior", errorCode): return awsRestxml_deserializeErrorIllegalFieldLevelEncryptionConfigAssociationWithCacheBehavior(response, errorBody) case strings.EqualFold("IllegalUpdate", errorCode): return awsRestxml_deserializeErrorIllegalUpdate(response, errorBody) case strings.EqualFold("InconsistentQuantities", errorCode): return awsRestxml_deserializeErrorInconsistentQuantities(response, errorBody) case strings.EqualFold("InvalidArgument", errorCode): return awsRestxml_deserializeErrorInvalidArgument(response, errorBody) case strings.EqualFold("InvalidDefaultRootObject", errorCode): return awsRestxml_deserializeErrorInvalidDefaultRootObject(response, errorBody) case strings.EqualFold("InvalidErrorCode", errorCode): return awsRestxml_deserializeErrorInvalidErrorCode(response, errorBody) case strings.EqualFold("InvalidForwardCookies", errorCode): return awsRestxml_deserializeErrorInvalidForwardCookies(response, errorBody) case strings.EqualFold("InvalidFunctionAssociation", errorCode): return awsRestxml_deserializeErrorInvalidFunctionAssociation(response, errorBody) case strings.EqualFold("InvalidGeoRestrictionParameter", errorCode): return awsRestxml_deserializeErrorInvalidGeoRestrictionParameter(response, errorBody) case strings.EqualFold("InvalidHeadersForS3Origin", errorCode): return awsRestxml_deserializeErrorInvalidHeadersForS3Origin(response, errorBody) case strings.EqualFold("InvalidIfMatchVersion", errorCode): return awsRestxml_deserializeErrorInvalidIfMatchVersion(response, errorBody) case strings.EqualFold("InvalidLambdaFunctionAssociation", errorCode): return awsRestxml_deserializeErrorInvalidLambdaFunctionAssociation(response, errorBody) case strings.EqualFold("InvalidLocationCode", errorCode): return awsRestxml_deserializeErrorInvalidLocationCode(response, errorBody) case strings.EqualFold("InvalidMinimumProtocolVersion", errorCode): return awsRestxml_deserializeErrorInvalidMinimumProtocolVersion(response, errorBody) case strings.EqualFold("InvalidOriginAccessControl", errorCode): return awsRestxml_deserializeErrorInvalidOriginAccessControl(response, errorBody) case strings.EqualFold("InvalidOriginAccessIdentity", errorCode): return awsRestxml_deserializeErrorInvalidOriginAccessIdentity(response, errorBody) case strings.EqualFold("InvalidOriginKeepaliveTimeout", errorCode): return awsRestxml_deserializeErrorInvalidOriginKeepaliveTimeout(response, errorBody) case strings.EqualFold("InvalidOriginReadTimeout", errorCode): return awsRestxml_deserializeErrorInvalidOriginReadTimeout(response, errorBody) case strings.EqualFold("InvalidQueryStringParameters", errorCode): return awsRestxml_deserializeErrorInvalidQueryStringParameters(response, errorBody) case strings.EqualFold("InvalidRelativePath", errorCode): return awsRestxml_deserializeErrorInvalidRelativePath(response, errorBody) case strings.EqualFold("InvalidRequiredProtocol", errorCode): return awsRestxml_deserializeErrorInvalidRequiredProtocol(response, errorBody) case strings.EqualFold("InvalidResponseCode", errorCode): return awsRestxml_deserializeErrorInvalidResponseCode(response, errorBody) case strings.EqualFold("InvalidTTLOrder", errorCode): return awsRestxml_deserializeErrorInvalidTTLOrder(response, errorBody) case strings.EqualFold("InvalidViewerCertificate", errorCode): return awsRestxml_deserializeErrorInvalidViewerCertificate(response, errorBody) case strings.EqualFold("InvalidWebACLId", errorCode): return awsRestxml_deserializeErrorInvalidWebACLId(response, errorBody) case strings.EqualFold("MissingBody", errorCode): return awsRestxml_deserializeErrorMissingBody(response, errorBody) case strings.EqualFold("NoSuchCachePolicy", errorCode): return awsRestxml_deserializeErrorNoSuchCachePolicy(response, errorBody) case strings.EqualFold("NoSuchDistribution", errorCode): return awsRestxml_deserializeErrorNoSuchDistribution(response, errorBody) case strings.EqualFold("NoSuchFieldLevelEncryptionConfig", errorCode): return awsRestxml_deserializeErrorNoSuchFieldLevelEncryptionConfig(response, errorBody) case strings.EqualFold("NoSuchOrigin", errorCode): return awsRestxml_deserializeErrorNoSuchOrigin(response, errorBody) case strings.EqualFold("NoSuchOriginRequestPolicy", errorCode): return awsRestxml_deserializeErrorNoSuchOriginRequestPolicy(response, errorBody) case strings.EqualFold("NoSuchRealtimeLogConfig", errorCode): return awsRestxml_deserializeErrorNoSuchRealtimeLogConfig(response, errorBody) case strings.EqualFold("NoSuchResponseHeadersPolicy", errorCode): return awsRestxml_deserializeErrorNoSuchResponseHeadersPolicy(response, errorBody) case strings.EqualFold("PreconditionFailed", errorCode): return awsRestxml_deserializeErrorPreconditionFailed(response, errorBody) case strings.EqualFold("RealtimeLogConfigOwnerMismatch", errorCode): return awsRestxml_deserializeErrorRealtimeLogConfigOwnerMismatch(response, errorBody) case strings.EqualFold("TooManyCacheBehaviors", errorCode): return awsRestxml_deserializeErrorTooManyCacheBehaviors(response, errorBody) case strings.EqualFold("TooManyCertificates", errorCode): return awsRestxml_deserializeErrorTooManyCertificates(response, errorBody) case strings.EqualFold("TooManyCookieNamesInWhiteList", errorCode): return awsRestxml_deserializeErrorTooManyCookieNamesInWhiteList(response, errorBody) case strings.EqualFold("TooManyDistributionCNAMEs", errorCode): return awsRestxml_deserializeErrorTooManyDistributionCNAMEs(response, errorBody) case strings.EqualFold("TooManyDistributionsAssociatedToCachePolicy", errorCode): return awsRestxml_deserializeErrorTooManyDistributionsAssociatedToCachePolicy(response, errorBody) case strings.EqualFold("TooManyDistributionsAssociatedToFieldLevelEncryptionConfig", errorCode): return awsRestxml_deserializeErrorTooManyDistributionsAssociatedToFieldLevelEncryptionConfig(response, errorBody) case strings.EqualFold("TooManyDistributionsAssociatedToKeyGroup", errorCode): return awsRestxml_deserializeErrorTooManyDistributionsAssociatedToKeyGroup(response, errorBody) case strings.EqualFold("TooManyDistributionsAssociatedToOriginAccessControl", errorCode): return awsRestxml_deserializeErrorTooManyDistributionsAssociatedToOriginAccessControl(response, errorBody) case strings.EqualFold("TooManyDistributionsAssociatedToOriginRequestPolicy", errorCode): return awsRestxml_deserializeErrorTooManyDistributionsAssociatedToOriginRequestPolicy(response, errorBody) case strings.EqualFold("TooManyDistributionsAssociatedToResponseHeadersPolicy", errorCode): return awsRestxml_deserializeErrorTooManyDistributionsAssociatedToResponseHeadersPolicy(response, errorBody) case strings.EqualFold("TooManyDistributionsWithFunctionAssociations", errorCode): return awsRestxml_deserializeErrorTooManyDistributionsWithFunctionAssociations(response, errorBody) case strings.EqualFold("TooManyDistributionsWithLambdaAssociations", errorCode): return awsRestxml_deserializeErrorTooManyDistributionsWithLambdaAssociations(response, errorBody) case strings.EqualFold("TooManyDistributionsWithSingleFunctionARN", errorCode): return awsRestxml_deserializeErrorTooManyDistributionsWithSingleFunctionARN(response, errorBody) case strings.EqualFold("TooManyFunctionAssociations", errorCode): return awsRestxml_deserializeErrorTooManyFunctionAssociations(response, errorBody) case strings.EqualFold("TooManyHeadersInForwardedValues", errorCode): return awsRestxml_deserializeErrorTooManyHeadersInForwardedValues(response, errorBody) case strings.EqualFold("TooManyKeyGroupsAssociatedToDistribution", errorCode): return awsRestxml_deserializeErrorTooManyKeyGroupsAssociatedToDistribution(response, errorBody) case strings.EqualFold("TooManyLambdaFunctionAssociations", errorCode): return awsRestxml_deserializeErrorTooManyLambdaFunctionAssociations(response, errorBody) case strings.EqualFold("TooManyOriginCustomHeaders", errorCode): return awsRestxml_deserializeErrorTooManyOriginCustomHeaders(response, errorBody) case strings.EqualFold("TooManyOriginGroupsPerDistribution", errorCode): return awsRestxml_deserializeErrorTooManyOriginGroupsPerDistribution(response, errorBody) case strings.EqualFold("TooManyOrigins", errorCode): return awsRestxml_deserializeErrorTooManyOrigins(response, errorBody) case strings.EqualFold("TooManyQueryStringParameters", errorCode): return awsRestxml_deserializeErrorTooManyQueryStringParameters(response, errorBody) case strings.EqualFold("TooManyTrustedSigners", errorCode): return awsRestxml_deserializeErrorTooManyTrustedSigners(response, errorBody) case strings.EqualFold("TrustedKeyGroupDoesNotExist", errorCode): return awsRestxml_deserializeErrorTrustedKeyGroupDoesNotExist(response, errorBody) case strings.EqualFold("TrustedSignerDoesNotExist", errorCode): return awsRestxml_deserializeErrorTrustedSignerDoesNotExist(response, errorBody) default: genericError := &smithy.GenericAPIError{ Code: errorCode, Message: errorMessage, } return genericError } } func awsRestxml_deserializeOpHttpBindingsUpdateDistributionWithStagingConfigOutput(v *UpdateDistributionWithStagingConfigOutput, response *smithyhttp.Response) error { if v == nil { return fmt.Errorf("unsupported deserialization for nil %T", v) } if headerValues := response.Header.Values("ETag"); len(headerValues) != 0 { headerValues[0] = strings.TrimSpace(headerValues[0]) v.ETag = ptr.String(headerValues[0]) } return nil } func awsRestxml_deserializeOpDocumentUpdateDistributionWithStagingConfigOutput(v **UpdateDistributionWithStagingConfigOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *UpdateDistributionWithStagingConfigOutput if *v == nil { sv = &UpdateDistributionWithStagingConfigOutput{} } 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("Distribution", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentDistribution(&sv.Distribution, nodeDecoder); err != nil { return err } default: // Do nothing and ignore the unexpected tag element err = decoder.Decoder.Skip() if err != nil { return err } } decoder = originalDecoder } *v = sv return nil } type awsRestxml_deserializeOpUpdateFieldLevelEncryptionConfig struct { } func (*awsRestxml_deserializeOpUpdateFieldLevelEncryptionConfig) ID() string { return "OperationDeserializer" } func (m *awsRestxml_deserializeOpUpdateFieldLevelEncryptionConfig) 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, awsRestxml_deserializeOpErrorUpdateFieldLevelEncryptionConfig(response, &metadata) } output := &UpdateFieldLevelEncryptionConfigOutput{} out.Result = output err = awsRestxml_deserializeOpHttpBindingsUpdateFieldLevelEncryptionConfigOutput(output, response) if err != nil { return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} } 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) err = awsRestxml_deserializeDocumentFieldLevelEncryption(&output.FieldLevelEncryption, decoder) 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(), } } return out, metadata, err } func awsRestxml_deserializeOpErrorUpdateFieldLevelEncryptionConfig(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("AccessDenied", errorCode): return awsRestxml_deserializeErrorAccessDenied(response, errorBody) case strings.EqualFold("IllegalUpdate", errorCode): return awsRestxml_deserializeErrorIllegalUpdate(response, errorBody) case strings.EqualFold("InconsistentQuantities", errorCode): return awsRestxml_deserializeErrorInconsistentQuantities(response, errorBody) case strings.EqualFold("InvalidArgument", errorCode): return awsRestxml_deserializeErrorInvalidArgument(response, errorBody) case strings.EqualFold("InvalidIfMatchVersion", errorCode): return awsRestxml_deserializeErrorInvalidIfMatchVersion(response, errorBody) case strings.EqualFold("NoSuchFieldLevelEncryptionConfig", errorCode): return awsRestxml_deserializeErrorNoSuchFieldLevelEncryptionConfig(response, errorBody) case strings.EqualFold("NoSuchFieldLevelEncryptionProfile", errorCode): return awsRestxml_deserializeErrorNoSuchFieldLevelEncryptionProfile(response, errorBody) case strings.EqualFold("PreconditionFailed", errorCode): return awsRestxml_deserializeErrorPreconditionFailed(response, errorBody) case strings.EqualFold("QueryArgProfileEmpty", errorCode): return awsRestxml_deserializeErrorQueryArgProfileEmpty(response, errorBody) case strings.EqualFold("TooManyFieldLevelEncryptionContentTypeProfiles", errorCode): return awsRestxml_deserializeErrorTooManyFieldLevelEncryptionContentTypeProfiles(response, errorBody) case strings.EqualFold("TooManyFieldLevelEncryptionQueryArgProfiles", errorCode): return awsRestxml_deserializeErrorTooManyFieldLevelEncryptionQueryArgProfiles(response, errorBody) default: genericError := &smithy.GenericAPIError{ Code: errorCode, Message: errorMessage, } return genericError } } func awsRestxml_deserializeOpHttpBindingsUpdateFieldLevelEncryptionConfigOutput(v *UpdateFieldLevelEncryptionConfigOutput, response *smithyhttp.Response) error { if v == nil { return fmt.Errorf("unsupported deserialization for nil %T", v) } if headerValues := response.Header.Values("ETag"); len(headerValues) != 0 { headerValues[0] = strings.TrimSpace(headerValues[0]) v.ETag = ptr.String(headerValues[0]) } return nil } func awsRestxml_deserializeOpDocumentUpdateFieldLevelEncryptionConfigOutput(v **UpdateFieldLevelEncryptionConfigOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *UpdateFieldLevelEncryptionConfigOutput if *v == nil { sv = &UpdateFieldLevelEncryptionConfigOutput{} } 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("FieldLevelEncryption", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentFieldLevelEncryption(&sv.FieldLevelEncryption, nodeDecoder); err != nil { return err } default: // Do nothing and ignore the unexpected tag element err = decoder.Decoder.Skip() if err != nil { return err } } decoder = originalDecoder } *v = sv return nil } type awsRestxml_deserializeOpUpdateFieldLevelEncryptionProfile struct { } func (*awsRestxml_deserializeOpUpdateFieldLevelEncryptionProfile) ID() string { return "OperationDeserializer" } func (m *awsRestxml_deserializeOpUpdateFieldLevelEncryptionProfile) 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, awsRestxml_deserializeOpErrorUpdateFieldLevelEncryptionProfile(response, &metadata) } output := &UpdateFieldLevelEncryptionProfileOutput{} out.Result = output err = awsRestxml_deserializeOpHttpBindingsUpdateFieldLevelEncryptionProfileOutput(output, response) if err != nil { return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} } 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) err = awsRestxml_deserializeDocumentFieldLevelEncryptionProfile(&output.FieldLevelEncryptionProfile, decoder) 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(), } } return out, metadata, err } func awsRestxml_deserializeOpErrorUpdateFieldLevelEncryptionProfile(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("AccessDenied", errorCode): return awsRestxml_deserializeErrorAccessDenied(response, errorBody) case strings.EqualFold("FieldLevelEncryptionProfileAlreadyExists", errorCode): return awsRestxml_deserializeErrorFieldLevelEncryptionProfileAlreadyExists(response, errorBody) case strings.EqualFold("FieldLevelEncryptionProfileSizeExceeded", errorCode): return awsRestxml_deserializeErrorFieldLevelEncryptionProfileSizeExceeded(response, errorBody) case strings.EqualFold("IllegalUpdate", errorCode): return awsRestxml_deserializeErrorIllegalUpdate(response, errorBody) case strings.EqualFold("InconsistentQuantities", errorCode): return awsRestxml_deserializeErrorInconsistentQuantities(response, errorBody) case strings.EqualFold("InvalidArgument", errorCode): return awsRestxml_deserializeErrorInvalidArgument(response, errorBody) case strings.EqualFold("InvalidIfMatchVersion", errorCode): return awsRestxml_deserializeErrorInvalidIfMatchVersion(response, errorBody) case strings.EqualFold("NoSuchFieldLevelEncryptionProfile", errorCode): return awsRestxml_deserializeErrorNoSuchFieldLevelEncryptionProfile(response, errorBody) case strings.EqualFold("NoSuchPublicKey", errorCode): return awsRestxml_deserializeErrorNoSuchPublicKey(response, errorBody) case strings.EqualFold("PreconditionFailed", errorCode): return awsRestxml_deserializeErrorPreconditionFailed(response, errorBody) case strings.EqualFold("TooManyFieldLevelEncryptionEncryptionEntities", errorCode): return awsRestxml_deserializeErrorTooManyFieldLevelEncryptionEncryptionEntities(response, errorBody) case strings.EqualFold("TooManyFieldLevelEncryptionFieldPatterns", errorCode): return awsRestxml_deserializeErrorTooManyFieldLevelEncryptionFieldPatterns(response, errorBody) default: genericError := &smithy.GenericAPIError{ Code: errorCode, Message: errorMessage, } return genericError } } func awsRestxml_deserializeOpHttpBindingsUpdateFieldLevelEncryptionProfileOutput(v *UpdateFieldLevelEncryptionProfileOutput, response *smithyhttp.Response) error { if v == nil { return fmt.Errorf("unsupported deserialization for nil %T", v) } if headerValues := response.Header.Values("ETag"); len(headerValues) != 0 { headerValues[0] = strings.TrimSpace(headerValues[0]) v.ETag = ptr.String(headerValues[0]) } return nil } func awsRestxml_deserializeOpDocumentUpdateFieldLevelEncryptionProfileOutput(v **UpdateFieldLevelEncryptionProfileOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *UpdateFieldLevelEncryptionProfileOutput if *v == nil { sv = &UpdateFieldLevelEncryptionProfileOutput{} } 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("FieldLevelEncryptionProfile", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentFieldLevelEncryptionProfile(&sv.FieldLevelEncryptionProfile, nodeDecoder); err != nil { return err } default: // Do nothing and ignore the unexpected tag element err = decoder.Decoder.Skip() if err != nil { return err } } decoder = originalDecoder } *v = sv return nil } type awsRestxml_deserializeOpUpdateFunction struct { } func (*awsRestxml_deserializeOpUpdateFunction) ID() string { return "OperationDeserializer" } func (m *awsRestxml_deserializeOpUpdateFunction) 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, awsRestxml_deserializeOpErrorUpdateFunction(response, &metadata) } output := &UpdateFunctionOutput{} out.Result = output err = awsRestxml_deserializeOpHttpBindingsUpdateFunctionOutput(output, response) if err != nil { return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} } 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) err = awsRestxml_deserializeDocumentFunctionSummary(&output.FunctionSummary, decoder) 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(), } } return out, metadata, err } func awsRestxml_deserializeOpErrorUpdateFunction(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("FunctionSizeLimitExceeded", errorCode): return awsRestxml_deserializeErrorFunctionSizeLimitExceeded(response, errorBody) case strings.EqualFold("InvalidArgument", errorCode): return awsRestxml_deserializeErrorInvalidArgument(response, errorBody) case strings.EqualFold("InvalidIfMatchVersion", errorCode): return awsRestxml_deserializeErrorInvalidIfMatchVersion(response, errorBody) case strings.EqualFold("NoSuchFunctionExists", errorCode): return awsRestxml_deserializeErrorNoSuchFunctionExists(response, errorBody) case strings.EqualFold("PreconditionFailed", errorCode): return awsRestxml_deserializeErrorPreconditionFailed(response, errorBody) case strings.EqualFold("UnsupportedOperation", errorCode): return awsRestxml_deserializeErrorUnsupportedOperation(response, errorBody) default: genericError := &smithy.GenericAPIError{ Code: errorCode, Message: errorMessage, } return genericError } } func awsRestxml_deserializeOpHttpBindingsUpdateFunctionOutput(v *UpdateFunctionOutput, response *smithyhttp.Response) error { if v == nil { return fmt.Errorf("unsupported deserialization for nil %T", v) } if headerValues := response.Header.Values("ETtag"); len(headerValues) != 0 { headerValues[0] = strings.TrimSpace(headerValues[0]) v.ETag = ptr.String(headerValues[0]) } return nil } func awsRestxml_deserializeOpDocumentUpdateFunctionOutput(v **UpdateFunctionOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *UpdateFunctionOutput if *v == nil { sv = &UpdateFunctionOutput{} } 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("FunctionSummary", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentFunctionSummary(&sv.FunctionSummary, nodeDecoder); err != nil { return err } default: // Do nothing and ignore the unexpected tag element err = decoder.Decoder.Skip() if err != nil { return err } } decoder = originalDecoder } *v = sv return nil } type awsRestxml_deserializeOpUpdateKeyGroup struct { } func (*awsRestxml_deserializeOpUpdateKeyGroup) ID() string { return "OperationDeserializer" } func (m *awsRestxml_deserializeOpUpdateKeyGroup) 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, awsRestxml_deserializeOpErrorUpdateKeyGroup(response, &metadata) } output := &UpdateKeyGroupOutput{} out.Result = output err = awsRestxml_deserializeOpHttpBindingsUpdateKeyGroupOutput(output, response) if err != nil { return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} } 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) err = awsRestxml_deserializeDocumentKeyGroup(&output.KeyGroup, decoder) 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(), } } return out, metadata, err } func awsRestxml_deserializeOpErrorUpdateKeyGroup(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("InvalidArgument", errorCode): return awsRestxml_deserializeErrorInvalidArgument(response, errorBody) case strings.EqualFold("InvalidIfMatchVersion", errorCode): return awsRestxml_deserializeErrorInvalidIfMatchVersion(response, errorBody) case strings.EqualFold("KeyGroupAlreadyExists", errorCode): return awsRestxml_deserializeErrorKeyGroupAlreadyExists(response, errorBody) case strings.EqualFold("NoSuchResource", errorCode): return awsRestxml_deserializeErrorNoSuchResource(response, errorBody) case strings.EqualFold("PreconditionFailed", errorCode): return awsRestxml_deserializeErrorPreconditionFailed(response, errorBody) case strings.EqualFold("TooManyPublicKeysInKeyGroup", errorCode): return awsRestxml_deserializeErrorTooManyPublicKeysInKeyGroup(response, errorBody) default: genericError := &smithy.GenericAPIError{ Code: errorCode, Message: errorMessage, } return genericError } } func awsRestxml_deserializeOpHttpBindingsUpdateKeyGroupOutput(v *UpdateKeyGroupOutput, response *smithyhttp.Response) error { if v == nil { return fmt.Errorf("unsupported deserialization for nil %T", v) } if headerValues := response.Header.Values("ETag"); len(headerValues) != 0 { headerValues[0] = strings.TrimSpace(headerValues[0]) v.ETag = ptr.String(headerValues[0]) } return nil } func awsRestxml_deserializeOpDocumentUpdateKeyGroupOutput(v **UpdateKeyGroupOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *UpdateKeyGroupOutput if *v == nil { sv = &UpdateKeyGroupOutput{} } 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("KeyGroup", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentKeyGroup(&sv.KeyGroup, nodeDecoder); err != nil { return err } default: // Do nothing and ignore the unexpected tag element err = decoder.Decoder.Skip() if err != nil { return err } } decoder = originalDecoder } *v = sv return nil } type awsRestxml_deserializeOpUpdateOriginAccessControl struct { } func (*awsRestxml_deserializeOpUpdateOriginAccessControl) ID() string { return "OperationDeserializer" } func (m *awsRestxml_deserializeOpUpdateOriginAccessControl) 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, awsRestxml_deserializeOpErrorUpdateOriginAccessControl(response, &metadata) } output := &UpdateOriginAccessControlOutput{} out.Result = output err = awsRestxml_deserializeOpHttpBindingsUpdateOriginAccessControlOutput(output, response) if err != nil { return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} } 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) err = awsRestxml_deserializeDocumentOriginAccessControl(&output.OriginAccessControl, decoder) 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(), } } return out, metadata, err } func awsRestxml_deserializeOpErrorUpdateOriginAccessControl(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("AccessDenied", errorCode): return awsRestxml_deserializeErrorAccessDenied(response, errorBody) case strings.EqualFold("IllegalUpdate", errorCode): return awsRestxml_deserializeErrorIllegalUpdate(response, errorBody) case strings.EqualFold("InvalidArgument", errorCode): return awsRestxml_deserializeErrorInvalidArgument(response, errorBody) case strings.EqualFold("InvalidIfMatchVersion", errorCode): return awsRestxml_deserializeErrorInvalidIfMatchVersion(response, errorBody) case strings.EqualFold("NoSuchOriginAccessControl", errorCode): return awsRestxml_deserializeErrorNoSuchOriginAccessControl(response, errorBody) case strings.EqualFold("OriginAccessControlAlreadyExists", errorCode): return awsRestxml_deserializeErrorOriginAccessControlAlreadyExists(response, errorBody) case strings.EqualFold("PreconditionFailed", errorCode): return awsRestxml_deserializeErrorPreconditionFailed(response, errorBody) default: genericError := &smithy.GenericAPIError{ Code: errorCode, Message: errorMessage, } return genericError } } func awsRestxml_deserializeOpHttpBindingsUpdateOriginAccessControlOutput(v *UpdateOriginAccessControlOutput, response *smithyhttp.Response) error { if v == nil { return fmt.Errorf("unsupported deserialization for nil %T", v) } if headerValues := response.Header.Values("ETag"); len(headerValues) != 0 { headerValues[0] = strings.TrimSpace(headerValues[0]) v.ETag = ptr.String(headerValues[0]) } return nil } func awsRestxml_deserializeOpDocumentUpdateOriginAccessControlOutput(v **UpdateOriginAccessControlOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *UpdateOriginAccessControlOutput if *v == nil { sv = &UpdateOriginAccessControlOutput{} } 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("OriginAccessControl", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentOriginAccessControl(&sv.OriginAccessControl, nodeDecoder); err != nil { return err } default: // Do nothing and ignore the unexpected tag element err = decoder.Decoder.Skip() if err != nil { return err } } decoder = originalDecoder } *v = sv return nil } type awsRestxml_deserializeOpUpdateOriginRequestPolicy struct { } func (*awsRestxml_deserializeOpUpdateOriginRequestPolicy) ID() string { return "OperationDeserializer" } func (m *awsRestxml_deserializeOpUpdateOriginRequestPolicy) 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, awsRestxml_deserializeOpErrorUpdateOriginRequestPolicy(response, &metadata) } output := &UpdateOriginRequestPolicyOutput{} out.Result = output err = awsRestxml_deserializeOpHttpBindingsUpdateOriginRequestPolicyOutput(output, response) if err != nil { return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} } 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) err = awsRestxml_deserializeDocumentOriginRequestPolicy(&output.OriginRequestPolicy, decoder) 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(), } } return out, metadata, err } func awsRestxml_deserializeOpErrorUpdateOriginRequestPolicy(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("AccessDenied", errorCode): return awsRestxml_deserializeErrorAccessDenied(response, errorBody) case strings.EqualFold("IllegalUpdate", errorCode): return awsRestxml_deserializeErrorIllegalUpdate(response, errorBody) case strings.EqualFold("InconsistentQuantities", errorCode): return awsRestxml_deserializeErrorInconsistentQuantities(response, errorBody) case strings.EqualFold("InvalidArgument", errorCode): return awsRestxml_deserializeErrorInvalidArgument(response, errorBody) case strings.EqualFold("InvalidIfMatchVersion", errorCode): return awsRestxml_deserializeErrorInvalidIfMatchVersion(response, errorBody) case strings.EqualFold("NoSuchOriginRequestPolicy", errorCode): return awsRestxml_deserializeErrorNoSuchOriginRequestPolicy(response, errorBody) case strings.EqualFold("OriginRequestPolicyAlreadyExists", errorCode): return awsRestxml_deserializeErrorOriginRequestPolicyAlreadyExists(response, errorBody) case strings.EqualFold("PreconditionFailed", errorCode): return awsRestxml_deserializeErrorPreconditionFailed(response, errorBody) case strings.EqualFold("TooManyCookiesInOriginRequestPolicy", errorCode): return awsRestxml_deserializeErrorTooManyCookiesInOriginRequestPolicy(response, errorBody) case strings.EqualFold("TooManyHeadersInOriginRequestPolicy", errorCode): return awsRestxml_deserializeErrorTooManyHeadersInOriginRequestPolicy(response, errorBody) case strings.EqualFold("TooManyQueryStringsInOriginRequestPolicy", errorCode): return awsRestxml_deserializeErrorTooManyQueryStringsInOriginRequestPolicy(response, errorBody) default: genericError := &smithy.GenericAPIError{ Code: errorCode, Message: errorMessage, } return genericError } } func awsRestxml_deserializeOpHttpBindingsUpdateOriginRequestPolicyOutput(v *UpdateOriginRequestPolicyOutput, response *smithyhttp.Response) error { if v == nil { return fmt.Errorf("unsupported deserialization for nil %T", v) } if headerValues := response.Header.Values("ETag"); len(headerValues) != 0 { headerValues[0] = strings.TrimSpace(headerValues[0]) v.ETag = ptr.String(headerValues[0]) } return nil } func awsRestxml_deserializeOpDocumentUpdateOriginRequestPolicyOutput(v **UpdateOriginRequestPolicyOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *UpdateOriginRequestPolicyOutput if *v == nil { sv = &UpdateOriginRequestPolicyOutput{} } 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("OriginRequestPolicy", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentOriginRequestPolicy(&sv.OriginRequestPolicy, nodeDecoder); err != nil { return err } default: // Do nothing and ignore the unexpected tag element err = decoder.Decoder.Skip() if err != nil { return err } } decoder = originalDecoder } *v = sv return nil } type awsRestxml_deserializeOpUpdatePublicKey struct { } func (*awsRestxml_deserializeOpUpdatePublicKey) ID() string { return "OperationDeserializer" } func (m *awsRestxml_deserializeOpUpdatePublicKey) 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, awsRestxml_deserializeOpErrorUpdatePublicKey(response, &metadata) } output := &UpdatePublicKeyOutput{} out.Result = output err = awsRestxml_deserializeOpHttpBindingsUpdatePublicKeyOutput(output, response) if err != nil { return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} } 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) err = awsRestxml_deserializeDocumentPublicKey(&output.PublicKey, decoder) 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(), } } return out, metadata, err } func awsRestxml_deserializeOpErrorUpdatePublicKey(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("AccessDenied", errorCode): return awsRestxml_deserializeErrorAccessDenied(response, errorBody) case strings.EqualFold("CannotChangeImmutablePublicKeyFields", errorCode): return awsRestxml_deserializeErrorCannotChangeImmutablePublicKeyFields(response, errorBody) case strings.EqualFold("IllegalUpdate", errorCode): return awsRestxml_deserializeErrorIllegalUpdate(response, errorBody) case strings.EqualFold("InvalidArgument", errorCode): return awsRestxml_deserializeErrorInvalidArgument(response, errorBody) case strings.EqualFold("InvalidIfMatchVersion", errorCode): return awsRestxml_deserializeErrorInvalidIfMatchVersion(response, errorBody) case strings.EqualFold("NoSuchPublicKey", errorCode): return awsRestxml_deserializeErrorNoSuchPublicKey(response, errorBody) case strings.EqualFold("PreconditionFailed", errorCode): return awsRestxml_deserializeErrorPreconditionFailed(response, errorBody) default: genericError := &smithy.GenericAPIError{ Code: errorCode, Message: errorMessage, } return genericError } } func awsRestxml_deserializeOpHttpBindingsUpdatePublicKeyOutput(v *UpdatePublicKeyOutput, response *smithyhttp.Response) error { if v == nil { return fmt.Errorf("unsupported deserialization for nil %T", v) } if headerValues := response.Header.Values("ETag"); len(headerValues) != 0 { headerValues[0] = strings.TrimSpace(headerValues[0]) v.ETag = ptr.String(headerValues[0]) } return nil } func awsRestxml_deserializeOpDocumentUpdatePublicKeyOutput(v **UpdatePublicKeyOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *UpdatePublicKeyOutput if *v == nil { sv = &UpdatePublicKeyOutput{} } 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("PublicKey", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentPublicKey(&sv.PublicKey, nodeDecoder); err != nil { return err } default: // Do nothing and ignore the unexpected tag element err = decoder.Decoder.Skip() if err != nil { return err } } decoder = originalDecoder } *v = sv return nil } type awsRestxml_deserializeOpUpdateRealtimeLogConfig struct { } func (*awsRestxml_deserializeOpUpdateRealtimeLogConfig) ID() string { return "OperationDeserializer" } func (m *awsRestxml_deserializeOpUpdateRealtimeLogConfig) 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, awsRestxml_deserializeOpErrorUpdateRealtimeLogConfig(response, &metadata) } output := &UpdateRealtimeLogConfigOutput{} 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) err = awsRestxml_deserializeOpDocumentUpdateRealtimeLogConfigOutput(&output, decoder) 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(), } } return out, metadata, err } func awsRestxml_deserializeOpErrorUpdateRealtimeLogConfig(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("AccessDenied", errorCode): return awsRestxml_deserializeErrorAccessDenied(response, errorBody) case strings.EqualFold("InvalidArgument", errorCode): return awsRestxml_deserializeErrorInvalidArgument(response, errorBody) case strings.EqualFold("NoSuchRealtimeLogConfig", errorCode): return awsRestxml_deserializeErrorNoSuchRealtimeLogConfig(response, errorBody) default: genericError := &smithy.GenericAPIError{ Code: errorCode, Message: errorMessage, } return genericError } } func awsRestxml_deserializeOpDocumentUpdateRealtimeLogConfigOutput(v **UpdateRealtimeLogConfigOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *UpdateRealtimeLogConfigOutput if *v == nil { sv = &UpdateRealtimeLogConfigOutput{} } 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("RealtimeLogConfig", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentRealtimeLogConfig(&sv.RealtimeLogConfig, nodeDecoder); err != nil { return err } default: // Do nothing and ignore the unexpected tag element err = decoder.Decoder.Skip() if err != nil { return err } } decoder = originalDecoder } *v = sv return nil } type awsRestxml_deserializeOpUpdateResponseHeadersPolicy struct { } func (*awsRestxml_deserializeOpUpdateResponseHeadersPolicy) ID() string { return "OperationDeserializer" } func (m *awsRestxml_deserializeOpUpdateResponseHeadersPolicy) 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, awsRestxml_deserializeOpErrorUpdateResponseHeadersPolicy(response, &metadata) } output := &UpdateResponseHeadersPolicyOutput{} out.Result = output err = awsRestxml_deserializeOpHttpBindingsUpdateResponseHeadersPolicyOutput(output, response) if err != nil { return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} } 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) err = awsRestxml_deserializeDocumentResponseHeadersPolicy(&output.ResponseHeadersPolicy, decoder) 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(), } } return out, metadata, err } func awsRestxml_deserializeOpErrorUpdateResponseHeadersPolicy(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("AccessDenied", errorCode): return awsRestxml_deserializeErrorAccessDenied(response, errorBody) case strings.EqualFold("IllegalUpdate", errorCode): return awsRestxml_deserializeErrorIllegalUpdate(response, errorBody) case strings.EqualFold("InconsistentQuantities", errorCode): return awsRestxml_deserializeErrorInconsistentQuantities(response, errorBody) case strings.EqualFold("InvalidArgument", errorCode): return awsRestxml_deserializeErrorInvalidArgument(response, errorBody) case strings.EqualFold("InvalidIfMatchVersion", errorCode): return awsRestxml_deserializeErrorInvalidIfMatchVersion(response, errorBody) case strings.EqualFold("NoSuchResponseHeadersPolicy", errorCode): return awsRestxml_deserializeErrorNoSuchResponseHeadersPolicy(response, errorBody) case strings.EqualFold("PreconditionFailed", errorCode): return awsRestxml_deserializeErrorPreconditionFailed(response, errorBody) case strings.EqualFold("ResponseHeadersPolicyAlreadyExists", errorCode): return awsRestxml_deserializeErrorResponseHeadersPolicyAlreadyExists(response, errorBody) case strings.EqualFold("TooLongCSPInResponseHeadersPolicy", errorCode): return awsRestxml_deserializeErrorTooLongCSPInResponseHeadersPolicy(response, errorBody) case strings.EqualFold("TooManyCustomHeadersInResponseHeadersPolicy", errorCode): return awsRestxml_deserializeErrorTooManyCustomHeadersInResponseHeadersPolicy(response, errorBody) case strings.EqualFold("TooManyRemoveHeadersInResponseHeadersPolicy", errorCode): return awsRestxml_deserializeErrorTooManyRemoveHeadersInResponseHeadersPolicy(response, errorBody) default: genericError := &smithy.GenericAPIError{ Code: errorCode, Message: errorMessage, } return genericError } } func awsRestxml_deserializeOpHttpBindingsUpdateResponseHeadersPolicyOutput(v *UpdateResponseHeadersPolicyOutput, response *smithyhttp.Response) error { if v == nil { return fmt.Errorf("unsupported deserialization for nil %T", v) } if headerValues := response.Header.Values("ETag"); len(headerValues) != 0 { headerValues[0] = strings.TrimSpace(headerValues[0]) v.ETag = ptr.String(headerValues[0]) } return nil } func awsRestxml_deserializeOpDocumentUpdateResponseHeadersPolicyOutput(v **UpdateResponseHeadersPolicyOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *UpdateResponseHeadersPolicyOutput if *v == nil { sv = &UpdateResponseHeadersPolicyOutput{} } 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("ResponseHeadersPolicy", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentResponseHeadersPolicy(&sv.ResponseHeadersPolicy, nodeDecoder); err != nil { return err } default: // Do nothing and ignore the unexpected tag element err = decoder.Decoder.Skip() if err != nil { return err } } decoder = originalDecoder } *v = sv return nil } type awsRestxml_deserializeOpUpdateStreamingDistribution struct { } func (*awsRestxml_deserializeOpUpdateStreamingDistribution) ID() string { return "OperationDeserializer" } func (m *awsRestxml_deserializeOpUpdateStreamingDistribution) 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, awsRestxml_deserializeOpErrorUpdateStreamingDistribution(response, &metadata) } output := &UpdateStreamingDistributionOutput{} out.Result = output err = awsRestxml_deserializeOpHttpBindingsUpdateStreamingDistributionOutput(output, response) if err != nil { return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} } 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) err = awsRestxml_deserializeDocumentStreamingDistribution(&output.StreamingDistribution, decoder) 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(), } } return out, metadata, err } func awsRestxml_deserializeOpErrorUpdateStreamingDistribution(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("AccessDenied", errorCode): return awsRestxml_deserializeErrorAccessDenied(response, errorBody) case strings.EqualFold("CNAMEAlreadyExists", errorCode): return awsRestxml_deserializeErrorCNAMEAlreadyExists(response, errorBody) case strings.EqualFold("IllegalUpdate", errorCode): return awsRestxml_deserializeErrorIllegalUpdate(response, errorBody) case strings.EqualFold("InconsistentQuantities", errorCode): return awsRestxml_deserializeErrorInconsistentQuantities(response, errorBody) case strings.EqualFold("InvalidArgument", errorCode): return awsRestxml_deserializeErrorInvalidArgument(response, errorBody) case strings.EqualFold("InvalidIfMatchVersion", errorCode): return awsRestxml_deserializeErrorInvalidIfMatchVersion(response, errorBody) case strings.EqualFold("InvalidOriginAccessControl", errorCode): return awsRestxml_deserializeErrorInvalidOriginAccessControl(response, errorBody) case strings.EqualFold("InvalidOriginAccessIdentity", errorCode): return awsRestxml_deserializeErrorInvalidOriginAccessIdentity(response, errorBody) case strings.EqualFold("MissingBody", errorCode): return awsRestxml_deserializeErrorMissingBody(response, errorBody) case strings.EqualFold("NoSuchStreamingDistribution", errorCode): return awsRestxml_deserializeErrorNoSuchStreamingDistribution(response, errorBody) case strings.EqualFold("PreconditionFailed", errorCode): return awsRestxml_deserializeErrorPreconditionFailed(response, errorBody) case strings.EqualFold("TooManyStreamingDistributionCNAMEs", errorCode): return awsRestxml_deserializeErrorTooManyStreamingDistributionCNAMEs(response, errorBody) case strings.EqualFold("TooManyTrustedSigners", errorCode): return awsRestxml_deserializeErrorTooManyTrustedSigners(response, errorBody) case strings.EqualFold("TrustedSignerDoesNotExist", errorCode): return awsRestxml_deserializeErrorTrustedSignerDoesNotExist(response, errorBody) default: genericError := &smithy.GenericAPIError{ Code: errorCode, Message: errorMessage, } return genericError } } func awsRestxml_deserializeOpHttpBindingsUpdateStreamingDistributionOutput(v *UpdateStreamingDistributionOutput, response *smithyhttp.Response) error { if v == nil { return fmt.Errorf("unsupported deserialization for nil %T", v) } if headerValues := response.Header.Values("ETag"); len(headerValues) != 0 { headerValues[0] = strings.TrimSpace(headerValues[0]) v.ETag = ptr.String(headerValues[0]) } return nil } func awsRestxml_deserializeOpDocumentUpdateStreamingDistributionOutput(v **UpdateStreamingDistributionOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *UpdateStreamingDistributionOutput if *v == nil { sv = &UpdateStreamingDistributionOutput{} } 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("StreamingDistribution", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentStreamingDistribution(&sv.StreamingDistribution, nodeDecoder); err != nil { return err } 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 awsRestxml_deserializeErrorAccessDenied(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.AccessDenied{} 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 = awsRestxml_deserializeDocumentAccessDenied(&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 awsRestxml_deserializeErrorBatchTooLarge(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.BatchTooLarge{} 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 = awsRestxml_deserializeDocumentBatchTooLarge(&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 awsRestxml_deserializeErrorCachePolicyAlreadyExists(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.CachePolicyAlreadyExists{} 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 = awsRestxml_deserializeDocumentCachePolicyAlreadyExists(&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 awsRestxml_deserializeErrorCachePolicyInUse(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.CachePolicyInUse{} 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 = awsRestxml_deserializeDocumentCachePolicyInUse(&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 awsRestxml_deserializeErrorCannotChangeImmutablePublicKeyFields(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.CannotChangeImmutablePublicKeyFields{} 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 = awsRestxml_deserializeDocumentCannotChangeImmutablePublicKeyFields(&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 awsRestxml_deserializeErrorCloudFrontOriginAccessIdentityAlreadyExists(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.CloudFrontOriginAccessIdentityAlreadyExists{} 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 = awsRestxml_deserializeDocumentCloudFrontOriginAccessIdentityAlreadyExists(&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 awsRestxml_deserializeErrorCloudFrontOriginAccessIdentityInUse(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.CloudFrontOriginAccessIdentityInUse{} 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 = awsRestxml_deserializeDocumentCloudFrontOriginAccessIdentityInUse(&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 awsRestxml_deserializeErrorCNAMEAlreadyExists(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.CNAMEAlreadyExists{} 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 = awsRestxml_deserializeDocumentCNAMEAlreadyExists(&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 awsRestxml_deserializeErrorContinuousDeploymentPolicyAlreadyExists(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.ContinuousDeploymentPolicyAlreadyExists{} 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 = awsRestxml_deserializeDocumentContinuousDeploymentPolicyAlreadyExists(&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 awsRestxml_deserializeErrorContinuousDeploymentPolicyInUse(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.ContinuousDeploymentPolicyInUse{} 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 = awsRestxml_deserializeDocumentContinuousDeploymentPolicyInUse(&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 awsRestxml_deserializeErrorDistributionAlreadyExists(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.DistributionAlreadyExists{} 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 = awsRestxml_deserializeDocumentDistributionAlreadyExists(&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 awsRestxml_deserializeErrorDistributionNotDisabled(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.DistributionNotDisabled{} 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 = awsRestxml_deserializeDocumentDistributionNotDisabled(&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 awsRestxml_deserializeErrorFieldLevelEncryptionConfigAlreadyExists(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.FieldLevelEncryptionConfigAlreadyExists{} 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 = awsRestxml_deserializeDocumentFieldLevelEncryptionConfigAlreadyExists(&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 awsRestxml_deserializeErrorFieldLevelEncryptionConfigInUse(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.FieldLevelEncryptionConfigInUse{} 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 = awsRestxml_deserializeDocumentFieldLevelEncryptionConfigInUse(&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 awsRestxml_deserializeErrorFieldLevelEncryptionProfileAlreadyExists(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.FieldLevelEncryptionProfileAlreadyExists{} 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 = awsRestxml_deserializeDocumentFieldLevelEncryptionProfileAlreadyExists(&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 awsRestxml_deserializeErrorFieldLevelEncryptionProfileInUse(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.FieldLevelEncryptionProfileInUse{} 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 = awsRestxml_deserializeDocumentFieldLevelEncryptionProfileInUse(&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 awsRestxml_deserializeErrorFieldLevelEncryptionProfileSizeExceeded(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.FieldLevelEncryptionProfileSizeExceeded{} 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 = awsRestxml_deserializeDocumentFieldLevelEncryptionProfileSizeExceeded(&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 awsRestxml_deserializeErrorFunctionAlreadyExists(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.FunctionAlreadyExists{} 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 = awsRestxml_deserializeDocumentFunctionAlreadyExists(&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 awsRestxml_deserializeErrorFunctionInUse(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.FunctionInUse{} 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 = awsRestxml_deserializeDocumentFunctionInUse(&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 awsRestxml_deserializeErrorFunctionSizeLimitExceeded(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.FunctionSizeLimitExceeded{} 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 = awsRestxml_deserializeDocumentFunctionSizeLimitExceeded(&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 awsRestxml_deserializeErrorIllegalDelete(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.IllegalDelete{} 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 = awsRestxml_deserializeDocumentIllegalDelete(&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 awsRestxml_deserializeErrorIllegalFieldLevelEncryptionConfigAssociationWithCacheBehavior(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.IllegalFieldLevelEncryptionConfigAssociationWithCacheBehavior{} 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 = awsRestxml_deserializeDocumentIllegalFieldLevelEncryptionConfigAssociationWithCacheBehavior(&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 awsRestxml_deserializeErrorIllegalOriginAccessConfiguration(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.IllegalOriginAccessConfiguration{} 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 = awsRestxml_deserializeDocumentIllegalOriginAccessConfiguration(&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 awsRestxml_deserializeErrorIllegalUpdate(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.IllegalUpdate{} 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 = awsRestxml_deserializeDocumentIllegalUpdate(&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 awsRestxml_deserializeErrorInconsistentQuantities(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.InconsistentQuantities{} 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 = awsRestxml_deserializeDocumentInconsistentQuantities(&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 awsRestxml_deserializeErrorInvalidArgument(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.InvalidArgument{} 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 = awsRestxml_deserializeDocumentInvalidArgument(&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 awsRestxml_deserializeErrorInvalidDefaultRootObject(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.InvalidDefaultRootObject{} 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 = awsRestxml_deserializeDocumentInvalidDefaultRootObject(&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 awsRestxml_deserializeErrorInvalidDomainNameForOriginAccessControl(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.InvalidDomainNameForOriginAccessControl{} 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 = awsRestxml_deserializeDocumentInvalidDomainNameForOriginAccessControl(&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 awsRestxml_deserializeErrorInvalidErrorCode(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.InvalidErrorCode{} 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 = awsRestxml_deserializeDocumentInvalidErrorCode(&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 awsRestxml_deserializeErrorInvalidForwardCookies(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.InvalidForwardCookies{} 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 = awsRestxml_deserializeDocumentInvalidForwardCookies(&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 awsRestxml_deserializeErrorInvalidFunctionAssociation(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.InvalidFunctionAssociation{} 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 = awsRestxml_deserializeDocumentInvalidFunctionAssociation(&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 awsRestxml_deserializeErrorInvalidGeoRestrictionParameter(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.InvalidGeoRestrictionParameter{} 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 = awsRestxml_deserializeDocumentInvalidGeoRestrictionParameter(&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 awsRestxml_deserializeErrorInvalidHeadersForS3Origin(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.InvalidHeadersForS3Origin{} 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 = awsRestxml_deserializeDocumentInvalidHeadersForS3Origin(&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 awsRestxml_deserializeErrorInvalidIfMatchVersion(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.InvalidIfMatchVersion{} 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 = awsRestxml_deserializeDocumentInvalidIfMatchVersion(&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 awsRestxml_deserializeErrorInvalidLambdaFunctionAssociation(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.InvalidLambdaFunctionAssociation{} 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 = awsRestxml_deserializeDocumentInvalidLambdaFunctionAssociation(&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 awsRestxml_deserializeErrorInvalidLocationCode(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.InvalidLocationCode{} 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 = awsRestxml_deserializeDocumentInvalidLocationCode(&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 awsRestxml_deserializeErrorInvalidMinimumProtocolVersion(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.InvalidMinimumProtocolVersion{} 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 = awsRestxml_deserializeDocumentInvalidMinimumProtocolVersion(&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 awsRestxml_deserializeErrorInvalidOrigin(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.InvalidOrigin{} 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 = awsRestxml_deserializeDocumentInvalidOrigin(&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 awsRestxml_deserializeErrorInvalidOriginAccessControl(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.InvalidOriginAccessControl{} 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 = awsRestxml_deserializeDocumentInvalidOriginAccessControl(&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 awsRestxml_deserializeErrorInvalidOriginAccessIdentity(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.InvalidOriginAccessIdentity{} 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 = awsRestxml_deserializeDocumentInvalidOriginAccessIdentity(&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 awsRestxml_deserializeErrorInvalidOriginKeepaliveTimeout(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.InvalidOriginKeepaliveTimeout{} 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 = awsRestxml_deserializeDocumentInvalidOriginKeepaliveTimeout(&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 awsRestxml_deserializeErrorInvalidOriginReadTimeout(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.InvalidOriginReadTimeout{} 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 = awsRestxml_deserializeDocumentInvalidOriginReadTimeout(&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 awsRestxml_deserializeErrorInvalidProtocolSettings(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.InvalidProtocolSettings{} 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 = awsRestxml_deserializeDocumentInvalidProtocolSettings(&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 awsRestxml_deserializeErrorInvalidQueryStringParameters(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.InvalidQueryStringParameters{} 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 = awsRestxml_deserializeDocumentInvalidQueryStringParameters(&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 awsRestxml_deserializeErrorInvalidRelativePath(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.InvalidRelativePath{} 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 = awsRestxml_deserializeDocumentInvalidRelativePath(&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 awsRestxml_deserializeErrorInvalidRequiredProtocol(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.InvalidRequiredProtocol{} 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 = awsRestxml_deserializeDocumentInvalidRequiredProtocol(&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 awsRestxml_deserializeErrorInvalidResponseCode(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.InvalidResponseCode{} 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 = awsRestxml_deserializeDocumentInvalidResponseCode(&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 awsRestxml_deserializeErrorInvalidTagging(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.InvalidTagging{} 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 = awsRestxml_deserializeDocumentInvalidTagging(&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 awsRestxml_deserializeErrorInvalidTTLOrder(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.InvalidTTLOrder{} 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 = awsRestxml_deserializeDocumentInvalidTTLOrder(&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 awsRestxml_deserializeErrorInvalidViewerCertificate(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.InvalidViewerCertificate{} 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 = awsRestxml_deserializeDocumentInvalidViewerCertificate(&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 awsRestxml_deserializeErrorInvalidWebACLId(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.InvalidWebACLId{} 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 = awsRestxml_deserializeDocumentInvalidWebACLId(&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 awsRestxml_deserializeErrorKeyGroupAlreadyExists(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.KeyGroupAlreadyExists{} 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 = awsRestxml_deserializeDocumentKeyGroupAlreadyExists(&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 awsRestxml_deserializeErrorMissingBody(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.MissingBody{} 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 = awsRestxml_deserializeDocumentMissingBody(&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 awsRestxml_deserializeErrorMonitoringSubscriptionAlreadyExists(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.MonitoringSubscriptionAlreadyExists{} 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 = awsRestxml_deserializeDocumentMonitoringSubscriptionAlreadyExists(&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 awsRestxml_deserializeErrorNoSuchCachePolicy(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.NoSuchCachePolicy{} 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 = awsRestxml_deserializeDocumentNoSuchCachePolicy(&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 awsRestxml_deserializeErrorNoSuchCloudFrontOriginAccessIdentity(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.NoSuchCloudFrontOriginAccessIdentity{} 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 = awsRestxml_deserializeDocumentNoSuchCloudFrontOriginAccessIdentity(&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 awsRestxml_deserializeErrorNoSuchContinuousDeploymentPolicy(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.NoSuchContinuousDeploymentPolicy{} 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 = awsRestxml_deserializeDocumentNoSuchContinuousDeploymentPolicy(&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 awsRestxml_deserializeErrorNoSuchDistribution(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.NoSuchDistribution{} 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 = awsRestxml_deserializeDocumentNoSuchDistribution(&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 awsRestxml_deserializeErrorNoSuchFieldLevelEncryptionConfig(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.NoSuchFieldLevelEncryptionConfig{} 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 = awsRestxml_deserializeDocumentNoSuchFieldLevelEncryptionConfig(&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 awsRestxml_deserializeErrorNoSuchFieldLevelEncryptionProfile(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.NoSuchFieldLevelEncryptionProfile{} 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 = awsRestxml_deserializeDocumentNoSuchFieldLevelEncryptionProfile(&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 awsRestxml_deserializeErrorNoSuchFunctionExists(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.NoSuchFunctionExists{} 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 = awsRestxml_deserializeDocumentNoSuchFunctionExists(&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 awsRestxml_deserializeErrorNoSuchInvalidation(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.NoSuchInvalidation{} 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 = awsRestxml_deserializeDocumentNoSuchInvalidation(&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 awsRestxml_deserializeErrorNoSuchMonitoringSubscription(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.NoSuchMonitoringSubscription{} 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 = awsRestxml_deserializeDocumentNoSuchMonitoringSubscription(&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 awsRestxml_deserializeErrorNoSuchOrigin(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.NoSuchOrigin{} 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 = awsRestxml_deserializeDocumentNoSuchOrigin(&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 awsRestxml_deserializeErrorNoSuchOriginAccessControl(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.NoSuchOriginAccessControl{} 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 = awsRestxml_deserializeDocumentNoSuchOriginAccessControl(&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 awsRestxml_deserializeErrorNoSuchOriginRequestPolicy(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.NoSuchOriginRequestPolicy{} 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 = awsRestxml_deserializeDocumentNoSuchOriginRequestPolicy(&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 awsRestxml_deserializeErrorNoSuchPublicKey(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.NoSuchPublicKey{} 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 = awsRestxml_deserializeDocumentNoSuchPublicKey(&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 awsRestxml_deserializeErrorNoSuchRealtimeLogConfig(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.NoSuchRealtimeLogConfig{} 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 = awsRestxml_deserializeDocumentNoSuchRealtimeLogConfig(&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 awsRestxml_deserializeErrorNoSuchResource(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.NoSuchResource{} 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 = awsRestxml_deserializeDocumentNoSuchResource(&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 awsRestxml_deserializeErrorNoSuchResponseHeadersPolicy(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.NoSuchResponseHeadersPolicy{} 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 = awsRestxml_deserializeDocumentNoSuchResponseHeadersPolicy(&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 awsRestxml_deserializeErrorNoSuchStreamingDistribution(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.NoSuchStreamingDistribution{} 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 = awsRestxml_deserializeDocumentNoSuchStreamingDistribution(&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 awsRestxml_deserializeErrorOriginAccessControlAlreadyExists(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.OriginAccessControlAlreadyExists{} 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 = awsRestxml_deserializeDocumentOriginAccessControlAlreadyExists(&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 awsRestxml_deserializeErrorOriginAccessControlInUse(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.OriginAccessControlInUse{} 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 = awsRestxml_deserializeDocumentOriginAccessControlInUse(&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 awsRestxml_deserializeErrorOriginRequestPolicyAlreadyExists(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.OriginRequestPolicyAlreadyExists{} 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 = awsRestxml_deserializeDocumentOriginRequestPolicyAlreadyExists(&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 awsRestxml_deserializeErrorOriginRequestPolicyInUse(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.OriginRequestPolicyInUse{} 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 = awsRestxml_deserializeDocumentOriginRequestPolicyInUse(&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 awsRestxml_deserializeErrorPreconditionFailed(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.PreconditionFailed{} 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 = awsRestxml_deserializeDocumentPreconditionFailed(&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 awsRestxml_deserializeErrorPublicKeyAlreadyExists(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.PublicKeyAlreadyExists{} 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 = awsRestxml_deserializeDocumentPublicKeyAlreadyExists(&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 awsRestxml_deserializeErrorPublicKeyInUse(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.PublicKeyInUse{} 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 = awsRestxml_deserializeDocumentPublicKeyInUse(&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 awsRestxml_deserializeErrorQueryArgProfileEmpty(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.QueryArgProfileEmpty{} 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 = awsRestxml_deserializeDocumentQueryArgProfileEmpty(&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 awsRestxml_deserializeErrorRealtimeLogConfigAlreadyExists(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.RealtimeLogConfigAlreadyExists{} 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 = awsRestxml_deserializeDocumentRealtimeLogConfigAlreadyExists(&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 awsRestxml_deserializeErrorRealtimeLogConfigInUse(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.RealtimeLogConfigInUse{} 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 = awsRestxml_deserializeDocumentRealtimeLogConfigInUse(&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 awsRestxml_deserializeErrorRealtimeLogConfigOwnerMismatch(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.RealtimeLogConfigOwnerMismatch{} 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 = awsRestxml_deserializeDocumentRealtimeLogConfigOwnerMismatch(&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 awsRestxml_deserializeErrorResourceInUse(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.ResourceInUse{} 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 = awsRestxml_deserializeDocumentResourceInUse(&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 awsRestxml_deserializeErrorResponseHeadersPolicyAlreadyExists(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.ResponseHeadersPolicyAlreadyExists{} 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 = awsRestxml_deserializeDocumentResponseHeadersPolicyAlreadyExists(&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 awsRestxml_deserializeErrorResponseHeadersPolicyInUse(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.ResponseHeadersPolicyInUse{} 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 = awsRestxml_deserializeDocumentResponseHeadersPolicyInUse(&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 awsRestxml_deserializeErrorStagingDistributionInUse(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.StagingDistributionInUse{} 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 = awsRestxml_deserializeDocumentStagingDistributionInUse(&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 awsRestxml_deserializeErrorStreamingDistributionAlreadyExists(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.StreamingDistributionAlreadyExists{} 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 = awsRestxml_deserializeDocumentStreamingDistributionAlreadyExists(&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 awsRestxml_deserializeErrorStreamingDistributionNotDisabled(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.StreamingDistributionNotDisabled{} 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 = awsRestxml_deserializeDocumentStreamingDistributionNotDisabled(&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 awsRestxml_deserializeErrorTestFunctionFailed(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.TestFunctionFailed{} 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 = awsRestxml_deserializeDocumentTestFunctionFailed(&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 awsRestxml_deserializeErrorTooLongCSPInResponseHeadersPolicy(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.TooLongCSPInResponseHeadersPolicy{} 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 = awsRestxml_deserializeDocumentTooLongCSPInResponseHeadersPolicy(&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 awsRestxml_deserializeErrorTooManyCacheBehaviors(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.TooManyCacheBehaviors{} 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 = awsRestxml_deserializeDocumentTooManyCacheBehaviors(&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 awsRestxml_deserializeErrorTooManyCachePolicies(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.TooManyCachePolicies{} 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 = awsRestxml_deserializeDocumentTooManyCachePolicies(&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 awsRestxml_deserializeErrorTooManyCertificates(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.TooManyCertificates{} 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 = awsRestxml_deserializeDocumentTooManyCertificates(&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 awsRestxml_deserializeErrorTooManyCloudFrontOriginAccessIdentities(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.TooManyCloudFrontOriginAccessIdentities{} 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 = awsRestxml_deserializeDocumentTooManyCloudFrontOriginAccessIdentities(&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 awsRestxml_deserializeErrorTooManyContinuousDeploymentPolicies(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.TooManyContinuousDeploymentPolicies{} 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 = awsRestxml_deserializeDocumentTooManyContinuousDeploymentPolicies(&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 awsRestxml_deserializeErrorTooManyCookieNamesInWhiteList(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.TooManyCookieNamesInWhiteList{} 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 = awsRestxml_deserializeDocumentTooManyCookieNamesInWhiteList(&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 awsRestxml_deserializeErrorTooManyCookiesInCachePolicy(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.TooManyCookiesInCachePolicy{} 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 = awsRestxml_deserializeDocumentTooManyCookiesInCachePolicy(&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 awsRestxml_deserializeErrorTooManyCookiesInOriginRequestPolicy(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.TooManyCookiesInOriginRequestPolicy{} 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 = awsRestxml_deserializeDocumentTooManyCookiesInOriginRequestPolicy(&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 awsRestxml_deserializeErrorTooManyCustomHeadersInResponseHeadersPolicy(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.TooManyCustomHeadersInResponseHeadersPolicy{} 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 = awsRestxml_deserializeDocumentTooManyCustomHeadersInResponseHeadersPolicy(&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 awsRestxml_deserializeErrorTooManyDistributionCNAMEs(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.TooManyDistributionCNAMEs{} 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 = awsRestxml_deserializeDocumentTooManyDistributionCNAMEs(&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 awsRestxml_deserializeErrorTooManyDistributions(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.TooManyDistributions{} 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 = awsRestxml_deserializeDocumentTooManyDistributions(&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 awsRestxml_deserializeErrorTooManyDistributionsAssociatedToCachePolicy(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.TooManyDistributionsAssociatedToCachePolicy{} 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 = awsRestxml_deserializeDocumentTooManyDistributionsAssociatedToCachePolicy(&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 awsRestxml_deserializeErrorTooManyDistributionsAssociatedToFieldLevelEncryptionConfig(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.TooManyDistributionsAssociatedToFieldLevelEncryptionConfig{} 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 = awsRestxml_deserializeDocumentTooManyDistributionsAssociatedToFieldLevelEncryptionConfig(&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 awsRestxml_deserializeErrorTooManyDistributionsAssociatedToKeyGroup(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.TooManyDistributionsAssociatedToKeyGroup{} 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 = awsRestxml_deserializeDocumentTooManyDistributionsAssociatedToKeyGroup(&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 awsRestxml_deserializeErrorTooManyDistributionsAssociatedToOriginAccessControl(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.TooManyDistributionsAssociatedToOriginAccessControl{} 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 = awsRestxml_deserializeDocumentTooManyDistributionsAssociatedToOriginAccessControl(&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 awsRestxml_deserializeErrorTooManyDistributionsAssociatedToOriginRequestPolicy(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.TooManyDistributionsAssociatedToOriginRequestPolicy{} 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 = awsRestxml_deserializeDocumentTooManyDistributionsAssociatedToOriginRequestPolicy(&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 awsRestxml_deserializeErrorTooManyDistributionsAssociatedToResponseHeadersPolicy(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.TooManyDistributionsAssociatedToResponseHeadersPolicy{} 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 = awsRestxml_deserializeDocumentTooManyDistributionsAssociatedToResponseHeadersPolicy(&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 awsRestxml_deserializeErrorTooManyDistributionsWithFunctionAssociations(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.TooManyDistributionsWithFunctionAssociations{} 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 = awsRestxml_deserializeDocumentTooManyDistributionsWithFunctionAssociations(&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 awsRestxml_deserializeErrorTooManyDistributionsWithLambdaAssociations(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.TooManyDistributionsWithLambdaAssociations{} 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 = awsRestxml_deserializeDocumentTooManyDistributionsWithLambdaAssociations(&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 awsRestxml_deserializeErrorTooManyDistributionsWithSingleFunctionARN(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.TooManyDistributionsWithSingleFunctionARN{} 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 = awsRestxml_deserializeDocumentTooManyDistributionsWithSingleFunctionARN(&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 awsRestxml_deserializeErrorTooManyFieldLevelEncryptionConfigs(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.TooManyFieldLevelEncryptionConfigs{} 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 = awsRestxml_deserializeDocumentTooManyFieldLevelEncryptionConfigs(&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 awsRestxml_deserializeErrorTooManyFieldLevelEncryptionContentTypeProfiles(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.TooManyFieldLevelEncryptionContentTypeProfiles{} 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 = awsRestxml_deserializeDocumentTooManyFieldLevelEncryptionContentTypeProfiles(&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 awsRestxml_deserializeErrorTooManyFieldLevelEncryptionEncryptionEntities(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.TooManyFieldLevelEncryptionEncryptionEntities{} 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 = awsRestxml_deserializeDocumentTooManyFieldLevelEncryptionEncryptionEntities(&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 awsRestxml_deserializeErrorTooManyFieldLevelEncryptionFieldPatterns(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.TooManyFieldLevelEncryptionFieldPatterns{} 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 = awsRestxml_deserializeDocumentTooManyFieldLevelEncryptionFieldPatterns(&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 awsRestxml_deserializeErrorTooManyFieldLevelEncryptionProfiles(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.TooManyFieldLevelEncryptionProfiles{} 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 = awsRestxml_deserializeDocumentTooManyFieldLevelEncryptionProfiles(&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 awsRestxml_deserializeErrorTooManyFieldLevelEncryptionQueryArgProfiles(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.TooManyFieldLevelEncryptionQueryArgProfiles{} 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 = awsRestxml_deserializeDocumentTooManyFieldLevelEncryptionQueryArgProfiles(&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 awsRestxml_deserializeErrorTooManyFunctionAssociations(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.TooManyFunctionAssociations{} 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 = awsRestxml_deserializeDocumentTooManyFunctionAssociations(&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 awsRestxml_deserializeErrorTooManyFunctions(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.TooManyFunctions{} 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 = awsRestxml_deserializeDocumentTooManyFunctions(&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 awsRestxml_deserializeErrorTooManyHeadersInCachePolicy(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.TooManyHeadersInCachePolicy{} 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 = awsRestxml_deserializeDocumentTooManyHeadersInCachePolicy(&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 awsRestxml_deserializeErrorTooManyHeadersInForwardedValues(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.TooManyHeadersInForwardedValues{} 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 = awsRestxml_deserializeDocumentTooManyHeadersInForwardedValues(&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 awsRestxml_deserializeErrorTooManyHeadersInOriginRequestPolicy(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.TooManyHeadersInOriginRequestPolicy{} 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 = awsRestxml_deserializeDocumentTooManyHeadersInOriginRequestPolicy(&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 awsRestxml_deserializeErrorTooManyInvalidationsInProgress(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.TooManyInvalidationsInProgress{} 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 = awsRestxml_deserializeDocumentTooManyInvalidationsInProgress(&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 awsRestxml_deserializeErrorTooManyKeyGroups(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.TooManyKeyGroups{} 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 = awsRestxml_deserializeDocumentTooManyKeyGroups(&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 awsRestxml_deserializeErrorTooManyKeyGroupsAssociatedToDistribution(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.TooManyKeyGroupsAssociatedToDistribution{} 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 = awsRestxml_deserializeDocumentTooManyKeyGroupsAssociatedToDistribution(&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 awsRestxml_deserializeErrorTooManyLambdaFunctionAssociations(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.TooManyLambdaFunctionAssociations{} 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 = awsRestxml_deserializeDocumentTooManyLambdaFunctionAssociations(&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 awsRestxml_deserializeErrorTooManyOriginAccessControls(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.TooManyOriginAccessControls{} 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 = awsRestxml_deserializeDocumentTooManyOriginAccessControls(&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 awsRestxml_deserializeErrorTooManyOriginCustomHeaders(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.TooManyOriginCustomHeaders{} 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 = awsRestxml_deserializeDocumentTooManyOriginCustomHeaders(&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 awsRestxml_deserializeErrorTooManyOriginGroupsPerDistribution(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.TooManyOriginGroupsPerDistribution{} 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 = awsRestxml_deserializeDocumentTooManyOriginGroupsPerDistribution(&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 awsRestxml_deserializeErrorTooManyOriginRequestPolicies(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.TooManyOriginRequestPolicies{} 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 = awsRestxml_deserializeDocumentTooManyOriginRequestPolicies(&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 awsRestxml_deserializeErrorTooManyOrigins(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.TooManyOrigins{} 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 = awsRestxml_deserializeDocumentTooManyOrigins(&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 awsRestxml_deserializeErrorTooManyPublicKeys(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.TooManyPublicKeys{} 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 = awsRestxml_deserializeDocumentTooManyPublicKeys(&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 awsRestxml_deserializeErrorTooManyPublicKeysInKeyGroup(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.TooManyPublicKeysInKeyGroup{} 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 = awsRestxml_deserializeDocumentTooManyPublicKeysInKeyGroup(&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 awsRestxml_deserializeErrorTooManyQueryStringParameters(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.TooManyQueryStringParameters{} 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 = awsRestxml_deserializeDocumentTooManyQueryStringParameters(&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 awsRestxml_deserializeErrorTooManyQueryStringsInCachePolicy(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.TooManyQueryStringsInCachePolicy{} 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 = awsRestxml_deserializeDocumentTooManyQueryStringsInCachePolicy(&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 awsRestxml_deserializeErrorTooManyQueryStringsInOriginRequestPolicy(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.TooManyQueryStringsInOriginRequestPolicy{} 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 = awsRestxml_deserializeDocumentTooManyQueryStringsInOriginRequestPolicy(&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 awsRestxml_deserializeErrorTooManyRealtimeLogConfigs(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.TooManyRealtimeLogConfigs{} 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 = awsRestxml_deserializeDocumentTooManyRealtimeLogConfigs(&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 awsRestxml_deserializeErrorTooManyRemoveHeadersInResponseHeadersPolicy(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.TooManyRemoveHeadersInResponseHeadersPolicy{} 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 = awsRestxml_deserializeDocumentTooManyRemoveHeadersInResponseHeadersPolicy(&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 awsRestxml_deserializeErrorTooManyResponseHeadersPolicies(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.TooManyResponseHeadersPolicies{} 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 = awsRestxml_deserializeDocumentTooManyResponseHeadersPolicies(&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 awsRestxml_deserializeErrorTooManyStreamingDistributionCNAMEs(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.TooManyStreamingDistributionCNAMEs{} 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 = awsRestxml_deserializeDocumentTooManyStreamingDistributionCNAMEs(&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 awsRestxml_deserializeErrorTooManyStreamingDistributions(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.TooManyStreamingDistributions{} 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 = awsRestxml_deserializeDocumentTooManyStreamingDistributions(&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 awsRestxml_deserializeErrorTooManyTrustedSigners(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.TooManyTrustedSigners{} 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 = awsRestxml_deserializeDocumentTooManyTrustedSigners(&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 awsRestxml_deserializeErrorTrustedKeyGroupDoesNotExist(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.TrustedKeyGroupDoesNotExist{} 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 = awsRestxml_deserializeDocumentTrustedKeyGroupDoesNotExist(&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 awsRestxml_deserializeErrorTrustedSignerDoesNotExist(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.TrustedSignerDoesNotExist{} 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 = awsRestxml_deserializeDocumentTrustedSignerDoesNotExist(&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 awsRestxml_deserializeErrorUnsupportedOperation(response *smithyhttp.Response, errorBody *bytes.Reader) error { output := &types.UnsupportedOperation{} 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 = awsRestxml_deserializeDocumentUnsupportedOperation(&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 awsRestxml_deserializeDocumentAccessControlAllowHeadersList(v *[]string, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv []string if *v == nil { sv = make([]string, 0) } else { sv = *v } originalDecoder := decoder for { t, done, err := decoder.Token() if err != nil { return err } if done { break } memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) decoder = memberDecoder switch { case strings.EqualFold("Header", t.Name.Local): var col string val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) col = xtv } sv = append(sv, col) default: err = decoder.Decoder.Skip() if err != nil { return err } } decoder = originalDecoder } *v = sv return nil } func awsRestxml_deserializeDocumentAccessControlAllowHeadersListUnwrapped(v *[]string, decoder smithyxml.NodeDecoder) error { var sv []string if *v == nil { sv = make([]string, 0) } else { sv = *v } switch { default: var mv string t := decoder.StartEl _ = t val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) mv = xtv } sv = append(sv, mv) } *v = sv return nil } func awsRestxml_deserializeDocumentAccessControlAllowMethodsList(v *[]types.ResponseHeadersPolicyAccessControlAllowMethodsValues, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv []types.ResponseHeadersPolicyAccessControlAllowMethodsValues if *v == nil { sv = make([]types.ResponseHeadersPolicyAccessControlAllowMethodsValues, 0) } else { sv = *v } originalDecoder := decoder for { t, done, err := decoder.Token() if err != nil { return err } if done { break } memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) decoder = memberDecoder switch { case strings.EqualFold("Method", t.Name.Local): var col types.ResponseHeadersPolicyAccessControlAllowMethodsValues val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) col = types.ResponseHeadersPolicyAccessControlAllowMethodsValues(xtv) } sv = append(sv, col) default: err = decoder.Decoder.Skip() if err != nil { return err } } decoder = originalDecoder } *v = sv return nil } func awsRestxml_deserializeDocumentAccessControlAllowMethodsListUnwrapped(v *[]types.ResponseHeadersPolicyAccessControlAllowMethodsValues, decoder smithyxml.NodeDecoder) error { var sv []types.ResponseHeadersPolicyAccessControlAllowMethodsValues if *v == nil { sv = make([]types.ResponseHeadersPolicyAccessControlAllowMethodsValues, 0) } else { sv = *v } switch { default: var mv types.ResponseHeadersPolicyAccessControlAllowMethodsValues t := decoder.StartEl _ = t val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) mv = types.ResponseHeadersPolicyAccessControlAllowMethodsValues(xtv) } sv = append(sv, mv) } *v = sv return nil } func awsRestxml_deserializeDocumentAccessControlAllowOriginsList(v *[]string, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv []string if *v == nil { sv = make([]string, 0) } else { sv = *v } originalDecoder := decoder for { t, done, err := decoder.Token() if err != nil { return err } if done { break } memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) decoder = memberDecoder switch { case strings.EqualFold("Origin", t.Name.Local): var col string val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) col = xtv } sv = append(sv, col) default: err = decoder.Decoder.Skip() if err != nil { return err } } decoder = originalDecoder } *v = sv return nil } func awsRestxml_deserializeDocumentAccessControlAllowOriginsListUnwrapped(v *[]string, decoder smithyxml.NodeDecoder) error { var sv []string if *v == nil { sv = make([]string, 0) } else { sv = *v } switch { default: var mv string t := decoder.StartEl _ = t val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) mv = xtv } sv = append(sv, mv) } *v = sv return nil } func awsRestxml_deserializeDocumentAccessControlExposeHeadersList(v *[]string, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv []string if *v == nil { sv = make([]string, 0) } else { sv = *v } originalDecoder := decoder for { t, done, err := decoder.Token() if err != nil { return err } if done { break } memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) decoder = memberDecoder switch { case strings.EqualFold("Header", t.Name.Local): var col string val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) col = xtv } sv = append(sv, col) default: err = decoder.Decoder.Skip() if err != nil { return err } } decoder = originalDecoder } *v = sv return nil } func awsRestxml_deserializeDocumentAccessControlExposeHeadersListUnwrapped(v *[]string, decoder smithyxml.NodeDecoder) error { var sv []string if *v == nil { sv = make([]string, 0) } else { sv = *v } switch { default: var mv string t := decoder.StartEl _ = t val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) mv = xtv } sv = append(sv, mv) } *v = sv return nil } func awsRestxml_deserializeDocumentAccessDenied(v **types.AccessDenied, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.AccessDenied if *v == nil { sv = &types.AccessDenied{} } 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 awsRestxml_deserializeDocumentActiveTrustedKeyGroups(v **types.ActiveTrustedKeyGroups, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.ActiveTrustedKeyGroups if *v == nil { sv = &types.ActiveTrustedKeyGroups{} } 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("Enabled", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv, err := strconv.ParseBool(string(val)) if err != nil { return fmt.Errorf("expected boolean to be of type *bool, got %T instead", val) } sv.Enabled = ptr.Bool(xtv) } case strings.EqualFold("Items", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentKGKeyPairIdsList(&sv.Items, nodeDecoder); err != nil { return err } case strings.EqualFold("Quantity", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) i64, err := strconv.ParseInt(xtv, 10, 64) if err != nil { return err } sv.Quantity = ptr.Int32(int32(i64)) } 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 awsRestxml_deserializeDocumentActiveTrustedSigners(v **types.ActiveTrustedSigners, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.ActiveTrustedSigners if *v == nil { sv = &types.ActiveTrustedSigners{} } 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("Enabled", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv, err := strconv.ParseBool(string(val)) if err != nil { return fmt.Errorf("expected boolean to be of type *bool, got %T instead", val) } sv.Enabled = ptr.Bool(xtv) } case strings.EqualFold("Items", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentSignerList(&sv.Items, nodeDecoder); err != nil { return err } case strings.EqualFold("Quantity", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) i64, err := strconv.ParseInt(xtv, 10, 64) if err != nil { return err } sv.Quantity = ptr.Int32(int32(i64)) } 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 awsRestxml_deserializeDocumentAliases(v **types.Aliases, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.Aliases if *v == nil { sv = &types.Aliases{} } 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("Items", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentAliasList(&sv.Items, nodeDecoder); err != nil { return err } case strings.EqualFold("Quantity", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) i64, err := strconv.ParseInt(xtv, 10, 64) if err != nil { return err } sv.Quantity = ptr.Int32(int32(i64)) } 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 awsRestxml_deserializeDocumentAliasICPRecordal(v **types.AliasICPRecordal, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.AliasICPRecordal if *v == nil { sv = &types.AliasICPRecordal{} } 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("CNAME", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.CNAME = ptr.String(xtv) } case strings.EqualFold("ICPRecordalStatus", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.ICPRecordalStatus = types.ICPRecordalStatus(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 awsRestxml_deserializeDocumentAliasICPRecordals(v *[]types.AliasICPRecordal, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv []types.AliasICPRecordal if *v == nil { sv = make([]types.AliasICPRecordal, 0) } else { sv = *v } originalDecoder := decoder for { t, done, err := decoder.Token() if err != nil { return err } if done { break } switch { case strings.EqualFold("AliasICPRecordal", t.Name.Local): var col types.AliasICPRecordal nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) destAddr := &col if err := awsRestxml_deserializeDocumentAliasICPRecordal(&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 awsRestxml_deserializeDocumentAliasICPRecordalsUnwrapped(v *[]types.AliasICPRecordal, decoder smithyxml.NodeDecoder) error { var sv []types.AliasICPRecordal if *v == nil { sv = make([]types.AliasICPRecordal, 0) } else { sv = *v } switch { default: var mv types.AliasICPRecordal t := decoder.StartEl _ = t nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) destAddr := &mv if err := awsRestxml_deserializeDocumentAliasICPRecordal(&destAddr, nodeDecoder); err != nil { return err } mv = *destAddr sv = append(sv, mv) } *v = sv return nil } func awsRestxml_deserializeDocumentAliasList(v *[]string, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv []string if *v == nil { sv = make([]string, 0) } else { sv = *v } originalDecoder := decoder for { t, done, err := decoder.Token() if err != nil { return err } if done { break } memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) decoder = memberDecoder switch { case strings.EqualFold("CNAME", t.Name.Local): var col string val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) col = xtv } sv = append(sv, col) default: err = decoder.Decoder.Skip() if err != nil { return err } } decoder = originalDecoder } *v = sv return nil } func awsRestxml_deserializeDocumentAliasListUnwrapped(v *[]string, decoder smithyxml.NodeDecoder) error { var sv []string if *v == nil { sv = make([]string, 0) } else { sv = *v } switch { default: var mv string t := decoder.StartEl _ = t val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) mv = xtv } sv = append(sv, mv) } *v = sv return nil } func awsRestxml_deserializeDocumentAllowedMethods(v **types.AllowedMethods, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.AllowedMethods if *v == nil { sv = &types.AllowedMethods{} } 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("CachedMethods", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentCachedMethods(&sv.CachedMethods, nodeDecoder); err != nil { return err } case strings.EqualFold("Items", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentMethodsList(&sv.Items, nodeDecoder); err != nil { return err } case strings.EqualFold("Quantity", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) i64, err := strconv.ParseInt(xtv, 10, 64) if err != nil { return err } sv.Quantity = ptr.Int32(int32(i64)) } 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 awsRestxml_deserializeDocumentAwsAccountNumberList(v *[]string, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv []string if *v == nil { sv = make([]string, 0) } else { sv = *v } originalDecoder := decoder for { t, done, err := decoder.Token() if err != nil { return err } if done { break } memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) decoder = memberDecoder switch { case strings.EqualFold("AwsAccountNumber", t.Name.Local): var col string val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) col = xtv } sv = append(sv, col) default: err = decoder.Decoder.Skip() if err != nil { return err } } decoder = originalDecoder } *v = sv return nil } func awsRestxml_deserializeDocumentAwsAccountNumberListUnwrapped(v *[]string, decoder smithyxml.NodeDecoder) error { var sv []string if *v == nil { sv = make([]string, 0) } else { sv = *v } switch { default: var mv string t := decoder.StartEl _ = t val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) mv = xtv } sv = append(sv, mv) } *v = sv return nil } func awsRestxml_deserializeDocumentBatchTooLarge(v **types.BatchTooLarge, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.BatchTooLarge if *v == nil { sv = &types.BatchTooLarge{} } 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 awsRestxml_deserializeDocumentCacheBehavior(v **types.CacheBehavior, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.CacheBehavior if *v == nil { sv = &types.CacheBehavior{} } 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("AllowedMethods", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentAllowedMethods(&sv.AllowedMethods, nodeDecoder); err != nil { return err } case strings.EqualFold("CachePolicyId", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.CachePolicyId = ptr.String(xtv) } case strings.EqualFold("Compress", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv, err := strconv.ParseBool(string(val)) if err != nil { return fmt.Errorf("expected boolean to be of type *bool, got %T instead", val) } sv.Compress = ptr.Bool(xtv) } case strings.EqualFold("DefaultTTL", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) i64, err := strconv.ParseInt(xtv, 10, 64) if err != nil { return err } sv.DefaultTTL = ptr.Int64(i64) } case strings.EqualFold("FieldLevelEncryptionId", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.FieldLevelEncryptionId = ptr.String(xtv) } case strings.EqualFold("ForwardedValues", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentForwardedValues(&sv.ForwardedValues, nodeDecoder); err != nil { return err } case strings.EqualFold("FunctionAssociations", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentFunctionAssociations(&sv.FunctionAssociations, nodeDecoder); err != nil { return err } case strings.EqualFold("LambdaFunctionAssociations", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentLambdaFunctionAssociations(&sv.LambdaFunctionAssociations, nodeDecoder); err != nil { return err } case strings.EqualFold("MaxTTL", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) i64, err := strconv.ParseInt(xtv, 10, 64) if err != nil { return err } sv.MaxTTL = ptr.Int64(i64) } case strings.EqualFold("MinTTL", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) i64, err := strconv.ParseInt(xtv, 10, 64) if err != nil { return err } sv.MinTTL = ptr.Int64(i64) } case strings.EqualFold("OriginRequestPolicyId", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.OriginRequestPolicyId = ptr.String(xtv) } case strings.EqualFold("PathPattern", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.PathPattern = ptr.String(xtv) } case strings.EqualFold("RealtimeLogConfigArn", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.RealtimeLogConfigArn = ptr.String(xtv) } case strings.EqualFold("ResponseHeadersPolicyId", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.ResponseHeadersPolicyId = ptr.String(xtv) } case strings.EqualFold("SmoothStreaming", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv, err := strconv.ParseBool(string(val)) if err != nil { return fmt.Errorf("expected boolean to be of type *bool, got %T instead", val) } sv.SmoothStreaming = ptr.Bool(xtv) } case strings.EqualFold("TargetOriginId", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.TargetOriginId = ptr.String(xtv) } case strings.EqualFold("TrustedKeyGroups", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentTrustedKeyGroups(&sv.TrustedKeyGroups, nodeDecoder); err != nil { return err } case strings.EqualFold("TrustedSigners", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentTrustedSigners(&sv.TrustedSigners, nodeDecoder); err != nil { return err } case strings.EqualFold("ViewerProtocolPolicy", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.ViewerProtocolPolicy = types.ViewerProtocolPolicy(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 awsRestxml_deserializeDocumentCacheBehaviorList(v *[]types.CacheBehavior, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv []types.CacheBehavior if *v == nil { sv = make([]types.CacheBehavior, 0) } else { sv = *v } originalDecoder := decoder for { t, done, err := decoder.Token() if err != nil { return err } if done { break } switch { case strings.EqualFold("CacheBehavior", t.Name.Local): var col types.CacheBehavior nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) destAddr := &col if err := awsRestxml_deserializeDocumentCacheBehavior(&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 awsRestxml_deserializeDocumentCacheBehaviorListUnwrapped(v *[]types.CacheBehavior, decoder smithyxml.NodeDecoder) error { var sv []types.CacheBehavior if *v == nil { sv = make([]types.CacheBehavior, 0) } else { sv = *v } switch { default: var mv types.CacheBehavior t := decoder.StartEl _ = t nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) destAddr := &mv if err := awsRestxml_deserializeDocumentCacheBehavior(&destAddr, nodeDecoder); err != nil { return err } mv = *destAddr sv = append(sv, mv) } *v = sv return nil } func awsRestxml_deserializeDocumentCacheBehaviors(v **types.CacheBehaviors, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.CacheBehaviors if *v == nil { sv = &types.CacheBehaviors{} } 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("Items", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentCacheBehaviorList(&sv.Items, nodeDecoder); err != nil { return err } case strings.EqualFold("Quantity", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) i64, err := strconv.ParseInt(xtv, 10, 64) if err != nil { return err } sv.Quantity = ptr.Int32(int32(i64)) } 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 awsRestxml_deserializeDocumentCachedMethods(v **types.CachedMethods, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.CachedMethods if *v == nil { sv = &types.CachedMethods{} } 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("Items", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentMethodsList(&sv.Items, nodeDecoder); err != nil { return err } case strings.EqualFold("Quantity", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) i64, err := strconv.ParseInt(xtv, 10, 64) if err != nil { return err } sv.Quantity = ptr.Int32(int32(i64)) } 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 awsRestxml_deserializeDocumentCachePolicy(v **types.CachePolicy, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.CachePolicy if *v == nil { sv = &types.CachePolicy{} } 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("CachePolicyConfig", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentCachePolicyConfig(&sv.CachePolicyConfig, nodeDecoder); err != nil { return err } case strings.EqualFold("Id", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.Id = ptr.String(xtv) } case strings.EqualFold("LastModifiedTime", 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.LastModifiedTime = 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 awsRestxml_deserializeDocumentCachePolicyAlreadyExists(v **types.CachePolicyAlreadyExists, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.CachePolicyAlreadyExists if *v == nil { sv = &types.CachePolicyAlreadyExists{} } 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 awsRestxml_deserializeDocumentCachePolicyConfig(v **types.CachePolicyConfig, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.CachePolicyConfig if *v == nil { sv = &types.CachePolicyConfig{} } 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("Comment", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.Comment = ptr.String(xtv) } case strings.EqualFold("DefaultTTL", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) i64, err := strconv.ParseInt(xtv, 10, 64) if err != nil { return err } sv.DefaultTTL = ptr.Int64(i64) } case strings.EqualFold("MaxTTL", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) i64, err := strconv.ParseInt(xtv, 10, 64) if err != nil { return err } sv.MaxTTL = ptr.Int64(i64) } case strings.EqualFold("MinTTL", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) i64, err := strconv.ParseInt(xtv, 10, 64) if err != nil { return err } sv.MinTTL = ptr.Int64(i64) } case strings.EqualFold("Name", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.Name = ptr.String(xtv) } case strings.EqualFold("ParametersInCacheKeyAndForwardedToOrigin", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentParametersInCacheKeyAndForwardedToOrigin(&sv.ParametersInCacheKeyAndForwardedToOrigin, nodeDecoder); err != nil { return err } 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 awsRestxml_deserializeDocumentCachePolicyCookiesConfig(v **types.CachePolicyCookiesConfig, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.CachePolicyCookiesConfig if *v == nil { sv = &types.CachePolicyCookiesConfig{} } 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("CookieBehavior", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.CookieBehavior = types.CachePolicyCookieBehavior(xtv) } case strings.EqualFold("Cookies", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentCookieNames(&sv.Cookies, nodeDecoder); err != nil { return err } 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 awsRestxml_deserializeDocumentCachePolicyHeadersConfig(v **types.CachePolicyHeadersConfig, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.CachePolicyHeadersConfig if *v == nil { sv = &types.CachePolicyHeadersConfig{} } 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("HeaderBehavior", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.HeaderBehavior = types.CachePolicyHeaderBehavior(xtv) } case strings.EqualFold("Headers", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentHeaders(&sv.Headers, nodeDecoder); err != nil { return err } 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 awsRestxml_deserializeDocumentCachePolicyInUse(v **types.CachePolicyInUse, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.CachePolicyInUse if *v == nil { sv = &types.CachePolicyInUse{} } 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 awsRestxml_deserializeDocumentCachePolicyList(v **types.CachePolicyList, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.CachePolicyList if *v == nil { sv = &types.CachePolicyList{} } 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("Items", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentCachePolicySummaryList(&sv.Items, nodeDecoder); err != nil { return err } case strings.EqualFold("MaxItems", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) i64, err := strconv.ParseInt(xtv, 10, 64) if err != nil { return err } sv.MaxItems = ptr.Int32(int32(i64)) } case strings.EqualFold("NextMarker", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.NextMarker = ptr.String(xtv) } case strings.EqualFold("Quantity", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) i64, err := strconv.ParseInt(xtv, 10, 64) if err != nil { return err } sv.Quantity = ptr.Int32(int32(i64)) } 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 awsRestxml_deserializeDocumentCachePolicyQueryStringsConfig(v **types.CachePolicyQueryStringsConfig, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.CachePolicyQueryStringsConfig if *v == nil { sv = &types.CachePolicyQueryStringsConfig{} } 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("QueryStringBehavior", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.QueryStringBehavior = types.CachePolicyQueryStringBehavior(xtv) } case strings.EqualFold("QueryStrings", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentQueryStringNames(&sv.QueryStrings, nodeDecoder); err != nil { return err } 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 awsRestxml_deserializeDocumentCachePolicySummary(v **types.CachePolicySummary, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.CachePolicySummary if *v == nil { sv = &types.CachePolicySummary{} } 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("CachePolicy", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentCachePolicy(&sv.CachePolicy, nodeDecoder); err != nil { return err } case strings.EqualFold("Type", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.Type = types.CachePolicyType(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 awsRestxml_deserializeDocumentCachePolicySummaryList(v *[]types.CachePolicySummary, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv []types.CachePolicySummary if *v == nil { sv = make([]types.CachePolicySummary, 0) } else { sv = *v } originalDecoder := decoder for { t, done, err := decoder.Token() if err != nil { return err } if done { break } switch { case strings.EqualFold("CachePolicySummary", t.Name.Local): var col types.CachePolicySummary nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) destAddr := &col if err := awsRestxml_deserializeDocumentCachePolicySummary(&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 awsRestxml_deserializeDocumentCachePolicySummaryListUnwrapped(v *[]types.CachePolicySummary, decoder smithyxml.NodeDecoder) error { var sv []types.CachePolicySummary if *v == nil { sv = make([]types.CachePolicySummary, 0) } else { sv = *v } switch { default: var mv types.CachePolicySummary t := decoder.StartEl _ = t nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) destAddr := &mv if err := awsRestxml_deserializeDocumentCachePolicySummary(&destAddr, nodeDecoder); err != nil { return err } mv = *destAddr sv = append(sv, mv) } *v = sv return nil } func awsRestxml_deserializeDocumentCannotChangeImmutablePublicKeyFields(v **types.CannotChangeImmutablePublicKeyFields, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.CannotChangeImmutablePublicKeyFields if *v == nil { sv = &types.CannotChangeImmutablePublicKeyFields{} } 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 awsRestxml_deserializeDocumentCloudFrontOriginAccessIdentity(v **types.CloudFrontOriginAccessIdentity, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.CloudFrontOriginAccessIdentity if *v == nil { sv = &types.CloudFrontOriginAccessIdentity{} } 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("CloudFrontOriginAccessIdentityConfig", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentCloudFrontOriginAccessIdentityConfig(&sv.CloudFrontOriginAccessIdentityConfig, nodeDecoder); err != nil { return err } case strings.EqualFold("Id", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.Id = ptr.String(xtv) } case strings.EqualFold("S3CanonicalUserId", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.S3CanonicalUserId = 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 awsRestxml_deserializeDocumentCloudFrontOriginAccessIdentityAlreadyExists(v **types.CloudFrontOriginAccessIdentityAlreadyExists, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.CloudFrontOriginAccessIdentityAlreadyExists if *v == nil { sv = &types.CloudFrontOriginAccessIdentityAlreadyExists{} } 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 awsRestxml_deserializeDocumentCloudFrontOriginAccessIdentityConfig(v **types.CloudFrontOriginAccessIdentityConfig, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.CloudFrontOriginAccessIdentityConfig if *v == nil { sv = &types.CloudFrontOriginAccessIdentityConfig{} } 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("CallerReference", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.CallerReference = ptr.String(xtv) } case strings.EqualFold("Comment", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.Comment = 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 awsRestxml_deserializeDocumentCloudFrontOriginAccessIdentityInUse(v **types.CloudFrontOriginAccessIdentityInUse, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.CloudFrontOriginAccessIdentityInUse if *v == nil { sv = &types.CloudFrontOriginAccessIdentityInUse{} } 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 awsRestxml_deserializeDocumentCloudFrontOriginAccessIdentityList(v **types.CloudFrontOriginAccessIdentityList, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.CloudFrontOriginAccessIdentityList if *v == nil { sv = &types.CloudFrontOriginAccessIdentityList{} } 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("IsTruncated", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv, err := strconv.ParseBool(string(val)) if err != nil { return fmt.Errorf("expected boolean to be of type *bool, got %T instead", val) } sv.IsTruncated = ptr.Bool(xtv) } case strings.EqualFold("Items", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentCloudFrontOriginAccessIdentitySummaryList(&sv.Items, 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) } case strings.EqualFold("MaxItems", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) i64, err := strconv.ParseInt(xtv, 10, 64) if err != nil { return err } sv.MaxItems = ptr.Int32(int32(i64)) } case strings.EqualFold("NextMarker", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.NextMarker = ptr.String(xtv) } case strings.EqualFold("Quantity", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) i64, err := strconv.ParseInt(xtv, 10, 64) if err != nil { return err } sv.Quantity = ptr.Int32(int32(i64)) } 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 awsRestxml_deserializeDocumentCloudFrontOriginAccessIdentitySummary(v **types.CloudFrontOriginAccessIdentitySummary, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.CloudFrontOriginAccessIdentitySummary if *v == nil { sv = &types.CloudFrontOriginAccessIdentitySummary{} } 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("Comment", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.Comment = ptr.String(xtv) } case strings.EqualFold("Id", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.Id = ptr.String(xtv) } case strings.EqualFold("S3CanonicalUserId", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.S3CanonicalUserId = 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 awsRestxml_deserializeDocumentCloudFrontOriginAccessIdentitySummaryList(v *[]types.CloudFrontOriginAccessIdentitySummary, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv []types.CloudFrontOriginAccessIdentitySummary if *v == nil { sv = make([]types.CloudFrontOriginAccessIdentitySummary, 0) } else { sv = *v } originalDecoder := decoder for { t, done, err := decoder.Token() if err != nil { return err } if done { break } switch { case strings.EqualFold("CloudFrontOriginAccessIdentitySummary", t.Name.Local): var col types.CloudFrontOriginAccessIdentitySummary nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) destAddr := &col if err := awsRestxml_deserializeDocumentCloudFrontOriginAccessIdentitySummary(&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 awsRestxml_deserializeDocumentCloudFrontOriginAccessIdentitySummaryListUnwrapped(v *[]types.CloudFrontOriginAccessIdentitySummary, decoder smithyxml.NodeDecoder) error { var sv []types.CloudFrontOriginAccessIdentitySummary if *v == nil { sv = make([]types.CloudFrontOriginAccessIdentitySummary, 0) } else { sv = *v } switch { default: var mv types.CloudFrontOriginAccessIdentitySummary t := decoder.StartEl _ = t nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) destAddr := &mv if err := awsRestxml_deserializeDocumentCloudFrontOriginAccessIdentitySummary(&destAddr, nodeDecoder); err != nil { return err } mv = *destAddr sv = append(sv, mv) } *v = sv return nil } func awsRestxml_deserializeDocumentCNAMEAlreadyExists(v **types.CNAMEAlreadyExists, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.CNAMEAlreadyExists if *v == nil { sv = &types.CNAMEAlreadyExists{} } 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 awsRestxml_deserializeDocumentConflictingAlias(v **types.ConflictingAlias, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.ConflictingAlias if *v == nil { sv = &types.ConflictingAlias{} } 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("AccountId", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.AccountId = ptr.String(xtv) } case strings.EqualFold("Alias", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.Alias = ptr.String(xtv) } case strings.EqualFold("DistributionId", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.DistributionId = 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 awsRestxml_deserializeDocumentConflictingAliases(v *[]types.ConflictingAlias, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv []types.ConflictingAlias if *v == nil { sv = make([]types.ConflictingAlias, 0) } else { sv = *v } originalDecoder := decoder for { t, done, err := decoder.Token() if err != nil { return err } if done { break } switch { case strings.EqualFold("ConflictingAlias", t.Name.Local): var col types.ConflictingAlias nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) destAddr := &col if err := awsRestxml_deserializeDocumentConflictingAlias(&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 awsRestxml_deserializeDocumentConflictingAliasesUnwrapped(v *[]types.ConflictingAlias, decoder smithyxml.NodeDecoder) error { var sv []types.ConflictingAlias if *v == nil { sv = make([]types.ConflictingAlias, 0) } else { sv = *v } switch { default: var mv types.ConflictingAlias t := decoder.StartEl _ = t nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) destAddr := &mv if err := awsRestxml_deserializeDocumentConflictingAlias(&destAddr, nodeDecoder); err != nil { return err } mv = *destAddr sv = append(sv, mv) } *v = sv return nil } func awsRestxml_deserializeDocumentConflictingAliasesList(v **types.ConflictingAliasesList, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.ConflictingAliasesList if *v == nil { sv = &types.ConflictingAliasesList{} } 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("Items", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentConflictingAliases(&sv.Items, nodeDecoder); err != nil { return err } case strings.EqualFold("MaxItems", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) i64, err := strconv.ParseInt(xtv, 10, 64) if err != nil { return err } sv.MaxItems = ptr.Int32(int32(i64)) } case strings.EqualFold("NextMarker", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.NextMarker = ptr.String(xtv) } case strings.EqualFold("Quantity", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) i64, err := strconv.ParseInt(xtv, 10, 64) if err != nil { return err } sv.Quantity = ptr.Int32(int32(i64)) } 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 awsRestxml_deserializeDocumentContentTypeProfile(v **types.ContentTypeProfile, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.ContentTypeProfile if *v == nil { sv = &types.ContentTypeProfile{} } 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("ContentType", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.ContentType = ptr.String(xtv) } case strings.EqualFold("Format", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.Format = types.Format(xtv) } case strings.EqualFold("ProfileId", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.ProfileId = 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 awsRestxml_deserializeDocumentContentTypeProfileConfig(v **types.ContentTypeProfileConfig, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.ContentTypeProfileConfig if *v == nil { sv = &types.ContentTypeProfileConfig{} } 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("ContentTypeProfiles", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentContentTypeProfiles(&sv.ContentTypeProfiles, nodeDecoder); err != nil { return err } case strings.EqualFold("ForwardWhenContentTypeIsUnknown", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv, err := strconv.ParseBool(string(val)) if err != nil { return fmt.Errorf("expected boolean to be of type *bool, got %T instead", val) } sv.ForwardWhenContentTypeIsUnknown = ptr.Bool(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 awsRestxml_deserializeDocumentContentTypeProfileList(v *[]types.ContentTypeProfile, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv []types.ContentTypeProfile if *v == nil { sv = make([]types.ContentTypeProfile, 0) } else { sv = *v } originalDecoder := decoder for { t, done, err := decoder.Token() if err != nil { return err } if done { break } switch { case strings.EqualFold("ContentTypeProfile", t.Name.Local): var col types.ContentTypeProfile nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) destAddr := &col if err := awsRestxml_deserializeDocumentContentTypeProfile(&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 awsRestxml_deserializeDocumentContentTypeProfileListUnwrapped(v *[]types.ContentTypeProfile, decoder smithyxml.NodeDecoder) error { var sv []types.ContentTypeProfile if *v == nil { sv = make([]types.ContentTypeProfile, 0) } else { sv = *v } switch { default: var mv types.ContentTypeProfile t := decoder.StartEl _ = t nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) destAddr := &mv if err := awsRestxml_deserializeDocumentContentTypeProfile(&destAddr, nodeDecoder); err != nil { return err } mv = *destAddr sv = append(sv, mv) } *v = sv return nil } func awsRestxml_deserializeDocumentContentTypeProfiles(v **types.ContentTypeProfiles, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.ContentTypeProfiles if *v == nil { sv = &types.ContentTypeProfiles{} } 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("Items", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentContentTypeProfileList(&sv.Items, nodeDecoder); err != nil { return err } case strings.EqualFold("Quantity", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) i64, err := strconv.ParseInt(xtv, 10, 64) if err != nil { return err } sv.Quantity = ptr.Int32(int32(i64)) } 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 awsRestxml_deserializeDocumentContinuousDeploymentPolicy(v **types.ContinuousDeploymentPolicy, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.ContinuousDeploymentPolicy if *v == nil { sv = &types.ContinuousDeploymentPolicy{} } 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("ContinuousDeploymentPolicyConfig", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentContinuousDeploymentPolicyConfig(&sv.ContinuousDeploymentPolicyConfig, nodeDecoder); err != nil { return err } case strings.EqualFold("Id", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.Id = ptr.String(xtv) } case strings.EqualFold("LastModifiedTime", 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.LastModifiedTime = 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 awsRestxml_deserializeDocumentContinuousDeploymentPolicyAlreadyExists(v **types.ContinuousDeploymentPolicyAlreadyExists, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.ContinuousDeploymentPolicyAlreadyExists if *v == nil { sv = &types.ContinuousDeploymentPolicyAlreadyExists{} } 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 awsRestxml_deserializeDocumentContinuousDeploymentPolicyConfig(v **types.ContinuousDeploymentPolicyConfig, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.ContinuousDeploymentPolicyConfig if *v == nil { sv = &types.ContinuousDeploymentPolicyConfig{} } 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("Enabled", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv, err := strconv.ParseBool(string(val)) if err != nil { return fmt.Errorf("expected boolean to be of type *bool, got %T instead", val) } sv.Enabled = ptr.Bool(xtv) } case strings.EqualFold("StagingDistributionDnsNames", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentStagingDistributionDnsNames(&sv.StagingDistributionDnsNames, nodeDecoder); err != nil { return err } case strings.EqualFold("TrafficConfig", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentTrafficConfig(&sv.TrafficConfig, nodeDecoder); err != nil { return err } 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 awsRestxml_deserializeDocumentContinuousDeploymentPolicyInUse(v **types.ContinuousDeploymentPolicyInUse, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.ContinuousDeploymentPolicyInUse if *v == nil { sv = &types.ContinuousDeploymentPolicyInUse{} } 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 awsRestxml_deserializeDocumentContinuousDeploymentPolicyList(v **types.ContinuousDeploymentPolicyList, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.ContinuousDeploymentPolicyList if *v == nil { sv = &types.ContinuousDeploymentPolicyList{} } 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("Items", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentContinuousDeploymentPolicySummaryList(&sv.Items, nodeDecoder); err != nil { return err } case strings.EqualFold("MaxItems", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) i64, err := strconv.ParseInt(xtv, 10, 64) if err != nil { return err } sv.MaxItems = ptr.Int32(int32(i64)) } case strings.EqualFold("NextMarker", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.NextMarker = ptr.String(xtv) } case strings.EqualFold("Quantity", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) i64, err := strconv.ParseInt(xtv, 10, 64) if err != nil { return err } sv.Quantity = ptr.Int32(int32(i64)) } 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 awsRestxml_deserializeDocumentContinuousDeploymentPolicySummary(v **types.ContinuousDeploymentPolicySummary, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.ContinuousDeploymentPolicySummary if *v == nil { sv = &types.ContinuousDeploymentPolicySummary{} } 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("ContinuousDeploymentPolicy", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentContinuousDeploymentPolicy(&sv.ContinuousDeploymentPolicy, nodeDecoder); err != nil { return err } 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 awsRestxml_deserializeDocumentContinuousDeploymentPolicySummaryList(v *[]types.ContinuousDeploymentPolicySummary, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv []types.ContinuousDeploymentPolicySummary if *v == nil { sv = make([]types.ContinuousDeploymentPolicySummary, 0) } else { sv = *v } originalDecoder := decoder for { t, done, err := decoder.Token() if err != nil { return err } if done { break } switch { case strings.EqualFold("ContinuousDeploymentPolicySummary", t.Name.Local): var col types.ContinuousDeploymentPolicySummary nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) destAddr := &col if err := awsRestxml_deserializeDocumentContinuousDeploymentPolicySummary(&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 awsRestxml_deserializeDocumentContinuousDeploymentPolicySummaryListUnwrapped(v *[]types.ContinuousDeploymentPolicySummary, decoder smithyxml.NodeDecoder) error { var sv []types.ContinuousDeploymentPolicySummary if *v == nil { sv = make([]types.ContinuousDeploymentPolicySummary, 0) } else { sv = *v } switch { default: var mv types.ContinuousDeploymentPolicySummary t := decoder.StartEl _ = t nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) destAddr := &mv if err := awsRestxml_deserializeDocumentContinuousDeploymentPolicySummary(&destAddr, nodeDecoder); err != nil { return err } mv = *destAddr sv = append(sv, mv) } *v = sv return nil } func awsRestxml_deserializeDocumentContinuousDeploymentSingleHeaderConfig(v **types.ContinuousDeploymentSingleHeaderConfig, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.ContinuousDeploymentSingleHeaderConfig if *v == nil { sv = &types.ContinuousDeploymentSingleHeaderConfig{} } 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("Header", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.Header = ptr.String(xtv) } case strings.EqualFold("Value", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.Value = 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 awsRestxml_deserializeDocumentContinuousDeploymentSingleWeightConfig(v **types.ContinuousDeploymentSingleWeightConfig, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.ContinuousDeploymentSingleWeightConfig if *v == nil { sv = &types.ContinuousDeploymentSingleWeightConfig{} } 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("SessionStickinessConfig", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentSessionStickinessConfig(&sv.SessionStickinessConfig, nodeDecoder); err != nil { return err } case strings.EqualFold("Weight", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) f64, err := strconv.ParseFloat(xtv, 64) if err != nil { return err } sv.Weight = ptr.Float32(float32(f64)) } 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 awsRestxml_deserializeDocumentCookieNameList(v *[]string, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv []string if *v == nil { sv = make([]string, 0) } else { sv = *v } originalDecoder := decoder for { t, done, err := decoder.Token() if err != nil { return err } if done { break } memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) decoder = memberDecoder switch { case strings.EqualFold("Name", t.Name.Local): var col string val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) col = xtv } sv = append(sv, col) default: err = decoder.Decoder.Skip() if err != nil { return err } } decoder = originalDecoder } *v = sv return nil } func awsRestxml_deserializeDocumentCookieNameListUnwrapped(v *[]string, decoder smithyxml.NodeDecoder) error { var sv []string if *v == nil { sv = make([]string, 0) } else { sv = *v } switch { default: var mv string t := decoder.StartEl _ = t val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) mv = xtv } sv = append(sv, mv) } *v = sv return nil } func awsRestxml_deserializeDocumentCookieNames(v **types.CookieNames, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.CookieNames if *v == nil { sv = &types.CookieNames{} } 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("Items", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentCookieNameList(&sv.Items, nodeDecoder); err != nil { return err } case strings.EqualFold("Quantity", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) i64, err := strconv.ParseInt(xtv, 10, 64) if err != nil { return err } sv.Quantity = ptr.Int32(int32(i64)) } 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 awsRestxml_deserializeDocumentCookiePreference(v **types.CookiePreference, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.CookiePreference if *v == nil { sv = &types.CookiePreference{} } 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("Forward", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.Forward = types.ItemSelection(xtv) } case strings.EqualFold("WhitelistedNames", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentCookieNames(&sv.WhitelistedNames, nodeDecoder); err != nil { return err } 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 awsRestxml_deserializeDocumentCustomErrorResponse(v **types.CustomErrorResponse, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.CustomErrorResponse if *v == nil { sv = &types.CustomErrorResponse{} } 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("ErrorCachingMinTTL", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) i64, err := strconv.ParseInt(xtv, 10, 64) if err != nil { return err } sv.ErrorCachingMinTTL = ptr.Int64(i64) } case strings.EqualFold("ErrorCode", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) i64, err := strconv.ParseInt(xtv, 10, 64) if err != nil { return err } sv.ErrorCode = ptr.Int32(int32(i64)) } case strings.EqualFold("ResponseCode", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.ResponseCode = ptr.String(xtv) } case strings.EqualFold("ResponsePagePath", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.ResponsePagePath = 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 awsRestxml_deserializeDocumentCustomErrorResponseList(v *[]types.CustomErrorResponse, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv []types.CustomErrorResponse if *v == nil { sv = make([]types.CustomErrorResponse, 0) } else { sv = *v } originalDecoder := decoder for { t, done, err := decoder.Token() if err != nil { return err } if done { break } switch { case strings.EqualFold("CustomErrorResponse", t.Name.Local): var col types.CustomErrorResponse nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) destAddr := &col if err := awsRestxml_deserializeDocumentCustomErrorResponse(&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 awsRestxml_deserializeDocumentCustomErrorResponseListUnwrapped(v *[]types.CustomErrorResponse, decoder smithyxml.NodeDecoder) error { var sv []types.CustomErrorResponse if *v == nil { sv = make([]types.CustomErrorResponse, 0) } else { sv = *v } switch { default: var mv types.CustomErrorResponse t := decoder.StartEl _ = t nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) destAddr := &mv if err := awsRestxml_deserializeDocumentCustomErrorResponse(&destAddr, nodeDecoder); err != nil { return err } mv = *destAddr sv = append(sv, mv) } *v = sv return nil } func awsRestxml_deserializeDocumentCustomErrorResponses(v **types.CustomErrorResponses, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.CustomErrorResponses if *v == nil { sv = &types.CustomErrorResponses{} } 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("Items", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentCustomErrorResponseList(&sv.Items, nodeDecoder); err != nil { return err } case strings.EqualFold("Quantity", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) i64, err := strconv.ParseInt(xtv, 10, 64) if err != nil { return err } sv.Quantity = ptr.Int32(int32(i64)) } 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 awsRestxml_deserializeDocumentCustomHeaders(v **types.CustomHeaders, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.CustomHeaders if *v == nil { sv = &types.CustomHeaders{} } 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("Items", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentOriginCustomHeadersList(&sv.Items, nodeDecoder); err != nil { return err } case strings.EqualFold("Quantity", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) i64, err := strconv.ParseInt(xtv, 10, 64) if err != nil { return err } sv.Quantity = ptr.Int32(int32(i64)) } 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 awsRestxml_deserializeDocumentCustomOriginConfig(v **types.CustomOriginConfig, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.CustomOriginConfig if *v == nil { sv = &types.CustomOriginConfig{} } 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("HTTPPort", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) i64, err := strconv.ParseInt(xtv, 10, 64) if err != nil { return err } sv.HTTPPort = ptr.Int32(int32(i64)) } case strings.EqualFold("HTTPSPort", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) i64, err := strconv.ParseInt(xtv, 10, 64) if err != nil { return err } sv.HTTPSPort = ptr.Int32(int32(i64)) } case strings.EqualFold("OriginKeepaliveTimeout", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) i64, err := strconv.ParseInt(xtv, 10, 64) if err != nil { return err } sv.OriginKeepaliveTimeout = ptr.Int32(int32(i64)) } case strings.EqualFold("OriginProtocolPolicy", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.OriginProtocolPolicy = types.OriginProtocolPolicy(xtv) } case strings.EqualFold("OriginReadTimeout", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) i64, err := strconv.ParseInt(xtv, 10, 64) if err != nil { return err } sv.OriginReadTimeout = ptr.Int32(int32(i64)) } case strings.EqualFold("OriginSslProtocols", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentOriginSslProtocols(&sv.OriginSslProtocols, nodeDecoder); err != nil { return err } 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 awsRestxml_deserializeDocumentDefaultCacheBehavior(v **types.DefaultCacheBehavior, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.DefaultCacheBehavior if *v == nil { sv = &types.DefaultCacheBehavior{} } 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("AllowedMethods", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentAllowedMethods(&sv.AllowedMethods, nodeDecoder); err != nil { return err } case strings.EqualFold("CachePolicyId", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.CachePolicyId = ptr.String(xtv) } case strings.EqualFold("Compress", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv, err := strconv.ParseBool(string(val)) if err != nil { return fmt.Errorf("expected boolean to be of type *bool, got %T instead", val) } sv.Compress = ptr.Bool(xtv) } case strings.EqualFold("DefaultTTL", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) i64, err := strconv.ParseInt(xtv, 10, 64) if err != nil { return err } sv.DefaultTTL = ptr.Int64(i64) } case strings.EqualFold("FieldLevelEncryptionId", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.FieldLevelEncryptionId = ptr.String(xtv) } case strings.EqualFold("ForwardedValues", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentForwardedValues(&sv.ForwardedValues, nodeDecoder); err != nil { return err } case strings.EqualFold("FunctionAssociations", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentFunctionAssociations(&sv.FunctionAssociations, nodeDecoder); err != nil { return err } case strings.EqualFold("LambdaFunctionAssociations", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentLambdaFunctionAssociations(&sv.LambdaFunctionAssociations, nodeDecoder); err != nil { return err } case strings.EqualFold("MaxTTL", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) i64, err := strconv.ParseInt(xtv, 10, 64) if err != nil { return err } sv.MaxTTL = ptr.Int64(i64) } case strings.EqualFold("MinTTL", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) i64, err := strconv.ParseInt(xtv, 10, 64) if err != nil { return err } sv.MinTTL = ptr.Int64(i64) } case strings.EqualFold("OriginRequestPolicyId", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.OriginRequestPolicyId = ptr.String(xtv) } case strings.EqualFold("RealtimeLogConfigArn", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.RealtimeLogConfigArn = ptr.String(xtv) } case strings.EqualFold("ResponseHeadersPolicyId", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.ResponseHeadersPolicyId = ptr.String(xtv) } case strings.EqualFold("SmoothStreaming", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv, err := strconv.ParseBool(string(val)) if err != nil { return fmt.Errorf("expected boolean to be of type *bool, got %T instead", val) } sv.SmoothStreaming = ptr.Bool(xtv) } case strings.EqualFold("TargetOriginId", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.TargetOriginId = ptr.String(xtv) } case strings.EqualFold("TrustedKeyGroups", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentTrustedKeyGroups(&sv.TrustedKeyGroups, nodeDecoder); err != nil { return err } case strings.EqualFold("TrustedSigners", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentTrustedSigners(&sv.TrustedSigners, nodeDecoder); err != nil { return err } case strings.EqualFold("ViewerProtocolPolicy", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.ViewerProtocolPolicy = types.ViewerProtocolPolicy(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 awsRestxml_deserializeDocumentDistribution(v **types.Distribution, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.Distribution if *v == nil { sv = &types.Distribution{} } 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("ActiveTrustedKeyGroups", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentActiveTrustedKeyGroups(&sv.ActiveTrustedKeyGroups, nodeDecoder); err != nil { return err } case strings.EqualFold("ActiveTrustedSigners", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentActiveTrustedSigners(&sv.ActiveTrustedSigners, nodeDecoder); err != nil { return err } case strings.EqualFold("AliasICPRecordals", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentAliasICPRecordals(&sv.AliasICPRecordals, nodeDecoder); err != nil { return err } case strings.EqualFold("ARN", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.ARN = ptr.String(xtv) } case strings.EqualFold("DistributionConfig", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentDistributionConfig(&sv.DistributionConfig, nodeDecoder); err != nil { return err } case strings.EqualFold("DomainName", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.DomainName = ptr.String(xtv) } case strings.EqualFold("Id", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.Id = ptr.String(xtv) } case strings.EqualFold("InProgressInvalidationBatches", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) i64, err := strconv.ParseInt(xtv, 10, 64) if err != nil { return err } sv.InProgressInvalidationBatches = ptr.Int32(int32(i64)) } case strings.EqualFold("LastModifiedTime", 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.LastModifiedTime = ptr.Time(t) } case strings.EqualFold("Status", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.Status = 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 awsRestxml_deserializeDocumentDistributionAlreadyExists(v **types.DistributionAlreadyExists, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.DistributionAlreadyExists if *v == nil { sv = &types.DistributionAlreadyExists{} } 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 awsRestxml_deserializeDocumentDistributionConfig(v **types.DistributionConfig, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.DistributionConfig if *v == nil { sv = &types.DistributionConfig{} } 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("Aliases", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentAliases(&sv.Aliases, nodeDecoder); err != nil { return err } case strings.EqualFold("CacheBehaviors", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentCacheBehaviors(&sv.CacheBehaviors, nodeDecoder); err != nil { return err } case strings.EqualFold("CallerReference", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.CallerReference = ptr.String(xtv) } case strings.EqualFold("Comment", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.Comment = ptr.String(xtv) } case strings.EqualFold("ContinuousDeploymentPolicyId", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.ContinuousDeploymentPolicyId = ptr.String(xtv) } case strings.EqualFold("CustomErrorResponses", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentCustomErrorResponses(&sv.CustomErrorResponses, nodeDecoder); err != nil { return err } case strings.EqualFold("DefaultCacheBehavior", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentDefaultCacheBehavior(&sv.DefaultCacheBehavior, nodeDecoder); err != nil { return err } case strings.EqualFold("DefaultRootObject", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.DefaultRootObject = ptr.String(xtv) } case strings.EqualFold("Enabled", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv, err := strconv.ParseBool(string(val)) if err != nil { return fmt.Errorf("expected boolean to be of type *bool, got %T instead", val) } sv.Enabled = ptr.Bool(xtv) } case strings.EqualFold("HttpVersion", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.HttpVersion = types.HttpVersion(xtv) } case strings.EqualFold("IsIPV6Enabled", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv, err := strconv.ParseBool(string(val)) if err != nil { return fmt.Errorf("expected boolean to be of type *bool, got %T instead", val) } sv.IsIPV6Enabled = ptr.Bool(xtv) } case strings.EqualFold("Logging", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentLoggingConfig(&sv.Logging, nodeDecoder); err != nil { return err } case strings.EqualFold("OriginGroups", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentOriginGroups(&sv.OriginGroups, nodeDecoder); err != nil { return err } case strings.EqualFold("Origins", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentOrigins(&sv.Origins, nodeDecoder); err != nil { return err } case strings.EqualFold("PriceClass", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.PriceClass = types.PriceClass(xtv) } case strings.EqualFold("Restrictions", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentRestrictions(&sv.Restrictions, nodeDecoder); err != nil { return err } case strings.EqualFold("Staging", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv, err := strconv.ParseBool(string(val)) if err != nil { return fmt.Errorf("expected boolean to be of type *bool, got %T instead", val) } sv.Staging = ptr.Bool(xtv) } case strings.EqualFold("ViewerCertificate", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentViewerCertificate(&sv.ViewerCertificate, nodeDecoder); err != nil { return err } case strings.EqualFold("WebACLId", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.WebACLId = 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 awsRestxml_deserializeDocumentDistributionIdList(v **types.DistributionIdList, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.DistributionIdList if *v == nil { sv = &types.DistributionIdList{} } 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("IsTruncated", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv, err := strconv.ParseBool(string(val)) if err != nil { return fmt.Errorf("expected boolean to be of type *bool, got %T instead", val) } sv.IsTruncated = ptr.Bool(xtv) } case strings.EqualFold("Items", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentDistributionIdListSummary(&sv.Items, 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) } case strings.EqualFold("MaxItems", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) i64, err := strconv.ParseInt(xtv, 10, 64) if err != nil { return err } sv.MaxItems = ptr.Int32(int32(i64)) } case strings.EqualFold("NextMarker", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.NextMarker = ptr.String(xtv) } case strings.EqualFold("Quantity", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) i64, err := strconv.ParseInt(xtv, 10, 64) if err != nil { return err } sv.Quantity = ptr.Int32(int32(i64)) } 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 awsRestxml_deserializeDocumentDistributionIdListSummary(v *[]string, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv []string if *v == nil { sv = make([]string, 0) } else { sv = *v } originalDecoder := decoder for { t, done, err := decoder.Token() if err != nil { return err } if done { break } memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) decoder = memberDecoder switch { case strings.EqualFold("DistributionId", t.Name.Local): var col string val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) col = xtv } sv = append(sv, col) default: err = decoder.Decoder.Skip() if err != nil { return err } } decoder = originalDecoder } *v = sv return nil } func awsRestxml_deserializeDocumentDistributionIdListSummaryUnwrapped(v *[]string, decoder smithyxml.NodeDecoder) error { var sv []string if *v == nil { sv = make([]string, 0) } else { sv = *v } switch { default: var mv string t := decoder.StartEl _ = t val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) mv = xtv } sv = append(sv, mv) } *v = sv return nil } func awsRestxml_deserializeDocumentDistributionList(v **types.DistributionList, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.DistributionList if *v == nil { sv = &types.DistributionList{} } 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("IsTruncated", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv, err := strconv.ParseBool(string(val)) if err != nil { return fmt.Errorf("expected boolean to be of type *bool, got %T instead", val) } sv.IsTruncated = ptr.Bool(xtv) } case strings.EqualFold("Items", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentDistributionSummaryList(&sv.Items, 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) } case strings.EqualFold("MaxItems", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) i64, err := strconv.ParseInt(xtv, 10, 64) if err != nil { return err } sv.MaxItems = ptr.Int32(int32(i64)) } case strings.EqualFold("NextMarker", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.NextMarker = ptr.String(xtv) } case strings.EqualFold("Quantity", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) i64, err := strconv.ParseInt(xtv, 10, 64) if err != nil { return err } sv.Quantity = ptr.Int32(int32(i64)) } 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 awsRestxml_deserializeDocumentDistributionNotDisabled(v **types.DistributionNotDisabled, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.DistributionNotDisabled if *v == nil { sv = &types.DistributionNotDisabled{} } 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 awsRestxml_deserializeDocumentDistributionSummary(v **types.DistributionSummary, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.DistributionSummary if *v == nil { sv = &types.DistributionSummary{} } 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("Aliases", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentAliases(&sv.Aliases, nodeDecoder); err != nil { return err } case strings.EqualFold("AliasICPRecordals", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentAliasICPRecordals(&sv.AliasICPRecordals, nodeDecoder); err != nil { return err } case strings.EqualFold("ARN", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.ARN = ptr.String(xtv) } case strings.EqualFold("CacheBehaviors", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentCacheBehaviors(&sv.CacheBehaviors, nodeDecoder); err != nil { return err } case strings.EqualFold("Comment", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.Comment = ptr.String(xtv) } case strings.EqualFold("CustomErrorResponses", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentCustomErrorResponses(&sv.CustomErrorResponses, nodeDecoder); err != nil { return err } case strings.EqualFold("DefaultCacheBehavior", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentDefaultCacheBehavior(&sv.DefaultCacheBehavior, nodeDecoder); err != nil { return err } case strings.EqualFold("DomainName", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.DomainName = ptr.String(xtv) } case strings.EqualFold("Enabled", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv, err := strconv.ParseBool(string(val)) if err != nil { return fmt.Errorf("expected boolean to be of type *bool, got %T instead", val) } sv.Enabled = ptr.Bool(xtv) } case strings.EqualFold("HttpVersion", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.HttpVersion = types.HttpVersion(xtv) } case strings.EqualFold("Id", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.Id = ptr.String(xtv) } case strings.EqualFold("IsIPV6Enabled", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv, err := strconv.ParseBool(string(val)) if err != nil { return fmt.Errorf("expected boolean to be of type *bool, got %T instead", val) } sv.IsIPV6Enabled = ptr.Bool(xtv) } case strings.EqualFold("LastModifiedTime", 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.LastModifiedTime = ptr.Time(t) } case strings.EqualFold("OriginGroups", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentOriginGroups(&sv.OriginGroups, nodeDecoder); err != nil { return err } case strings.EqualFold("Origins", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentOrigins(&sv.Origins, nodeDecoder); err != nil { return err } case strings.EqualFold("PriceClass", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.PriceClass = types.PriceClass(xtv) } case strings.EqualFold("Restrictions", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentRestrictions(&sv.Restrictions, nodeDecoder); err != nil { return err } case strings.EqualFold("Staging", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv, err := strconv.ParseBool(string(val)) if err != nil { return fmt.Errorf("expected boolean to be of type *bool, got %T instead", val) } sv.Staging = ptr.Bool(xtv) } case strings.EqualFold("Status", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.Status = ptr.String(xtv) } case strings.EqualFold("ViewerCertificate", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentViewerCertificate(&sv.ViewerCertificate, nodeDecoder); err != nil { return err } case strings.EqualFold("WebACLId", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.WebACLId = 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 awsRestxml_deserializeDocumentDistributionSummaryList(v *[]types.DistributionSummary, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv []types.DistributionSummary if *v == nil { sv = make([]types.DistributionSummary, 0) } else { sv = *v } originalDecoder := decoder for { t, done, err := decoder.Token() if err != nil { return err } if done { break } switch { case strings.EqualFold("DistributionSummary", t.Name.Local): var col types.DistributionSummary nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) destAddr := &col if err := awsRestxml_deserializeDocumentDistributionSummary(&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 awsRestxml_deserializeDocumentDistributionSummaryListUnwrapped(v *[]types.DistributionSummary, decoder smithyxml.NodeDecoder) error { var sv []types.DistributionSummary if *v == nil { sv = make([]types.DistributionSummary, 0) } else { sv = *v } switch { default: var mv types.DistributionSummary t := decoder.StartEl _ = t nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) destAddr := &mv if err := awsRestxml_deserializeDocumentDistributionSummary(&destAddr, nodeDecoder); err != nil { return err } mv = *destAddr sv = append(sv, mv) } *v = sv return nil } func awsRestxml_deserializeDocumentEncryptionEntities(v **types.EncryptionEntities, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.EncryptionEntities if *v == nil { sv = &types.EncryptionEntities{} } 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("Items", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentEncryptionEntityList(&sv.Items, nodeDecoder); err != nil { return err } case strings.EqualFold("Quantity", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) i64, err := strconv.ParseInt(xtv, 10, 64) if err != nil { return err } sv.Quantity = ptr.Int32(int32(i64)) } 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 awsRestxml_deserializeDocumentEncryptionEntity(v **types.EncryptionEntity, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.EncryptionEntity if *v == nil { sv = &types.EncryptionEntity{} } 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("FieldPatterns", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentFieldPatterns(&sv.FieldPatterns, nodeDecoder); err != nil { return err } case strings.EqualFold("ProviderId", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.ProviderId = ptr.String(xtv) } case strings.EqualFold("PublicKeyId", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.PublicKeyId = 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 awsRestxml_deserializeDocumentEncryptionEntityList(v *[]types.EncryptionEntity, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv []types.EncryptionEntity if *v == nil { sv = make([]types.EncryptionEntity, 0) } else { sv = *v } originalDecoder := decoder for { t, done, err := decoder.Token() if err != nil { return err } if done { break } switch { case strings.EqualFold("EncryptionEntity", t.Name.Local): var col types.EncryptionEntity nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) destAddr := &col if err := awsRestxml_deserializeDocumentEncryptionEntity(&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 awsRestxml_deserializeDocumentEncryptionEntityListUnwrapped(v *[]types.EncryptionEntity, decoder smithyxml.NodeDecoder) error { var sv []types.EncryptionEntity if *v == nil { sv = make([]types.EncryptionEntity, 0) } else { sv = *v } switch { default: var mv types.EncryptionEntity t := decoder.StartEl _ = t nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) destAddr := &mv if err := awsRestxml_deserializeDocumentEncryptionEntity(&destAddr, nodeDecoder); err != nil { return err } mv = *destAddr sv = append(sv, mv) } *v = sv return nil } func awsRestxml_deserializeDocumentEndPoint(v **types.EndPoint, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.EndPoint if *v == nil { sv = &types.EndPoint{} } 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("KinesisStreamConfig", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentKinesisStreamConfig(&sv.KinesisStreamConfig, nodeDecoder); err != nil { return err } case strings.EqualFold("StreamType", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.StreamType = 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 awsRestxml_deserializeDocumentEndPointList(v *[]types.EndPoint, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv []types.EndPoint if *v == nil { sv = make([]types.EndPoint, 0) } else { sv = *v } originalDecoder := decoder for { t, done, err := decoder.Token() if err != nil { return err } if done { break } switch { case strings.EqualFold("member", t.Name.Local): var col types.EndPoint nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) destAddr := &col if err := awsRestxml_deserializeDocumentEndPoint(&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 awsRestxml_deserializeDocumentEndPointListUnwrapped(v *[]types.EndPoint, decoder smithyxml.NodeDecoder) error { var sv []types.EndPoint if *v == nil { sv = make([]types.EndPoint, 0) } else { sv = *v } switch { default: var mv types.EndPoint t := decoder.StartEl _ = t nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) destAddr := &mv if err := awsRestxml_deserializeDocumentEndPoint(&destAddr, nodeDecoder); err != nil { return err } mv = *destAddr sv = append(sv, mv) } *v = sv return nil } func awsRestxml_deserializeDocumentFieldLevelEncryption(v **types.FieldLevelEncryption, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.FieldLevelEncryption if *v == nil { sv = &types.FieldLevelEncryption{} } 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("FieldLevelEncryptionConfig", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentFieldLevelEncryptionConfig(&sv.FieldLevelEncryptionConfig, nodeDecoder); err != nil { return err } case strings.EqualFold("Id", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.Id = ptr.String(xtv) } case strings.EqualFold("LastModifiedTime", 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.LastModifiedTime = 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 awsRestxml_deserializeDocumentFieldLevelEncryptionConfig(v **types.FieldLevelEncryptionConfig, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.FieldLevelEncryptionConfig if *v == nil { sv = &types.FieldLevelEncryptionConfig{} } 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("CallerReference", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.CallerReference = ptr.String(xtv) } case strings.EqualFold("Comment", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.Comment = ptr.String(xtv) } case strings.EqualFold("ContentTypeProfileConfig", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentContentTypeProfileConfig(&sv.ContentTypeProfileConfig, nodeDecoder); err != nil { return err } case strings.EqualFold("QueryArgProfileConfig", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentQueryArgProfileConfig(&sv.QueryArgProfileConfig, nodeDecoder); err != nil { return err } 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 awsRestxml_deserializeDocumentFieldLevelEncryptionConfigAlreadyExists(v **types.FieldLevelEncryptionConfigAlreadyExists, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.FieldLevelEncryptionConfigAlreadyExists if *v == nil { sv = &types.FieldLevelEncryptionConfigAlreadyExists{} } 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 awsRestxml_deserializeDocumentFieldLevelEncryptionConfigInUse(v **types.FieldLevelEncryptionConfigInUse, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.FieldLevelEncryptionConfigInUse if *v == nil { sv = &types.FieldLevelEncryptionConfigInUse{} } 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 awsRestxml_deserializeDocumentFieldLevelEncryptionList(v **types.FieldLevelEncryptionList, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.FieldLevelEncryptionList if *v == nil { sv = &types.FieldLevelEncryptionList{} } 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("Items", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentFieldLevelEncryptionSummaryList(&sv.Items, nodeDecoder); err != nil { return err } case strings.EqualFold("MaxItems", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) i64, err := strconv.ParseInt(xtv, 10, 64) if err != nil { return err } sv.MaxItems = ptr.Int32(int32(i64)) } case strings.EqualFold("NextMarker", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.NextMarker = ptr.String(xtv) } case strings.EqualFold("Quantity", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) i64, err := strconv.ParseInt(xtv, 10, 64) if err != nil { return err } sv.Quantity = ptr.Int32(int32(i64)) } 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 awsRestxml_deserializeDocumentFieldLevelEncryptionProfile(v **types.FieldLevelEncryptionProfile, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.FieldLevelEncryptionProfile if *v == nil { sv = &types.FieldLevelEncryptionProfile{} } 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("FieldLevelEncryptionProfileConfig", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentFieldLevelEncryptionProfileConfig(&sv.FieldLevelEncryptionProfileConfig, nodeDecoder); err != nil { return err } case strings.EqualFold("Id", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.Id = ptr.String(xtv) } case strings.EqualFold("LastModifiedTime", 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.LastModifiedTime = 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 awsRestxml_deserializeDocumentFieldLevelEncryptionProfileAlreadyExists(v **types.FieldLevelEncryptionProfileAlreadyExists, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.FieldLevelEncryptionProfileAlreadyExists if *v == nil { sv = &types.FieldLevelEncryptionProfileAlreadyExists{} } 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 awsRestxml_deserializeDocumentFieldLevelEncryptionProfileConfig(v **types.FieldLevelEncryptionProfileConfig, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.FieldLevelEncryptionProfileConfig if *v == nil { sv = &types.FieldLevelEncryptionProfileConfig{} } 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("CallerReference", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.CallerReference = ptr.String(xtv) } case strings.EqualFold("Comment", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.Comment = ptr.String(xtv) } case strings.EqualFold("EncryptionEntities", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentEncryptionEntities(&sv.EncryptionEntities, nodeDecoder); err != nil { return err } case strings.EqualFold("Name", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.Name = 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 awsRestxml_deserializeDocumentFieldLevelEncryptionProfileInUse(v **types.FieldLevelEncryptionProfileInUse, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.FieldLevelEncryptionProfileInUse if *v == nil { sv = &types.FieldLevelEncryptionProfileInUse{} } 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 awsRestxml_deserializeDocumentFieldLevelEncryptionProfileList(v **types.FieldLevelEncryptionProfileList, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.FieldLevelEncryptionProfileList if *v == nil { sv = &types.FieldLevelEncryptionProfileList{} } 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("Items", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentFieldLevelEncryptionProfileSummaryList(&sv.Items, nodeDecoder); err != nil { return err } case strings.EqualFold("MaxItems", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) i64, err := strconv.ParseInt(xtv, 10, 64) if err != nil { return err } sv.MaxItems = ptr.Int32(int32(i64)) } case strings.EqualFold("NextMarker", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.NextMarker = ptr.String(xtv) } case strings.EqualFold("Quantity", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) i64, err := strconv.ParseInt(xtv, 10, 64) if err != nil { return err } sv.Quantity = ptr.Int32(int32(i64)) } 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 awsRestxml_deserializeDocumentFieldLevelEncryptionProfileSizeExceeded(v **types.FieldLevelEncryptionProfileSizeExceeded, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.FieldLevelEncryptionProfileSizeExceeded if *v == nil { sv = &types.FieldLevelEncryptionProfileSizeExceeded{} } 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 awsRestxml_deserializeDocumentFieldLevelEncryptionProfileSummary(v **types.FieldLevelEncryptionProfileSummary, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.FieldLevelEncryptionProfileSummary if *v == nil { sv = &types.FieldLevelEncryptionProfileSummary{} } 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("Comment", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.Comment = ptr.String(xtv) } case strings.EqualFold("EncryptionEntities", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentEncryptionEntities(&sv.EncryptionEntities, nodeDecoder); err != nil { return err } case strings.EqualFold("Id", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.Id = ptr.String(xtv) } case strings.EqualFold("LastModifiedTime", 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.LastModifiedTime = ptr.Time(t) } case strings.EqualFold("Name", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.Name = 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 awsRestxml_deserializeDocumentFieldLevelEncryptionProfileSummaryList(v *[]types.FieldLevelEncryptionProfileSummary, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv []types.FieldLevelEncryptionProfileSummary if *v == nil { sv = make([]types.FieldLevelEncryptionProfileSummary, 0) } else { sv = *v } originalDecoder := decoder for { t, done, err := decoder.Token() if err != nil { return err } if done { break } switch { case strings.EqualFold("FieldLevelEncryptionProfileSummary", t.Name.Local): var col types.FieldLevelEncryptionProfileSummary nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) destAddr := &col if err := awsRestxml_deserializeDocumentFieldLevelEncryptionProfileSummary(&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 awsRestxml_deserializeDocumentFieldLevelEncryptionProfileSummaryListUnwrapped(v *[]types.FieldLevelEncryptionProfileSummary, decoder smithyxml.NodeDecoder) error { var sv []types.FieldLevelEncryptionProfileSummary if *v == nil { sv = make([]types.FieldLevelEncryptionProfileSummary, 0) } else { sv = *v } switch { default: var mv types.FieldLevelEncryptionProfileSummary t := decoder.StartEl _ = t nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) destAddr := &mv if err := awsRestxml_deserializeDocumentFieldLevelEncryptionProfileSummary(&destAddr, nodeDecoder); err != nil { return err } mv = *destAddr sv = append(sv, mv) } *v = sv return nil } func awsRestxml_deserializeDocumentFieldLevelEncryptionSummary(v **types.FieldLevelEncryptionSummary, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.FieldLevelEncryptionSummary if *v == nil { sv = &types.FieldLevelEncryptionSummary{} } 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("Comment", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.Comment = ptr.String(xtv) } case strings.EqualFold("ContentTypeProfileConfig", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentContentTypeProfileConfig(&sv.ContentTypeProfileConfig, nodeDecoder); err != nil { return err } case strings.EqualFold("Id", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.Id = ptr.String(xtv) } case strings.EqualFold("LastModifiedTime", 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.LastModifiedTime = ptr.Time(t) } case strings.EqualFold("QueryArgProfileConfig", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentQueryArgProfileConfig(&sv.QueryArgProfileConfig, nodeDecoder); err != nil { return err } 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 awsRestxml_deserializeDocumentFieldLevelEncryptionSummaryList(v *[]types.FieldLevelEncryptionSummary, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv []types.FieldLevelEncryptionSummary if *v == nil { sv = make([]types.FieldLevelEncryptionSummary, 0) } else { sv = *v } originalDecoder := decoder for { t, done, err := decoder.Token() if err != nil { return err } if done { break } switch { case strings.EqualFold("FieldLevelEncryptionSummary", t.Name.Local): var col types.FieldLevelEncryptionSummary nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) destAddr := &col if err := awsRestxml_deserializeDocumentFieldLevelEncryptionSummary(&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 awsRestxml_deserializeDocumentFieldLevelEncryptionSummaryListUnwrapped(v *[]types.FieldLevelEncryptionSummary, decoder smithyxml.NodeDecoder) error { var sv []types.FieldLevelEncryptionSummary if *v == nil { sv = make([]types.FieldLevelEncryptionSummary, 0) } else { sv = *v } switch { default: var mv types.FieldLevelEncryptionSummary t := decoder.StartEl _ = t nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) destAddr := &mv if err := awsRestxml_deserializeDocumentFieldLevelEncryptionSummary(&destAddr, nodeDecoder); err != nil { return err } mv = *destAddr sv = append(sv, mv) } *v = sv return nil } func awsRestxml_deserializeDocumentFieldList(v *[]string, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv []string if *v == nil { sv = make([]string, 0) } else { sv = *v } originalDecoder := decoder for { t, done, err := decoder.Token() if err != nil { return err } if done { break } memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) decoder = memberDecoder switch { case strings.EqualFold("Field", t.Name.Local): var col string val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) col = xtv } sv = append(sv, col) default: err = decoder.Decoder.Skip() if err != nil { return err } } decoder = originalDecoder } *v = sv return nil } func awsRestxml_deserializeDocumentFieldListUnwrapped(v *[]string, decoder smithyxml.NodeDecoder) error { var sv []string if *v == nil { sv = make([]string, 0) } else { sv = *v } switch { default: var mv string t := decoder.StartEl _ = t val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) mv = xtv } sv = append(sv, mv) } *v = sv return nil } func awsRestxml_deserializeDocumentFieldPatternList(v *[]string, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv []string if *v == nil { sv = make([]string, 0) } else { sv = *v } originalDecoder := decoder for { t, done, err := decoder.Token() if err != nil { return err } if done { break } memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) decoder = memberDecoder switch { case strings.EqualFold("FieldPattern", t.Name.Local): var col string val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) col = xtv } sv = append(sv, col) default: err = decoder.Decoder.Skip() if err != nil { return err } } decoder = originalDecoder } *v = sv return nil } func awsRestxml_deserializeDocumentFieldPatternListUnwrapped(v *[]string, decoder smithyxml.NodeDecoder) error { var sv []string if *v == nil { sv = make([]string, 0) } else { sv = *v } switch { default: var mv string t := decoder.StartEl _ = t val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) mv = xtv } sv = append(sv, mv) } *v = sv return nil } func awsRestxml_deserializeDocumentFieldPatterns(v **types.FieldPatterns, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.FieldPatterns if *v == nil { sv = &types.FieldPatterns{} } 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("Items", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentFieldPatternList(&sv.Items, nodeDecoder); err != nil { return err } case strings.EqualFold("Quantity", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) i64, err := strconv.ParseInt(xtv, 10, 64) if err != nil { return err } sv.Quantity = ptr.Int32(int32(i64)) } 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 awsRestxml_deserializeDocumentForwardedValues(v **types.ForwardedValues, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.ForwardedValues if *v == nil { sv = &types.ForwardedValues{} } 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("Cookies", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentCookiePreference(&sv.Cookies, nodeDecoder); err != nil { return err } case strings.EqualFold("Headers", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentHeaders(&sv.Headers, nodeDecoder); err != nil { return err } case strings.EqualFold("QueryString", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv, err := strconv.ParseBool(string(val)) if err != nil { return fmt.Errorf("expected boolean to be of type *bool, got %T instead", val) } sv.QueryString = ptr.Bool(xtv) } case strings.EqualFold("QueryStringCacheKeys", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentQueryStringCacheKeys(&sv.QueryStringCacheKeys, nodeDecoder); err != nil { return err } 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 awsRestxml_deserializeDocumentFunctionAlreadyExists(v **types.FunctionAlreadyExists, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.FunctionAlreadyExists if *v == nil { sv = &types.FunctionAlreadyExists{} } 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 awsRestxml_deserializeDocumentFunctionAssociation(v **types.FunctionAssociation, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.FunctionAssociation if *v == nil { sv = &types.FunctionAssociation{} } 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("EventType", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.EventType = types.EventType(xtv) } case strings.EqualFold("FunctionARN", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.FunctionARN = 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 awsRestxml_deserializeDocumentFunctionAssociationList(v *[]types.FunctionAssociation, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv []types.FunctionAssociation if *v == nil { sv = make([]types.FunctionAssociation, 0) } else { sv = *v } originalDecoder := decoder for { t, done, err := decoder.Token() if err != nil { return err } if done { break } switch { case strings.EqualFold("FunctionAssociation", t.Name.Local): var col types.FunctionAssociation nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) destAddr := &col if err := awsRestxml_deserializeDocumentFunctionAssociation(&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 awsRestxml_deserializeDocumentFunctionAssociationListUnwrapped(v *[]types.FunctionAssociation, decoder smithyxml.NodeDecoder) error { var sv []types.FunctionAssociation if *v == nil { sv = make([]types.FunctionAssociation, 0) } else { sv = *v } switch { default: var mv types.FunctionAssociation t := decoder.StartEl _ = t nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) destAddr := &mv if err := awsRestxml_deserializeDocumentFunctionAssociation(&destAddr, nodeDecoder); err != nil { return err } mv = *destAddr sv = append(sv, mv) } *v = sv return nil } func awsRestxml_deserializeDocumentFunctionAssociations(v **types.FunctionAssociations, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.FunctionAssociations if *v == nil { sv = &types.FunctionAssociations{} } 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("Items", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentFunctionAssociationList(&sv.Items, nodeDecoder); err != nil { return err } case strings.EqualFold("Quantity", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) i64, err := strconv.ParseInt(xtv, 10, 64) if err != nil { return err } sv.Quantity = ptr.Int32(int32(i64)) } 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 awsRestxml_deserializeDocumentFunctionConfig(v **types.FunctionConfig, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.FunctionConfig if *v == nil { sv = &types.FunctionConfig{} } 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("Comment", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.Comment = ptr.String(xtv) } case strings.EqualFold("Runtime", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.Runtime = types.FunctionRuntime(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 awsRestxml_deserializeDocumentFunctionExecutionLogList(v *[]string, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv []string if *v == nil { sv = make([]string, 0) } else { sv = *v } originalDecoder := decoder for { t, done, err := decoder.Token() if err != nil { return err } if done { break } memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) decoder = memberDecoder switch { case strings.EqualFold("member", t.Name.Local): var col string val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) col = xtv } sv = append(sv, col) default: err = decoder.Decoder.Skip() if err != nil { return err } } decoder = originalDecoder } *v = sv return nil } func awsRestxml_deserializeDocumentFunctionExecutionLogListUnwrapped(v *[]string, decoder smithyxml.NodeDecoder) error { var sv []string if *v == nil { sv = make([]string, 0) } else { sv = *v } switch { default: var mv string t := decoder.StartEl _ = t val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) mv = xtv } sv = append(sv, mv) } *v = sv return nil } func awsRestxml_deserializeDocumentFunctionInUse(v **types.FunctionInUse, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.FunctionInUse if *v == nil { sv = &types.FunctionInUse{} } 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 awsRestxml_deserializeDocumentFunctionList(v **types.FunctionList, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.FunctionList if *v == nil { sv = &types.FunctionList{} } 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("Items", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentFunctionSummaryList(&sv.Items, nodeDecoder); err != nil { return err } case strings.EqualFold("MaxItems", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) i64, err := strconv.ParseInt(xtv, 10, 64) if err != nil { return err } sv.MaxItems = ptr.Int32(int32(i64)) } case strings.EqualFold("NextMarker", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.NextMarker = ptr.String(xtv) } case strings.EqualFold("Quantity", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) i64, err := strconv.ParseInt(xtv, 10, 64) if err != nil { return err } sv.Quantity = ptr.Int32(int32(i64)) } 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 awsRestxml_deserializeDocumentFunctionMetadata(v **types.FunctionMetadata, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.FunctionMetadata if *v == nil { sv = &types.FunctionMetadata{} } 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("CreatedTime", 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.CreatedTime = ptr.Time(t) } case strings.EqualFold("FunctionARN", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.FunctionARN = ptr.String(xtv) } case strings.EqualFold("LastModifiedTime", 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.LastModifiedTime = ptr.Time(t) } case strings.EqualFold("Stage", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.Stage = types.FunctionStage(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 awsRestxml_deserializeDocumentFunctionSizeLimitExceeded(v **types.FunctionSizeLimitExceeded, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.FunctionSizeLimitExceeded if *v == nil { sv = &types.FunctionSizeLimitExceeded{} } 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 awsRestxml_deserializeDocumentFunctionSummary(v **types.FunctionSummary, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.FunctionSummary if *v == nil { sv = &types.FunctionSummary{} } 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("FunctionConfig", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentFunctionConfig(&sv.FunctionConfig, nodeDecoder); err != nil { return err } case strings.EqualFold("FunctionMetadata", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentFunctionMetadata(&sv.FunctionMetadata, nodeDecoder); err != nil { return err } case strings.EqualFold("Name", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.Name = ptr.String(xtv) } case strings.EqualFold("Status", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.Status = 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 awsRestxml_deserializeDocumentFunctionSummaryList(v *[]types.FunctionSummary, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv []types.FunctionSummary if *v == nil { sv = make([]types.FunctionSummary, 0) } else { sv = *v } originalDecoder := decoder for { t, done, err := decoder.Token() if err != nil { return err } if done { break } switch { case strings.EqualFold("FunctionSummary", t.Name.Local): var col types.FunctionSummary nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) destAddr := &col if err := awsRestxml_deserializeDocumentFunctionSummary(&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 awsRestxml_deserializeDocumentFunctionSummaryListUnwrapped(v *[]types.FunctionSummary, decoder smithyxml.NodeDecoder) error { var sv []types.FunctionSummary if *v == nil { sv = make([]types.FunctionSummary, 0) } else { sv = *v } switch { default: var mv types.FunctionSummary t := decoder.StartEl _ = t nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) destAddr := &mv if err := awsRestxml_deserializeDocumentFunctionSummary(&destAddr, nodeDecoder); err != nil { return err } mv = *destAddr sv = append(sv, mv) } *v = sv return nil } func awsRestxml_deserializeDocumentGeoRestriction(v **types.GeoRestriction, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.GeoRestriction if *v == nil { sv = &types.GeoRestriction{} } 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("Items", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentLocationList(&sv.Items, nodeDecoder); err != nil { return err } case strings.EqualFold("Quantity", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) i64, err := strconv.ParseInt(xtv, 10, 64) if err != nil { return err } sv.Quantity = ptr.Int32(int32(i64)) } case strings.EqualFold("RestrictionType", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.RestrictionType = types.GeoRestrictionType(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 awsRestxml_deserializeDocumentHeaderList(v *[]string, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv []string if *v == nil { sv = make([]string, 0) } else { sv = *v } originalDecoder := decoder for { t, done, err := decoder.Token() if err != nil { return err } if done { break } memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) decoder = memberDecoder switch { case strings.EqualFold("Name", t.Name.Local): var col string val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) col = xtv } sv = append(sv, col) default: err = decoder.Decoder.Skip() if err != nil { return err } } decoder = originalDecoder } *v = sv return nil } func awsRestxml_deserializeDocumentHeaderListUnwrapped(v *[]string, decoder smithyxml.NodeDecoder) error { var sv []string if *v == nil { sv = make([]string, 0) } else { sv = *v } switch { default: var mv string t := decoder.StartEl _ = t val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) mv = xtv } sv = append(sv, mv) } *v = sv return nil } func awsRestxml_deserializeDocumentHeaders(v **types.Headers, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.Headers if *v == nil { sv = &types.Headers{} } 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("Items", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentHeaderList(&sv.Items, nodeDecoder); err != nil { return err } case strings.EqualFold("Quantity", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) i64, err := strconv.ParseInt(xtv, 10, 64) if err != nil { return err } sv.Quantity = ptr.Int32(int32(i64)) } 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 awsRestxml_deserializeDocumentIllegalDelete(v **types.IllegalDelete, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.IllegalDelete if *v == nil { sv = &types.IllegalDelete{} } 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 awsRestxml_deserializeDocumentIllegalFieldLevelEncryptionConfigAssociationWithCacheBehavior(v **types.IllegalFieldLevelEncryptionConfigAssociationWithCacheBehavior, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.IllegalFieldLevelEncryptionConfigAssociationWithCacheBehavior if *v == nil { sv = &types.IllegalFieldLevelEncryptionConfigAssociationWithCacheBehavior{} } 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 awsRestxml_deserializeDocumentIllegalOriginAccessConfiguration(v **types.IllegalOriginAccessConfiguration, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.IllegalOriginAccessConfiguration if *v == nil { sv = &types.IllegalOriginAccessConfiguration{} } 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 awsRestxml_deserializeDocumentIllegalUpdate(v **types.IllegalUpdate, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.IllegalUpdate if *v == nil { sv = &types.IllegalUpdate{} } 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 awsRestxml_deserializeDocumentInconsistentQuantities(v **types.InconsistentQuantities, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.InconsistentQuantities if *v == nil { sv = &types.InconsistentQuantities{} } 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 awsRestxml_deserializeDocumentInvalidArgument(v **types.InvalidArgument, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.InvalidArgument if *v == nil { sv = &types.InvalidArgument{} } 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 awsRestxml_deserializeDocumentInvalidation(v **types.Invalidation, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.Invalidation if *v == nil { sv = &types.Invalidation{} } 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("CreateTime", 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.CreateTime = ptr.Time(t) } case strings.EqualFold("Id", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.Id = ptr.String(xtv) } case strings.EqualFold("InvalidationBatch", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentInvalidationBatch(&sv.InvalidationBatch, nodeDecoder); err != nil { return err } case strings.EqualFold("Status", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.Status = 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 awsRestxml_deserializeDocumentInvalidationBatch(v **types.InvalidationBatch, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.InvalidationBatch if *v == nil { sv = &types.InvalidationBatch{} } 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("CallerReference", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.CallerReference = ptr.String(xtv) } case strings.EqualFold("Paths", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentPaths(&sv.Paths, nodeDecoder); err != nil { return err } 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 awsRestxml_deserializeDocumentInvalidationList(v **types.InvalidationList, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.InvalidationList if *v == nil { sv = &types.InvalidationList{} } 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("IsTruncated", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv, err := strconv.ParseBool(string(val)) if err != nil { return fmt.Errorf("expected boolean to be of type *bool, got %T instead", val) } sv.IsTruncated = ptr.Bool(xtv) } case strings.EqualFold("Items", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentInvalidationSummaryList(&sv.Items, 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) } case strings.EqualFold("MaxItems", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) i64, err := strconv.ParseInt(xtv, 10, 64) if err != nil { return err } sv.MaxItems = ptr.Int32(int32(i64)) } case strings.EqualFold("NextMarker", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.NextMarker = ptr.String(xtv) } case strings.EqualFold("Quantity", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) i64, err := strconv.ParseInt(xtv, 10, 64) if err != nil { return err } sv.Quantity = ptr.Int32(int32(i64)) } 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 awsRestxml_deserializeDocumentInvalidationSummary(v **types.InvalidationSummary, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.InvalidationSummary if *v == nil { sv = &types.InvalidationSummary{} } 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("CreateTime", 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.CreateTime = ptr.Time(t) } case strings.EqualFold("Id", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.Id = ptr.String(xtv) } case strings.EqualFold("Status", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.Status = 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 awsRestxml_deserializeDocumentInvalidationSummaryList(v *[]types.InvalidationSummary, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv []types.InvalidationSummary if *v == nil { sv = make([]types.InvalidationSummary, 0) } else { sv = *v } originalDecoder := decoder for { t, done, err := decoder.Token() if err != nil { return err } if done { break } switch { case strings.EqualFold("InvalidationSummary", t.Name.Local): var col types.InvalidationSummary nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) destAddr := &col if err := awsRestxml_deserializeDocumentInvalidationSummary(&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 awsRestxml_deserializeDocumentInvalidationSummaryListUnwrapped(v *[]types.InvalidationSummary, decoder smithyxml.NodeDecoder) error { var sv []types.InvalidationSummary if *v == nil { sv = make([]types.InvalidationSummary, 0) } else { sv = *v } switch { default: var mv types.InvalidationSummary t := decoder.StartEl _ = t nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) destAddr := &mv if err := awsRestxml_deserializeDocumentInvalidationSummary(&destAddr, nodeDecoder); err != nil { return err } mv = *destAddr sv = append(sv, mv) } *v = sv return nil } func awsRestxml_deserializeDocumentInvalidDefaultRootObject(v **types.InvalidDefaultRootObject, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.InvalidDefaultRootObject if *v == nil { sv = &types.InvalidDefaultRootObject{} } 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 awsRestxml_deserializeDocumentInvalidDomainNameForOriginAccessControl(v **types.InvalidDomainNameForOriginAccessControl, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.InvalidDomainNameForOriginAccessControl if *v == nil { sv = &types.InvalidDomainNameForOriginAccessControl{} } 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 awsRestxml_deserializeDocumentInvalidErrorCode(v **types.InvalidErrorCode, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.InvalidErrorCode if *v == nil { sv = &types.InvalidErrorCode{} } 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 awsRestxml_deserializeDocumentInvalidForwardCookies(v **types.InvalidForwardCookies, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.InvalidForwardCookies if *v == nil { sv = &types.InvalidForwardCookies{} } 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 awsRestxml_deserializeDocumentInvalidFunctionAssociation(v **types.InvalidFunctionAssociation, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.InvalidFunctionAssociation if *v == nil { sv = &types.InvalidFunctionAssociation{} } 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 awsRestxml_deserializeDocumentInvalidGeoRestrictionParameter(v **types.InvalidGeoRestrictionParameter, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.InvalidGeoRestrictionParameter if *v == nil { sv = &types.InvalidGeoRestrictionParameter{} } 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 awsRestxml_deserializeDocumentInvalidHeadersForS3Origin(v **types.InvalidHeadersForS3Origin, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.InvalidHeadersForS3Origin if *v == nil { sv = &types.InvalidHeadersForS3Origin{} } 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 awsRestxml_deserializeDocumentInvalidIfMatchVersion(v **types.InvalidIfMatchVersion, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.InvalidIfMatchVersion if *v == nil { sv = &types.InvalidIfMatchVersion{} } 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 awsRestxml_deserializeDocumentInvalidLambdaFunctionAssociation(v **types.InvalidLambdaFunctionAssociation, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.InvalidLambdaFunctionAssociation if *v == nil { sv = &types.InvalidLambdaFunctionAssociation{} } 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 awsRestxml_deserializeDocumentInvalidLocationCode(v **types.InvalidLocationCode, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.InvalidLocationCode if *v == nil { sv = &types.InvalidLocationCode{} } 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 awsRestxml_deserializeDocumentInvalidMinimumProtocolVersion(v **types.InvalidMinimumProtocolVersion, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.InvalidMinimumProtocolVersion if *v == nil { sv = &types.InvalidMinimumProtocolVersion{} } 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 awsRestxml_deserializeDocumentInvalidOrigin(v **types.InvalidOrigin, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.InvalidOrigin if *v == nil { sv = &types.InvalidOrigin{} } 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 awsRestxml_deserializeDocumentInvalidOriginAccessControl(v **types.InvalidOriginAccessControl, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.InvalidOriginAccessControl if *v == nil { sv = &types.InvalidOriginAccessControl{} } 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 awsRestxml_deserializeDocumentInvalidOriginAccessIdentity(v **types.InvalidOriginAccessIdentity, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.InvalidOriginAccessIdentity if *v == nil { sv = &types.InvalidOriginAccessIdentity{} } 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 awsRestxml_deserializeDocumentInvalidOriginKeepaliveTimeout(v **types.InvalidOriginKeepaliveTimeout, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.InvalidOriginKeepaliveTimeout if *v == nil { sv = &types.InvalidOriginKeepaliveTimeout{} } 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 awsRestxml_deserializeDocumentInvalidOriginReadTimeout(v **types.InvalidOriginReadTimeout, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.InvalidOriginReadTimeout if *v == nil { sv = &types.InvalidOriginReadTimeout{} } 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 awsRestxml_deserializeDocumentInvalidProtocolSettings(v **types.InvalidProtocolSettings, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.InvalidProtocolSettings if *v == nil { sv = &types.InvalidProtocolSettings{} } 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 awsRestxml_deserializeDocumentInvalidQueryStringParameters(v **types.InvalidQueryStringParameters, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.InvalidQueryStringParameters if *v == nil { sv = &types.InvalidQueryStringParameters{} } 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 awsRestxml_deserializeDocumentInvalidRelativePath(v **types.InvalidRelativePath, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.InvalidRelativePath if *v == nil { sv = &types.InvalidRelativePath{} } 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 awsRestxml_deserializeDocumentInvalidRequiredProtocol(v **types.InvalidRequiredProtocol, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.InvalidRequiredProtocol if *v == nil { sv = &types.InvalidRequiredProtocol{} } 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 awsRestxml_deserializeDocumentInvalidResponseCode(v **types.InvalidResponseCode, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.InvalidResponseCode if *v == nil { sv = &types.InvalidResponseCode{} } 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 awsRestxml_deserializeDocumentInvalidTagging(v **types.InvalidTagging, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.InvalidTagging if *v == nil { sv = &types.InvalidTagging{} } 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 awsRestxml_deserializeDocumentInvalidTTLOrder(v **types.InvalidTTLOrder, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.InvalidTTLOrder if *v == nil { sv = &types.InvalidTTLOrder{} } 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 awsRestxml_deserializeDocumentInvalidViewerCertificate(v **types.InvalidViewerCertificate, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.InvalidViewerCertificate if *v == nil { sv = &types.InvalidViewerCertificate{} } 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 awsRestxml_deserializeDocumentInvalidWebACLId(v **types.InvalidWebACLId, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.InvalidWebACLId if *v == nil { sv = &types.InvalidWebACLId{} } 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 awsRestxml_deserializeDocumentKeyGroup(v **types.KeyGroup, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.KeyGroup if *v == nil { sv = &types.KeyGroup{} } 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("Id", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.Id = ptr.String(xtv) } case strings.EqualFold("KeyGroupConfig", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentKeyGroupConfig(&sv.KeyGroupConfig, nodeDecoder); err != nil { return err } case strings.EqualFold("LastModifiedTime", 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.LastModifiedTime = 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 awsRestxml_deserializeDocumentKeyGroupAlreadyExists(v **types.KeyGroupAlreadyExists, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.KeyGroupAlreadyExists if *v == nil { sv = &types.KeyGroupAlreadyExists{} } 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 awsRestxml_deserializeDocumentKeyGroupConfig(v **types.KeyGroupConfig, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.KeyGroupConfig if *v == nil { sv = &types.KeyGroupConfig{} } 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("Comment", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.Comment = ptr.String(xtv) } case strings.EqualFold("Items", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentPublicKeyIdList(&sv.Items, nodeDecoder); err != nil { return err } case strings.EqualFold("Name", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.Name = 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 awsRestxml_deserializeDocumentKeyGroupList(v **types.KeyGroupList, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.KeyGroupList if *v == nil { sv = &types.KeyGroupList{} } 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("Items", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentKeyGroupSummaryList(&sv.Items, nodeDecoder); err != nil { return err } case strings.EqualFold("MaxItems", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) i64, err := strconv.ParseInt(xtv, 10, 64) if err != nil { return err } sv.MaxItems = ptr.Int32(int32(i64)) } case strings.EqualFold("NextMarker", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.NextMarker = ptr.String(xtv) } case strings.EqualFold("Quantity", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) i64, err := strconv.ParseInt(xtv, 10, 64) if err != nil { return err } sv.Quantity = ptr.Int32(int32(i64)) } 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 awsRestxml_deserializeDocumentKeyGroupSummary(v **types.KeyGroupSummary, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.KeyGroupSummary if *v == nil { sv = &types.KeyGroupSummary{} } 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("KeyGroup", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentKeyGroup(&sv.KeyGroup, nodeDecoder); err != nil { return err } 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 awsRestxml_deserializeDocumentKeyGroupSummaryList(v *[]types.KeyGroupSummary, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv []types.KeyGroupSummary if *v == nil { sv = make([]types.KeyGroupSummary, 0) } else { sv = *v } originalDecoder := decoder for { t, done, err := decoder.Token() if err != nil { return err } if done { break } switch { case strings.EqualFold("KeyGroupSummary", t.Name.Local): var col types.KeyGroupSummary nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) destAddr := &col if err := awsRestxml_deserializeDocumentKeyGroupSummary(&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 awsRestxml_deserializeDocumentKeyGroupSummaryListUnwrapped(v *[]types.KeyGroupSummary, decoder smithyxml.NodeDecoder) error { var sv []types.KeyGroupSummary if *v == nil { sv = make([]types.KeyGroupSummary, 0) } else { sv = *v } switch { default: var mv types.KeyGroupSummary t := decoder.StartEl _ = t nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) destAddr := &mv if err := awsRestxml_deserializeDocumentKeyGroupSummary(&destAddr, nodeDecoder); err != nil { return err } mv = *destAddr sv = append(sv, mv) } *v = sv return nil } func awsRestxml_deserializeDocumentKeyPairIdList(v *[]string, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv []string if *v == nil { sv = make([]string, 0) } else { sv = *v } originalDecoder := decoder for { t, done, err := decoder.Token() if err != nil { return err } if done { break } memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) decoder = memberDecoder switch { case strings.EqualFold("KeyPairId", t.Name.Local): var col string val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) col = xtv } sv = append(sv, col) default: err = decoder.Decoder.Skip() if err != nil { return err } } decoder = originalDecoder } *v = sv return nil } func awsRestxml_deserializeDocumentKeyPairIdListUnwrapped(v *[]string, decoder smithyxml.NodeDecoder) error { var sv []string if *v == nil { sv = make([]string, 0) } else { sv = *v } switch { default: var mv string t := decoder.StartEl _ = t val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) mv = xtv } sv = append(sv, mv) } *v = sv return nil } func awsRestxml_deserializeDocumentKeyPairIds(v **types.KeyPairIds, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.KeyPairIds if *v == nil { sv = &types.KeyPairIds{} } 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("Items", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentKeyPairIdList(&sv.Items, nodeDecoder); err != nil { return err } case strings.EqualFold("Quantity", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) i64, err := strconv.ParseInt(xtv, 10, 64) if err != nil { return err } sv.Quantity = ptr.Int32(int32(i64)) } 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 awsRestxml_deserializeDocumentKGKeyPairIds(v **types.KGKeyPairIds, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.KGKeyPairIds if *v == nil { sv = &types.KGKeyPairIds{} } 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("KeyGroupId", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.KeyGroupId = ptr.String(xtv) } case strings.EqualFold("KeyPairIds", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentKeyPairIds(&sv.KeyPairIds, nodeDecoder); err != nil { return err } 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 awsRestxml_deserializeDocumentKGKeyPairIdsList(v *[]types.KGKeyPairIds, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv []types.KGKeyPairIds if *v == nil { sv = make([]types.KGKeyPairIds, 0) } else { sv = *v } originalDecoder := decoder for { t, done, err := decoder.Token() if err != nil { return err } if done { break } switch { case strings.EqualFold("KeyGroup", t.Name.Local): var col types.KGKeyPairIds nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) destAddr := &col if err := awsRestxml_deserializeDocumentKGKeyPairIds(&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 awsRestxml_deserializeDocumentKGKeyPairIdsListUnwrapped(v *[]types.KGKeyPairIds, decoder smithyxml.NodeDecoder) error { var sv []types.KGKeyPairIds if *v == nil { sv = make([]types.KGKeyPairIds, 0) } else { sv = *v } switch { default: var mv types.KGKeyPairIds t := decoder.StartEl _ = t nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) destAddr := &mv if err := awsRestxml_deserializeDocumentKGKeyPairIds(&destAddr, nodeDecoder); err != nil { return err } mv = *destAddr sv = append(sv, mv) } *v = sv return nil } func awsRestxml_deserializeDocumentKinesisStreamConfig(v **types.KinesisStreamConfig, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.KinesisStreamConfig if *v == nil { sv = &types.KinesisStreamConfig{} } 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("RoleARN", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.RoleARN = ptr.String(xtv) } case strings.EqualFold("StreamARN", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.StreamARN = 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 awsRestxml_deserializeDocumentLambdaFunctionAssociation(v **types.LambdaFunctionAssociation, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.LambdaFunctionAssociation if *v == nil { sv = &types.LambdaFunctionAssociation{} } 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("EventType", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.EventType = types.EventType(xtv) } case strings.EqualFold("IncludeBody", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv, err := strconv.ParseBool(string(val)) if err != nil { return fmt.Errorf("expected boolean to be of type *bool, got %T instead", val) } sv.IncludeBody = ptr.Bool(xtv) } case strings.EqualFold("LambdaFunctionARN", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.LambdaFunctionARN = 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 awsRestxml_deserializeDocumentLambdaFunctionAssociationList(v *[]types.LambdaFunctionAssociation, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv []types.LambdaFunctionAssociation if *v == nil { sv = make([]types.LambdaFunctionAssociation, 0) } else { sv = *v } originalDecoder := decoder for { t, done, err := decoder.Token() if err != nil { return err } if done { break } switch { case strings.EqualFold("LambdaFunctionAssociation", t.Name.Local): var col types.LambdaFunctionAssociation nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) destAddr := &col if err := awsRestxml_deserializeDocumentLambdaFunctionAssociation(&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 awsRestxml_deserializeDocumentLambdaFunctionAssociationListUnwrapped(v *[]types.LambdaFunctionAssociation, decoder smithyxml.NodeDecoder) error { var sv []types.LambdaFunctionAssociation if *v == nil { sv = make([]types.LambdaFunctionAssociation, 0) } else { sv = *v } switch { default: var mv types.LambdaFunctionAssociation t := decoder.StartEl _ = t nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) destAddr := &mv if err := awsRestxml_deserializeDocumentLambdaFunctionAssociation(&destAddr, nodeDecoder); err != nil { return err } mv = *destAddr sv = append(sv, mv) } *v = sv return nil } func awsRestxml_deserializeDocumentLambdaFunctionAssociations(v **types.LambdaFunctionAssociations, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.LambdaFunctionAssociations if *v == nil { sv = &types.LambdaFunctionAssociations{} } 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("Items", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentLambdaFunctionAssociationList(&sv.Items, nodeDecoder); err != nil { return err } case strings.EqualFold("Quantity", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) i64, err := strconv.ParseInt(xtv, 10, 64) if err != nil { return err } sv.Quantity = ptr.Int32(int32(i64)) } 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 awsRestxml_deserializeDocumentLocationList(v *[]string, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv []string if *v == nil { sv = make([]string, 0) } else { sv = *v } originalDecoder := decoder for { t, done, err := decoder.Token() if err != nil { return err } if done { break } memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) decoder = memberDecoder switch { case strings.EqualFold("Location", t.Name.Local): var col string val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) col = xtv } sv = append(sv, col) default: err = decoder.Decoder.Skip() if err != nil { return err } } decoder = originalDecoder } *v = sv return nil } func awsRestxml_deserializeDocumentLocationListUnwrapped(v *[]string, decoder smithyxml.NodeDecoder) error { var sv []string if *v == nil { sv = make([]string, 0) } else { sv = *v } switch { default: var mv string t := decoder.StartEl _ = t val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) mv = xtv } sv = append(sv, mv) } *v = sv return nil } func awsRestxml_deserializeDocumentLoggingConfig(v **types.LoggingConfig, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.LoggingConfig if *v == nil { sv = &types.LoggingConfig{} } 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("Bucket", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.Bucket = ptr.String(xtv) } case strings.EqualFold("Enabled", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv, err := strconv.ParseBool(string(val)) if err != nil { return fmt.Errorf("expected boolean to be of type *bool, got %T instead", val) } sv.Enabled = ptr.Bool(xtv) } case strings.EqualFold("IncludeCookies", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv, err := strconv.ParseBool(string(val)) if err != nil { return fmt.Errorf("expected boolean to be of type *bool, got %T instead", val) } sv.IncludeCookies = ptr.Bool(xtv) } case strings.EqualFold("Prefix", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.Prefix = 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 awsRestxml_deserializeDocumentMethodsList(v *[]types.Method, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv []types.Method if *v == nil { sv = make([]types.Method, 0) } else { sv = *v } originalDecoder := decoder for { t, done, err := decoder.Token() if err != nil { return err } if done { break } memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) decoder = memberDecoder switch { case strings.EqualFold("Method", t.Name.Local): var col types.Method val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) col = types.Method(xtv) } sv = append(sv, col) default: err = decoder.Decoder.Skip() if err != nil { return err } } decoder = originalDecoder } *v = sv return nil } func awsRestxml_deserializeDocumentMethodsListUnwrapped(v *[]types.Method, decoder smithyxml.NodeDecoder) error { var sv []types.Method if *v == nil { sv = make([]types.Method, 0) } else { sv = *v } switch { default: var mv types.Method t := decoder.StartEl _ = t val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) mv = types.Method(xtv) } sv = append(sv, mv) } *v = sv return nil } func awsRestxml_deserializeDocumentMissingBody(v **types.MissingBody, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.MissingBody if *v == nil { sv = &types.MissingBody{} } 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 awsRestxml_deserializeDocumentMonitoringSubscription(v **types.MonitoringSubscription, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.MonitoringSubscription if *v == nil { sv = &types.MonitoringSubscription{} } 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("RealtimeMetricsSubscriptionConfig", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentRealtimeMetricsSubscriptionConfig(&sv.RealtimeMetricsSubscriptionConfig, nodeDecoder); err != nil { return err } 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 awsRestxml_deserializeDocumentMonitoringSubscriptionAlreadyExists(v **types.MonitoringSubscriptionAlreadyExists, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.MonitoringSubscriptionAlreadyExists if *v == nil { sv = &types.MonitoringSubscriptionAlreadyExists{} } 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 awsRestxml_deserializeDocumentNoSuchCachePolicy(v **types.NoSuchCachePolicy, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.NoSuchCachePolicy if *v == nil { sv = &types.NoSuchCachePolicy{} } 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 awsRestxml_deserializeDocumentNoSuchCloudFrontOriginAccessIdentity(v **types.NoSuchCloudFrontOriginAccessIdentity, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.NoSuchCloudFrontOriginAccessIdentity if *v == nil { sv = &types.NoSuchCloudFrontOriginAccessIdentity{} } 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 awsRestxml_deserializeDocumentNoSuchContinuousDeploymentPolicy(v **types.NoSuchContinuousDeploymentPolicy, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.NoSuchContinuousDeploymentPolicy if *v == nil { sv = &types.NoSuchContinuousDeploymentPolicy{} } 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 awsRestxml_deserializeDocumentNoSuchDistribution(v **types.NoSuchDistribution, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.NoSuchDistribution if *v == nil { sv = &types.NoSuchDistribution{} } 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 awsRestxml_deserializeDocumentNoSuchFieldLevelEncryptionConfig(v **types.NoSuchFieldLevelEncryptionConfig, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.NoSuchFieldLevelEncryptionConfig if *v == nil { sv = &types.NoSuchFieldLevelEncryptionConfig{} } 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 awsRestxml_deserializeDocumentNoSuchFieldLevelEncryptionProfile(v **types.NoSuchFieldLevelEncryptionProfile, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.NoSuchFieldLevelEncryptionProfile if *v == nil { sv = &types.NoSuchFieldLevelEncryptionProfile{} } 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 awsRestxml_deserializeDocumentNoSuchFunctionExists(v **types.NoSuchFunctionExists, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.NoSuchFunctionExists if *v == nil { sv = &types.NoSuchFunctionExists{} } 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 awsRestxml_deserializeDocumentNoSuchInvalidation(v **types.NoSuchInvalidation, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.NoSuchInvalidation if *v == nil { sv = &types.NoSuchInvalidation{} } 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 awsRestxml_deserializeDocumentNoSuchMonitoringSubscription(v **types.NoSuchMonitoringSubscription, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.NoSuchMonitoringSubscription if *v == nil { sv = &types.NoSuchMonitoringSubscription{} } 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 awsRestxml_deserializeDocumentNoSuchOrigin(v **types.NoSuchOrigin, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.NoSuchOrigin if *v == nil { sv = &types.NoSuchOrigin{} } 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 awsRestxml_deserializeDocumentNoSuchOriginAccessControl(v **types.NoSuchOriginAccessControl, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.NoSuchOriginAccessControl if *v == nil { sv = &types.NoSuchOriginAccessControl{} } 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 awsRestxml_deserializeDocumentNoSuchOriginRequestPolicy(v **types.NoSuchOriginRequestPolicy, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.NoSuchOriginRequestPolicy if *v == nil { sv = &types.NoSuchOriginRequestPolicy{} } 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 awsRestxml_deserializeDocumentNoSuchPublicKey(v **types.NoSuchPublicKey, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.NoSuchPublicKey if *v == nil { sv = &types.NoSuchPublicKey{} } 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 awsRestxml_deserializeDocumentNoSuchRealtimeLogConfig(v **types.NoSuchRealtimeLogConfig, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.NoSuchRealtimeLogConfig if *v == nil { sv = &types.NoSuchRealtimeLogConfig{} } 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 awsRestxml_deserializeDocumentNoSuchResource(v **types.NoSuchResource, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.NoSuchResource if *v == nil { sv = &types.NoSuchResource{} } 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 awsRestxml_deserializeDocumentNoSuchResponseHeadersPolicy(v **types.NoSuchResponseHeadersPolicy, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.NoSuchResponseHeadersPolicy if *v == nil { sv = &types.NoSuchResponseHeadersPolicy{} } 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 awsRestxml_deserializeDocumentNoSuchStreamingDistribution(v **types.NoSuchStreamingDistribution, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.NoSuchStreamingDistribution if *v == nil { sv = &types.NoSuchStreamingDistribution{} } 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 awsRestxml_deserializeDocumentOrigin(v **types.Origin, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.Origin if *v == nil { sv = &types.Origin{} } 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("ConnectionAttempts", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) i64, err := strconv.ParseInt(xtv, 10, 64) if err != nil { return err } sv.ConnectionAttempts = ptr.Int32(int32(i64)) } case strings.EqualFold("ConnectionTimeout", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) i64, err := strconv.ParseInt(xtv, 10, 64) if err != nil { return err } sv.ConnectionTimeout = ptr.Int32(int32(i64)) } case strings.EqualFold("CustomHeaders", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentCustomHeaders(&sv.CustomHeaders, nodeDecoder); err != nil { return err } case strings.EqualFold("CustomOriginConfig", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentCustomOriginConfig(&sv.CustomOriginConfig, nodeDecoder); err != nil { return err } case strings.EqualFold("DomainName", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.DomainName = ptr.String(xtv) } case strings.EqualFold("Id", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.Id = ptr.String(xtv) } case strings.EqualFold("OriginAccessControlId", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.OriginAccessControlId = ptr.String(xtv) } case strings.EqualFold("OriginPath", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.OriginPath = ptr.String(xtv) } case strings.EqualFold("OriginShield", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentOriginShield(&sv.OriginShield, nodeDecoder); err != nil { return err } case strings.EqualFold("S3OriginConfig", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentS3OriginConfig(&sv.S3OriginConfig, nodeDecoder); err != nil { return err } 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 awsRestxml_deserializeDocumentOriginAccessControl(v **types.OriginAccessControl, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.OriginAccessControl if *v == nil { sv = &types.OriginAccessControl{} } 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("Id", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.Id = ptr.String(xtv) } case strings.EqualFold("OriginAccessControlConfig", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentOriginAccessControlConfig(&sv.OriginAccessControlConfig, nodeDecoder); err != nil { return err } 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 awsRestxml_deserializeDocumentOriginAccessControlAlreadyExists(v **types.OriginAccessControlAlreadyExists, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.OriginAccessControlAlreadyExists if *v == nil { sv = &types.OriginAccessControlAlreadyExists{} } 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 awsRestxml_deserializeDocumentOriginAccessControlConfig(v **types.OriginAccessControlConfig, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.OriginAccessControlConfig if *v == nil { sv = &types.OriginAccessControlConfig{} } 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("Description", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.Description = ptr.String(xtv) } case strings.EqualFold("Name", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.Name = ptr.String(xtv) } case strings.EqualFold("OriginAccessControlOriginType", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.OriginAccessControlOriginType = types.OriginAccessControlOriginTypes(xtv) } case strings.EqualFold("SigningBehavior", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.SigningBehavior = types.OriginAccessControlSigningBehaviors(xtv) } case strings.EqualFold("SigningProtocol", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.SigningProtocol = types.OriginAccessControlSigningProtocols(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 awsRestxml_deserializeDocumentOriginAccessControlInUse(v **types.OriginAccessControlInUse, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.OriginAccessControlInUse if *v == nil { sv = &types.OriginAccessControlInUse{} } 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 awsRestxml_deserializeDocumentOriginAccessControlList(v **types.OriginAccessControlList, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.OriginAccessControlList if *v == nil { sv = &types.OriginAccessControlList{} } 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("IsTruncated", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv, err := strconv.ParseBool(string(val)) if err != nil { return fmt.Errorf("expected boolean to be of type *bool, got %T instead", val) } sv.IsTruncated = ptr.Bool(xtv) } case strings.EqualFold("Items", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentOriginAccessControlSummaryList(&sv.Items, 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) } case strings.EqualFold("MaxItems", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) i64, err := strconv.ParseInt(xtv, 10, 64) if err != nil { return err } sv.MaxItems = ptr.Int32(int32(i64)) } case strings.EqualFold("NextMarker", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.NextMarker = ptr.String(xtv) } case strings.EqualFold("Quantity", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) i64, err := strconv.ParseInt(xtv, 10, 64) if err != nil { return err } sv.Quantity = ptr.Int32(int32(i64)) } 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 awsRestxml_deserializeDocumentOriginAccessControlSummary(v **types.OriginAccessControlSummary, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.OriginAccessControlSummary if *v == nil { sv = &types.OriginAccessControlSummary{} } 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("Description", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.Description = ptr.String(xtv) } case strings.EqualFold("Id", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.Id = ptr.String(xtv) } case strings.EqualFold("Name", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.Name = ptr.String(xtv) } case strings.EqualFold("OriginAccessControlOriginType", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.OriginAccessControlOriginType = types.OriginAccessControlOriginTypes(xtv) } case strings.EqualFold("SigningBehavior", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.SigningBehavior = types.OriginAccessControlSigningBehaviors(xtv) } case strings.EqualFold("SigningProtocol", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.SigningProtocol = types.OriginAccessControlSigningProtocols(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 awsRestxml_deserializeDocumentOriginAccessControlSummaryList(v *[]types.OriginAccessControlSummary, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv []types.OriginAccessControlSummary if *v == nil { sv = make([]types.OriginAccessControlSummary, 0) } else { sv = *v } originalDecoder := decoder for { t, done, err := decoder.Token() if err != nil { return err } if done { break } switch { case strings.EqualFold("OriginAccessControlSummary", t.Name.Local): var col types.OriginAccessControlSummary nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) destAddr := &col if err := awsRestxml_deserializeDocumentOriginAccessControlSummary(&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 awsRestxml_deserializeDocumentOriginAccessControlSummaryListUnwrapped(v *[]types.OriginAccessControlSummary, decoder smithyxml.NodeDecoder) error { var sv []types.OriginAccessControlSummary if *v == nil { sv = make([]types.OriginAccessControlSummary, 0) } else { sv = *v } switch { default: var mv types.OriginAccessControlSummary t := decoder.StartEl _ = t nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) destAddr := &mv if err := awsRestxml_deserializeDocumentOriginAccessControlSummary(&destAddr, nodeDecoder); err != nil { return err } mv = *destAddr sv = append(sv, mv) } *v = sv return nil } func awsRestxml_deserializeDocumentOriginCustomHeader(v **types.OriginCustomHeader, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.OriginCustomHeader if *v == nil { sv = &types.OriginCustomHeader{} } 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("HeaderName", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.HeaderName = ptr.String(xtv) } case strings.EqualFold("HeaderValue", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.HeaderValue = 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 awsRestxml_deserializeDocumentOriginCustomHeadersList(v *[]types.OriginCustomHeader, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv []types.OriginCustomHeader if *v == nil { sv = make([]types.OriginCustomHeader, 0) } else { sv = *v } originalDecoder := decoder for { t, done, err := decoder.Token() if err != nil { return err } if done { break } switch { case strings.EqualFold("OriginCustomHeader", t.Name.Local): var col types.OriginCustomHeader nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) destAddr := &col if err := awsRestxml_deserializeDocumentOriginCustomHeader(&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 awsRestxml_deserializeDocumentOriginCustomHeadersListUnwrapped(v *[]types.OriginCustomHeader, decoder smithyxml.NodeDecoder) error { var sv []types.OriginCustomHeader if *v == nil { sv = make([]types.OriginCustomHeader, 0) } else { sv = *v } switch { default: var mv types.OriginCustomHeader t := decoder.StartEl _ = t nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) destAddr := &mv if err := awsRestxml_deserializeDocumentOriginCustomHeader(&destAddr, nodeDecoder); err != nil { return err } mv = *destAddr sv = append(sv, mv) } *v = sv return nil } func awsRestxml_deserializeDocumentOriginGroup(v **types.OriginGroup, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.OriginGroup if *v == nil { sv = &types.OriginGroup{} } 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("FailoverCriteria", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentOriginGroupFailoverCriteria(&sv.FailoverCriteria, nodeDecoder); err != nil { return err } case strings.EqualFold("Id", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.Id = ptr.String(xtv) } case strings.EqualFold("Members", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentOriginGroupMembers(&sv.Members, nodeDecoder); err != nil { return err } 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 awsRestxml_deserializeDocumentOriginGroupFailoverCriteria(v **types.OriginGroupFailoverCriteria, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.OriginGroupFailoverCriteria if *v == nil { sv = &types.OriginGroupFailoverCriteria{} } 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("StatusCodes", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentStatusCodes(&sv.StatusCodes, nodeDecoder); err != nil { return err } 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 awsRestxml_deserializeDocumentOriginGroupList(v *[]types.OriginGroup, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv []types.OriginGroup if *v == nil { sv = make([]types.OriginGroup, 0) } else { sv = *v } originalDecoder := decoder for { t, done, err := decoder.Token() if err != nil { return err } if done { break } switch { case strings.EqualFold("OriginGroup", t.Name.Local): var col types.OriginGroup nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) destAddr := &col if err := awsRestxml_deserializeDocumentOriginGroup(&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 awsRestxml_deserializeDocumentOriginGroupListUnwrapped(v *[]types.OriginGroup, decoder smithyxml.NodeDecoder) error { var sv []types.OriginGroup if *v == nil { sv = make([]types.OriginGroup, 0) } else { sv = *v } switch { default: var mv types.OriginGroup t := decoder.StartEl _ = t nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) destAddr := &mv if err := awsRestxml_deserializeDocumentOriginGroup(&destAddr, nodeDecoder); err != nil { return err } mv = *destAddr sv = append(sv, mv) } *v = sv return nil } func awsRestxml_deserializeDocumentOriginGroupMember(v **types.OriginGroupMember, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.OriginGroupMember if *v == nil { sv = &types.OriginGroupMember{} } 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("OriginId", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.OriginId = 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 awsRestxml_deserializeDocumentOriginGroupMemberList(v *[]types.OriginGroupMember, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv []types.OriginGroupMember if *v == nil { sv = make([]types.OriginGroupMember, 0) } else { sv = *v } originalDecoder := decoder for { t, done, err := decoder.Token() if err != nil { return err } if done { break } switch { case strings.EqualFold("OriginGroupMember", t.Name.Local): var col types.OriginGroupMember nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) destAddr := &col if err := awsRestxml_deserializeDocumentOriginGroupMember(&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 awsRestxml_deserializeDocumentOriginGroupMemberListUnwrapped(v *[]types.OriginGroupMember, decoder smithyxml.NodeDecoder) error { var sv []types.OriginGroupMember if *v == nil { sv = make([]types.OriginGroupMember, 0) } else { sv = *v } switch { default: var mv types.OriginGroupMember t := decoder.StartEl _ = t nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) destAddr := &mv if err := awsRestxml_deserializeDocumentOriginGroupMember(&destAddr, nodeDecoder); err != nil { return err } mv = *destAddr sv = append(sv, mv) } *v = sv return nil } func awsRestxml_deserializeDocumentOriginGroupMembers(v **types.OriginGroupMembers, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.OriginGroupMembers if *v == nil { sv = &types.OriginGroupMembers{} } 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("Items", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentOriginGroupMemberList(&sv.Items, nodeDecoder); err != nil { return err } case strings.EqualFold("Quantity", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) i64, err := strconv.ParseInt(xtv, 10, 64) if err != nil { return err } sv.Quantity = ptr.Int32(int32(i64)) } 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 awsRestxml_deserializeDocumentOriginGroups(v **types.OriginGroups, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.OriginGroups if *v == nil { sv = &types.OriginGroups{} } 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("Items", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentOriginGroupList(&sv.Items, nodeDecoder); err != nil { return err } case strings.EqualFold("Quantity", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) i64, err := strconv.ParseInt(xtv, 10, 64) if err != nil { return err } sv.Quantity = ptr.Int32(int32(i64)) } 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 awsRestxml_deserializeDocumentOriginList(v *[]types.Origin, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv []types.Origin if *v == nil { sv = make([]types.Origin, 0) } else { sv = *v } originalDecoder := decoder for { t, done, err := decoder.Token() if err != nil { return err } if done { break } switch { case strings.EqualFold("Origin", t.Name.Local): var col types.Origin nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) destAddr := &col if err := awsRestxml_deserializeDocumentOrigin(&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 awsRestxml_deserializeDocumentOriginListUnwrapped(v *[]types.Origin, decoder smithyxml.NodeDecoder) error { var sv []types.Origin if *v == nil { sv = make([]types.Origin, 0) } else { sv = *v } switch { default: var mv types.Origin t := decoder.StartEl _ = t nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) destAddr := &mv if err := awsRestxml_deserializeDocumentOrigin(&destAddr, nodeDecoder); err != nil { return err } mv = *destAddr sv = append(sv, mv) } *v = sv return nil } func awsRestxml_deserializeDocumentOriginRequestPolicy(v **types.OriginRequestPolicy, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.OriginRequestPolicy if *v == nil { sv = &types.OriginRequestPolicy{} } 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("Id", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.Id = ptr.String(xtv) } case strings.EqualFold("LastModifiedTime", 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.LastModifiedTime = ptr.Time(t) } case strings.EqualFold("OriginRequestPolicyConfig", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentOriginRequestPolicyConfig(&sv.OriginRequestPolicyConfig, nodeDecoder); err != nil { return err } 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 awsRestxml_deserializeDocumentOriginRequestPolicyAlreadyExists(v **types.OriginRequestPolicyAlreadyExists, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.OriginRequestPolicyAlreadyExists if *v == nil { sv = &types.OriginRequestPolicyAlreadyExists{} } 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 awsRestxml_deserializeDocumentOriginRequestPolicyConfig(v **types.OriginRequestPolicyConfig, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.OriginRequestPolicyConfig if *v == nil { sv = &types.OriginRequestPolicyConfig{} } 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("Comment", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.Comment = ptr.String(xtv) } case strings.EqualFold("CookiesConfig", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentOriginRequestPolicyCookiesConfig(&sv.CookiesConfig, nodeDecoder); err != nil { return err } case strings.EqualFold("HeadersConfig", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentOriginRequestPolicyHeadersConfig(&sv.HeadersConfig, nodeDecoder); err != nil { return err } case strings.EqualFold("Name", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.Name = ptr.String(xtv) } case strings.EqualFold("QueryStringsConfig", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentOriginRequestPolicyQueryStringsConfig(&sv.QueryStringsConfig, nodeDecoder); err != nil { return err } 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 awsRestxml_deserializeDocumentOriginRequestPolicyCookiesConfig(v **types.OriginRequestPolicyCookiesConfig, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.OriginRequestPolicyCookiesConfig if *v == nil { sv = &types.OriginRequestPolicyCookiesConfig{} } 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("CookieBehavior", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.CookieBehavior = types.OriginRequestPolicyCookieBehavior(xtv) } case strings.EqualFold("Cookies", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentCookieNames(&sv.Cookies, nodeDecoder); err != nil { return err } 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 awsRestxml_deserializeDocumentOriginRequestPolicyHeadersConfig(v **types.OriginRequestPolicyHeadersConfig, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.OriginRequestPolicyHeadersConfig if *v == nil { sv = &types.OriginRequestPolicyHeadersConfig{} } 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("HeaderBehavior", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.HeaderBehavior = types.OriginRequestPolicyHeaderBehavior(xtv) } case strings.EqualFold("Headers", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentHeaders(&sv.Headers, nodeDecoder); err != nil { return err } 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 awsRestxml_deserializeDocumentOriginRequestPolicyInUse(v **types.OriginRequestPolicyInUse, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.OriginRequestPolicyInUse if *v == nil { sv = &types.OriginRequestPolicyInUse{} } 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 awsRestxml_deserializeDocumentOriginRequestPolicyList(v **types.OriginRequestPolicyList, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.OriginRequestPolicyList if *v == nil { sv = &types.OriginRequestPolicyList{} } 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("Items", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentOriginRequestPolicySummaryList(&sv.Items, nodeDecoder); err != nil { return err } case strings.EqualFold("MaxItems", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) i64, err := strconv.ParseInt(xtv, 10, 64) if err != nil { return err } sv.MaxItems = ptr.Int32(int32(i64)) } case strings.EqualFold("NextMarker", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.NextMarker = ptr.String(xtv) } case strings.EqualFold("Quantity", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) i64, err := strconv.ParseInt(xtv, 10, 64) if err != nil { return err } sv.Quantity = ptr.Int32(int32(i64)) } 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 awsRestxml_deserializeDocumentOriginRequestPolicyQueryStringsConfig(v **types.OriginRequestPolicyQueryStringsConfig, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.OriginRequestPolicyQueryStringsConfig if *v == nil { sv = &types.OriginRequestPolicyQueryStringsConfig{} } 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("QueryStringBehavior", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.QueryStringBehavior = types.OriginRequestPolicyQueryStringBehavior(xtv) } case strings.EqualFold("QueryStrings", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentQueryStringNames(&sv.QueryStrings, nodeDecoder); err != nil { return err } 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 awsRestxml_deserializeDocumentOriginRequestPolicySummary(v **types.OriginRequestPolicySummary, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.OriginRequestPolicySummary if *v == nil { sv = &types.OriginRequestPolicySummary{} } 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("OriginRequestPolicy", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentOriginRequestPolicy(&sv.OriginRequestPolicy, nodeDecoder); err != nil { return err } case strings.EqualFold("Type", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.Type = types.OriginRequestPolicyType(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 awsRestxml_deserializeDocumentOriginRequestPolicySummaryList(v *[]types.OriginRequestPolicySummary, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv []types.OriginRequestPolicySummary if *v == nil { sv = make([]types.OriginRequestPolicySummary, 0) } else { sv = *v } originalDecoder := decoder for { t, done, err := decoder.Token() if err != nil { return err } if done { break } switch { case strings.EqualFold("OriginRequestPolicySummary", t.Name.Local): var col types.OriginRequestPolicySummary nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) destAddr := &col if err := awsRestxml_deserializeDocumentOriginRequestPolicySummary(&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 awsRestxml_deserializeDocumentOriginRequestPolicySummaryListUnwrapped(v *[]types.OriginRequestPolicySummary, decoder smithyxml.NodeDecoder) error { var sv []types.OriginRequestPolicySummary if *v == nil { sv = make([]types.OriginRequestPolicySummary, 0) } else { sv = *v } switch { default: var mv types.OriginRequestPolicySummary t := decoder.StartEl _ = t nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) destAddr := &mv if err := awsRestxml_deserializeDocumentOriginRequestPolicySummary(&destAddr, nodeDecoder); err != nil { return err } mv = *destAddr sv = append(sv, mv) } *v = sv return nil } func awsRestxml_deserializeDocumentOrigins(v **types.Origins, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.Origins if *v == nil { sv = &types.Origins{} } 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("Items", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentOriginList(&sv.Items, nodeDecoder); err != nil { return err } case strings.EqualFold("Quantity", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) i64, err := strconv.ParseInt(xtv, 10, 64) if err != nil { return err } sv.Quantity = ptr.Int32(int32(i64)) } 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 awsRestxml_deserializeDocumentOriginShield(v **types.OriginShield, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.OriginShield if *v == nil { sv = &types.OriginShield{} } 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("Enabled", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv, err := strconv.ParseBool(string(val)) if err != nil { return fmt.Errorf("expected boolean to be of type *bool, got %T instead", val) } sv.Enabled = ptr.Bool(xtv) } case strings.EqualFold("OriginShieldRegion", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.OriginShieldRegion = 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 awsRestxml_deserializeDocumentOriginSslProtocols(v **types.OriginSslProtocols, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.OriginSslProtocols if *v == nil { sv = &types.OriginSslProtocols{} } 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("Items", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentSslProtocolsList(&sv.Items, nodeDecoder); err != nil { return err } case strings.EqualFold("Quantity", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) i64, err := strconv.ParseInt(xtv, 10, 64) if err != nil { return err } sv.Quantity = ptr.Int32(int32(i64)) } 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 awsRestxml_deserializeDocumentParametersInCacheKeyAndForwardedToOrigin(v **types.ParametersInCacheKeyAndForwardedToOrigin, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.ParametersInCacheKeyAndForwardedToOrigin if *v == nil { sv = &types.ParametersInCacheKeyAndForwardedToOrigin{} } 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("CookiesConfig", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentCachePolicyCookiesConfig(&sv.CookiesConfig, nodeDecoder); err != nil { return err } case strings.EqualFold("EnableAcceptEncodingBrotli", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv, err := strconv.ParseBool(string(val)) if err != nil { return fmt.Errorf("expected boolean to be of type *bool, got %T instead", val) } sv.EnableAcceptEncodingBrotli = ptr.Bool(xtv) } case strings.EqualFold("EnableAcceptEncodingGzip", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv, err := strconv.ParseBool(string(val)) if err != nil { return fmt.Errorf("expected boolean to be of type *bool, got %T instead", val) } sv.EnableAcceptEncodingGzip = ptr.Bool(xtv) } case strings.EqualFold("HeadersConfig", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentCachePolicyHeadersConfig(&sv.HeadersConfig, nodeDecoder); err != nil { return err } case strings.EqualFold("QueryStringsConfig", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentCachePolicyQueryStringsConfig(&sv.QueryStringsConfig, nodeDecoder); err != nil { return err } 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 awsRestxml_deserializeDocumentPathList(v *[]string, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv []string if *v == nil { sv = make([]string, 0) } else { sv = *v } originalDecoder := decoder for { t, done, err := decoder.Token() if err != nil { return err } if done { break } memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) decoder = memberDecoder switch { case strings.EqualFold("Path", t.Name.Local): var col string val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) col = xtv } sv = append(sv, col) default: err = decoder.Decoder.Skip() if err != nil { return err } } decoder = originalDecoder } *v = sv return nil } func awsRestxml_deserializeDocumentPathListUnwrapped(v *[]string, decoder smithyxml.NodeDecoder) error { var sv []string if *v == nil { sv = make([]string, 0) } else { sv = *v } switch { default: var mv string t := decoder.StartEl _ = t val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) mv = xtv } sv = append(sv, mv) } *v = sv return nil } func awsRestxml_deserializeDocumentPaths(v **types.Paths, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.Paths if *v == nil { sv = &types.Paths{} } 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("Items", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentPathList(&sv.Items, nodeDecoder); err != nil { return err } case strings.EqualFold("Quantity", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) i64, err := strconv.ParseInt(xtv, 10, 64) if err != nil { return err } sv.Quantity = ptr.Int32(int32(i64)) } 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 awsRestxml_deserializeDocumentPreconditionFailed(v **types.PreconditionFailed, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.PreconditionFailed if *v == nil { sv = &types.PreconditionFailed{} } 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 awsRestxml_deserializeDocumentPublicKey(v **types.PublicKey, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.PublicKey if *v == nil { sv = &types.PublicKey{} } 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("CreatedTime", 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.CreatedTime = ptr.Time(t) } case strings.EqualFold("Id", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.Id = ptr.String(xtv) } case strings.EqualFold("PublicKeyConfig", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentPublicKeyConfig(&sv.PublicKeyConfig, nodeDecoder); err != nil { return err } 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 awsRestxml_deserializeDocumentPublicKeyAlreadyExists(v **types.PublicKeyAlreadyExists, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.PublicKeyAlreadyExists if *v == nil { sv = &types.PublicKeyAlreadyExists{} } 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 awsRestxml_deserializeDocumentPublicKeyConfig(v **types.PublicKeyConfig, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.PublicKeyConfig if *v == nil { sv = &types.PublicKeyConfig{} } 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("CallerReference", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.CallerReference = ptr.String(xtv) } case strings.EqualFold("Comment", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.Comment = ptr.String(xtv) } case strings.EqualFold("EncodedKey", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.EncodedKey = ptr.String(xtv) } case strings.EqualFold("Name", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.Name = 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 awsRestxml_deserializeDocumentPublicKeyIdList(v *[]string, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv []string if *v == nil { sv = make([]string, 0) } else { sv = *v } originalDecoder := decoder for { t, done, err := decoder.Token() if err != nil { return err } if done { break } memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) decoder = memberDecoder switch { case strings.EqualFold("PublicKey", t.Name.Local): var col string val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) col = xtv } sv = append(sv, col) default: err = decoder.Decoder.Skip() if err != nil { return err } } decoder = originalDecoder } *v = sv return nil } func awsRestxml_deserializeDocumentPublicKeyIdListUnwrapped(v *[]string, decoder smithyxml.NodeDecoder) error { var sv []string if *v == nil { sv = make([]string, 0) } else { sv = *v } switch { default: var mv string t := decoder.StartEl _ = t val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) mv = xtv } sv = append(sv, mv) } *v = sv return nil } func awsRestxml_deserializeDocumentPublicKeyInUse(v **types.PublicKeyInUse, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.PublicKeyInUse if *v == nil { sv = &types.PublicKeyInUse{} } 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 awsRestxml_deserializeDocumentPublicKeyList(v **types.PublicKeyList, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.PublicKeyList if *v == nil { sv = &types.PublicKeyList{} } 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("Items", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentPublicKeySummaryList(&sv.Items, nodeDecoder); err != nil { return err } case strings.EqualFold("MaxItems", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) i64, err := strconv.ParseInt(xtv, 10, 64) if err != nil { return err } sv.MaxItems = ptr.Int32(int32(i64)) } case strings.EqualFold("NextMarker", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.NextMarker = ptr.String(xtv) } case strings.EqualFold("Quantity", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) i64, err := strconv.ParseInt(xtv, 10, 64) if err != nil { return err } sv.Quantity = ptr.Int32(int32(i64)) } 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 awsRestxml_deserializeDocumentPublicKeySummary(v **types.PublicKeySummary, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.PublicKeySummary if *v == nil { sv = &types.PublicKeySummary{} } 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("Comment", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.Comment = ptr.String(xtv) } case strings.EqualFold("CreatedTime", 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.CreatedTime = ptr.Time(t) } case strings.EqualFold("EncodedKey", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.EncodedKey = ptr.String(xtv) } case strings.EqualFold("Id", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.Id = ptr.String(xtv) } case strings.EqualFold("Name", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.Name = 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 awsRestxml_deserializeDocumentPublicKeySummaryList(v *[]types.PublicKeySummary, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv []types.PublicKeySummary if *v == nil { sv = make([]types.PublicKeySummary, 0) } else { sv = *v } originalDecoder := decoder for { t, done, err := decoder.Token() if err != nil { return err } if done { break } switch { case strings.EqualFold("PublicKeySummary", t.Name.Local): var col types.PublicKeySummary nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) destAddr := &col if err := awsRestxml_deserializeDocumentPublicKeySummary(&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 awsRestxml_deserializeDocumentPublicKeySummaryListUnwrapped(v *[]types.PublicKeySummary, decoder smithyxml.NodeDecoder) error { var sv []types.PublicKeySummary if *v == nil { sv = make([]types.PublicKeySummary, 0) } else { sv = *v } switch { default: var mv types.PublicKeySummary t := decoder.StartEl _ = t nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) destAddr := &mv if err := awsRestxml_deserializeDocumentPublicKeySummary(&destAddr, nodeDecoder); err != nil { return err } mv = *destAddr sv = append(sv, mv) } *v = sv return nil } func awsRestxml_deserializeDocumentQueryArgProfile(v **types.QueryArgProfile, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.QueryArgProfile if *v == nil { sv = &types.QueryArgProfile{} } 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("ProfileId", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.ProfileId = ptr.String(xtv) } case strings.EqualFold("QueryArg", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.QueryArg = 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 awsRestxml_deserializeDocumentQueryArgProfileConfig(v **types.QueryArgProfileConfig, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.QueryArgProfileConfig if *v == nil { sv = &types.QueryArgProfileConfig{} } 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("ForwardWhenQueryArgProfileIsUnknown", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv, err := strconv.ParseBool(string(val)) if err != nil { return fmt.Errorf("expected boolean to be of type *bool, got %T instead", val) } sv.ForwardWhenQueryArgProfileIsUnknown = ptr.Bool(xtv) } case strings.EqualFold("QueryArgProfiles", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentQueryArgProfiles(&sv.QueryArgProfiles, nodeDecoder); err != nil { return err } 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 awsRestxml_deserializeDocumentQueryArgProfileEmpty(v **types.QueryArgProfileEmpty, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.QueryArgProfileEmpty if *v == nil { sv = &types.QueryArgProfileEmpty{} } 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 awsRestxml_deserializeDocumentQueryArgProfileList(v *[]types.QueryArgProfile, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv []types.QueryArgProfile if *v == nil { sv = make([]types.QueryArgProfile, 0) } else { sv = *v } originalDecoder := decoder for { t, done, err := decoder.Token() if err != nil { return err } if done { break } switch { case strings.EqualFold("QueryArgProfile", t.Name.Local): var col types.QueryArgProfile nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) destAddr := &col if err := awsRestxml_deserializeDocumentQueryArgProfile(&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 awsRestxml_deserializeDocumentQueryArgProfileListUnwrapped(v *[]types.QueryArgProfile, decoder smithyxml.NodeDecoder) error { var sv []types.QueryArgProfile if *v == nil { sv = make([]types.QueryArgProfile, 0) } else { sv = *v } switch { default: var mv types.QueryArgProfile t := decoder.StartEl _ = t nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) destAddr := &mv if err := awsRestxml_deserializeDocumentQueryArgProfile(&destAddr, nodeDecoder); err != nil { return err } mv = *destAddr sv = append(sv, mv) } *v = sv return nil } func awsRestxml_deserializeDocumentQueryArgProfiles(v **types.QueryArgProfiles, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.QueryArgProfiles if *v == nil { sv = &types.QueryArgProfiles{} } 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("Items", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentQueryArgProfileList(&sv.Items, nodeDecoder); err != nil { return err } case strings.EqualFold("Quantity", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) i64, err := strconv.ParseInt(xtv, 10, 64) if err != nil { return err } sv.Quantity = ptr.Int32(int32(i64)) } 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 awsRestxml_deserializeDocumentQueryStringCacheKeys(v **types.QueryStringCacheKeys, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.QueryStringCacheKeys if *v == nil { sv = &types.QueryStringCacheKeys{} } 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("Items", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentQueryStringCacheKeysList(&sv.Items, nodeDecoder); err != nil { return err } case strings.EqualFold("Quantity", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) i64, err := strconv.ParseInt(xtv, 10, 64) if err != nil { return err } sv.Quantity = ptr.Int32(int32(i64)) } 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 awsRestxml_deserializeDocumentQueryStringCacheKeysList(v *[]string, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv []string if *v == nil { sv = make([]string, 0) } else { sv = *v } originalDecoder := decoder for { t, done, err := decoder.Token() if err != nil { return err } if done { break } memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) decoder = memberDecoder switch { case strings.EqualFold("Name", t.Name.Local): var col string val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) col = xtv } sv = append(sv, col) default: err = decoder.Decoder.Skip() if err != nil { return err } } decoder = originalDecoder } *v = sv return nil } func awsRestxml_deserializeDocumentQueryStringCacheKeysListUnwrapped(v *[]string, decoder smithyxml.NodeDecoder) error { var sv []string if *v == nil { sv = make([]string, 0) } else { sv = *v } switch { default: var mv string t := decoder.StartEl _ = t val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) mv = xtv } sv = append(sv, mv) } *v = sv return nil } func awsRestxml_deserializeDocumentQueryStringNames(v **types.QueryStringNames, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.QueryStringNames if *v == nil { sv = &types.QueryStringNames{} } 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("Items", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentQueryStringNamesList(&sv.Items, nodeDecoder); err != nil { return err } case strings.EqualFold("Quantity", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) i64, err := strconv.ParseInt(xtv, 10, 64) if err != nil { return err } sv.Quantity = ptr.Int32(int32(i64)) } 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 awsRestxml_deserializeDocumentQueryStringNamesList(v *[]string, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv []string if *v == nil { sv = make([]string, 0) } else { sv = *v } originalDecoder := decoder for { t, done, err := decoder.Token() if err != nil { return err } if done { break } memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) decoder = memberDecoder switch { case strings.EqualFold("Name", t.Name.Local): var col string val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) col = xtv } sv = append(sv, col) default: err = decoder.Decoder.Skip() if err != nil { return err } } decoder = originalDecoder } *v = sv return nil } func awsRestxml_deserializeDocumentQueryStringNamesListUnwrapped(v *[]string, decoder smithyxml.NodeDecoder) error { var sv []string if *v == nil { sv = make([]string, 0) } else { sv = *v } switch { default: var mv string t := decoder.StartEl _ = t val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) mv = xtv } sv = append(sv, mv) } *v = sv return nil } func awsRestxml_deserializeDocumentRealtimeLogConfig(v **types.RealtimeLogConfig, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.RealtimeLogConfig if *v == nil { sv = &types.RealtimeLogConfig{} } 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("ARN", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.ARN = ptr.String(xtv) } case strings.EqualFold("EndPoints", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentEndPointList(&sv.EndPoints, nodeDecoder); err != nil { return err } case strings.EqualFold("Fields", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentFieldList(&sv.Fields, nodeDecoder); err != nil { return err } case strings.EqualFold("Name", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.Name = ptr.String(xtv) } case strings.EqualFold("SamplingRate", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) i64, err := strconv.ParseInt(xtv, 10, 64) if err != nil { return err } sv.SamplingRate = ptr.Int64(i64) } 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 awsRestxml_deserializeDocumentRealtimeLogConfigAlreadyExists(v **types.RealtimeLogConfigAlreadyExists, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.RealtimeLogConfigAlreadyExists if *v == nil { sv = &types.RealtimeLogConfigAlreadyExists{} } 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 awsRestxml_deserializeDocumentRealtimeLogConfigInUse(v **types.RealtimeLogConfigInUse, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.RealtimeLogConfigInUse if *v == nil { sv = &types.RealtimeLogConfigInUse{} } 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 awsRestxml_deserializeDocumentRealtimeLogConfigList(v *[]types.RealtimeLogConfig, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv []types.RealtimeLogConfig if *v == nil { sv = make([]types.RealtimeLogConfig, 0) } else { sv = *v } originalDecoder := decoder for { t, done, err := decoder.Token() if err != nil { return err } if done { break } switch { case strings.EqualFold("member", t.Name.Local): var col types.RealtimeLogConfig nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) destAddr := &col if err := awsRestxml_deserializeDocumentRealtimeLogConfig(&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 awsRestxml_deserializeDocumentRealtimeLogConfigListUnwrapped(v *[]types.RealtimeLogConfig, decoder smithyxml.NodeDecoder) error { var sv []types.RealtimeLogConfig if *v == nil { sv = make([]types.RealtimeLogConfig, 0) } else { sv = *v } switch { default: var mv types.RealtimeLogConfig t := decoder.StartEl _ = t nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) destAddr := &mv if err := awsRestxml_deserializeDocumentRealtimeLogConfig(&destAddr, nodeDecoder); err != nil { return err } mv = *destAddr sv = append(sv, mv) } *v = sv return nil } func awsRestxml_deserializeDocumentRealtimeLogConfigOwnerMismatch(v **types.RealtimeLogConfigOwnerMismatch, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.RealtimeLogConfigOwnerMismatch if *v == nil { sv = &types.RealtimeLogConfigOwnerMismatch{} } 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 awsRestxml_deserializeDocumentRealtimeLogConfigs(v **types.RealtimeLogConfigs, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.RealtimeLogConfigs if *v == nil { sv = &types.RealtimeLogConfigs{} } 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("IsTruncated", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv, err := strconv.ParseBool(string(val)) if err != nil { return fmt.Errorf("expected boolean to be of type *bool, got %T instead", val) } sv.IsTruncated = ptr.Bool(xtv) } case strings.EqualFold("Items", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentRealtimeLogConfigList(&sv.Items, 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) } case strings.EqualFold("MaxItems", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) i64, err := strconv.ParseInt(xtv, 10, 64) if err != nil { return err } sv.MaxItems = ptr.Int32(int32(i64)) } case strings.EqualFold("NextMarker", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.NextMarker = 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 awsRestxml_deserializeDocumentRealtimeMetricsSubscriptionConfig(v **types.RealtimeMetricsSubscriptionConfig, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.RealtimeMetricsSubscriptionConfig if *v == nil { sv = &types.RealtimeMetricsSubscriptionConfig{} } 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("RealtimeMetricsSubscriptionStatus", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.RealtimeMetricsSubscriptionStatus = types.RealtimeMetricsSubscriptionStatus(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 awsRestxml_deserializeDocumentResourceInUse(v **types.ResourceInUse, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.ResourceInUse if *v == nil { sv = &types.ResourceInUse{} } 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 awsRestxml_deserializeDocumentResponseHeadersPolicy(v **types.ResponseHeadersPolicy, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.ResponseHeadersPolicy if *v == nil { sv = &types.ResponseHeadersPolicy{} } 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("Id", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.Id = ptr.String(xtv) } case strings.EqualFold("LastModifiedTime", 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.LastModifiedTime = ptr.Time(t) } case strings.EqualFold("ResponseHeadersPolicyConfig", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentResponseHeadersPolicyConfig(&sv.ResponseHeadersPolicyConfig, nodeDecoder); err != nil { return err } 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 awsRestxml_deserializeDocumentResponseHeadersPolicyAccessControlAllowHeaders(v **types.ResponseHeadersPolicyAccessControlAllowHeaders, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.ResponseHeadersPolicyAccessControlAllowHeaders if *v == nil { sv = &types.ResponseHeadersPolicyAccessControlAllowHeaders{} } 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("Items", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentAccessControlAllowHeadersList(&sv.Items, nodeDecoder); err != nil { return err } case strings.EqualFold("Quantity", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) i64, err := strconv.ParseInt(xtv, 10, 64) if err != nil { return err } sv.Quantity = ptr.Int32(int32(i64)) } 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 awsRestxml_deserializeDocumentResponseHeadersPolicyAccessControlAllowMethods(v **types.ResponseHeadersPolicyAccessControlAllowMethods, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.ResponseHeadersPolicyAccessControlAllowMethods if *v == nil { sv = &types.ResponseHeadersPolicyAccessControlAllowMethods{} } 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("Items", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentAccessControlAllowMethodsList(&sv.Items, nodeDecoder); err != nil { return err } case strings.EqualFold("Quantity", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) i64, err := strconv.ParseInt(xtv, 10, 64) if err != nil { return err } sv.Quantity = ptr.Int32(int32(i64)) } 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 awsRestxml_deserializeDocumentResponseHeadersPolicyAccessControlAllowOrigins(v **types.ResponseHeadersPolicyAccessControlAllowOrigins, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.ResponseHeadersPolicyAccessControlAllowOrigins if *v == nil { sv = &types.ResponseHeadersPolicyAccessControlAllowOrigins{} } 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("Items", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentAccessControlAllowOriginsList(&sv.Items, nodeDecoder); err != nil { return err } case strings.EqualFold("Quantity", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) i64, err := strconv.ParseInt(xtv, 10, 64) if err != nil { return err } sv.Quantity = ptr.Int32(int32(i64)) } 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 awsRestxml_deserializeDocumentResponseHeadersPolicyAccessControlExposeHeaders(v **types.ResponseHeadersPolicyAccessControlExposeHeaders, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.ResponseHeadersPolicyAccessControlExposeHeaders if *v == nil { sv = &types.ResponseHeadersPolicyAccessControlExposeHeaders{} } 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("Items", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentAccessControlExposeHeadersList(&sv.Items, nodeDecoder); err != nil { return err } case strings.EqualFold("Quantity", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) i64, err := strconv.ParseInt(xtv, 10, 64) if err != nil { return err } sv.Quantity = ptr.Int32(int32(i64)) } 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 awsRestxml_deserializeDocumentResponseHeadersPolicyAlreadyExists(v **types.ResponseHeadersPolicyAlreadyExists, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.ResponseHeadersPolicyAlreadyExists if *v == nil { sv = &types.ResponseHeadersPolicyAlreadyExists{} } 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 awsRestxml_deserializeDocumentResponseHeadersPolicyConfig(v **types.ResponseHeadersPolicyConfig, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.ResponseHeadersPolicyConfig if *v == nil { sv = &types.ResponseHeadersPolicyConfig{} } 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("Comment", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.Comment = ptr.String(xtv) } case strings.EqualFold("CorsConfig", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentResponseHeadersPolicyCorsConfig(&sv.CorsConfig, nodeDecoder); err != nil { return err } case strings.EqualFold("CustomHeadersConfig", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentResponseHeadersPolicyCustomHeadersConfig(&sv.CustomHeadersConfig, nodeDecoder); err != nil { return err } case strings.EqualFold("Name", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.Name = ptr.String(xtv) } case strings.EqualFold("RemoveHeadersConfig", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentResponseHeadersPolicyRemoveHeadersConfig(&sv.RemoveHeadersConfig, nodeDecoder); err != nil { return err } case strings.EqualFold("SecurityHeadersConfig", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentResponseHeadersPolicySecurityHeadersConfig(&sv.SecurityHeadersConfig, nodeDecoder); err != nil { return err } case strings.EqualFold("ServerTimingHeadersConfig", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentResponseHeadersPolicyServerTimingHeadersConfig(&sv.ServerTimingHeadersConfig, nodeDecoder); err != nil { return err } 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 awsRestxml_deserializeDocumentResponseHeadersPolicyContentSecurityPolicy(v **types.ResponseHeadersPolicyContentSecurityPolicy, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.ResponseHeadersPolicyContentSecurityPolicy if *v == nil { sv = &types.ResponseHeadersPolicyContentSecurityPolicy{} } 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("ContentSecurityPolicy", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.ContentSecurityPolicy = ptr.String(xtv) } case strings.EqualFold("Override", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv, err := strconv.ParseBool(string(val)) if err != nil { return fmt.Errorf("expected boolean to be of type *bool, got %T instead", val) } sv.Override = ptr.Bool(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 awsRestxml_deserializeDocumentResponseHeadersPolicyContentTypeOptions(v **types.ResponseHeadersPolicyContentTypeOptions, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.ResponseHeadersPolicyContentTypeOptions if *v == nil { sv = &types.ResponseHeadersPolicyContentTypeOptions{} } 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("Override", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv, err := strconv.ParseBool(string(val)) if err != nil { return fmt.Errorf("expected boolean to be of type *bool, got %T instead", val) } sv.Override = ptr.Bool(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 awsRestxml_deserializeDocumentResponseHeadersPolicyCorsConfig(v **types.ResponseHeadersPolicyCorsConfig, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.ResponseHeadersPolicyCorsConfig if *v == nil { sv = &types.ResponseHeadersPolicyCorsConfig{} } 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("AccessControlAllowCredentials", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv, err := strconv.ParseBool(string(val)) if err != nil { return fmt.Errorf("expected boolean to be of type *bool, got %T instead", val) } sv.AccessControlAllowCredentials = ptr.Bool(xtv) } case strings.EqualFold("AccessControlAllowHeaders", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentResponseHeadersPolicyAccessControlAllowHeaders(&sv.AccessControlAllowHeaders, nodeDecoder); err != nil { return err } case strings.EqualFold("AccessControlAllowMethods", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentResponseHeadersPolicyAccessControlAllowMethods(&sv.AccessControlAllowMethods, nodeDecoder); err != nil { return err } case strings.EqualFold("AccessControlAllowOrigins", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentResponseHeadersPolicyAccessControlAllowOrigins(&sv.AccessControlAllowOrigins, nodeDecoder); err != nil { return err } case strings.EqualFold("AccessControlExposeHeaders", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentResponseHeadersPolicyAccessControlExposeHeaders(&sv.AccessControlExposeHeaders, nodeDecoder); err != nil { return err } case strings.EqualFold("AccessControlMaxAgeSec", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) i64, err := strconv.ParseInt(xtv, 10, 64) if err != nil { return err } sv.AccessControlMaxAgeSec = ptr.Int32(int32(i64)) } case strings.EqualFold("OriginOverride", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv, err := strconv.ParseBool(string(val)) if err != nil { return fmt.Errorf("expected boolean to be of type *bool, got %T instead", val) } sv.OriginOverride = ptr.Bool(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 awsRestxml_deserializeDocumentResponseHeadersPolicyCustomHeader(v **types.ResponseHeadersPolicyCustomHeader, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.ResponseHeadersPolicyCustomHeader if *v == nil { sv = &types.ResponseHeadersPolicyCustomHeader{} } 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("Header", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.Header = ptr.String(xtv) } case strings.EqualFold("Override", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv, err := strconv.ParseBool(string(val)) if err != nil { return fmt.Errorf("expected boolean to be of type *bool, got %T instead", val) } sv.Override = ptr.Bool(xtv) } case strings.EqualFold("Value", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.Value = 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 awsRestxml_deserializeDocumentResponseHeadersPolicyCustomHeaderList(v *[]types.ResponseHeadersPolicyCustomHeader, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv []types.ResponseHeadersPolicyCustomHeader if *v == nil { sv = make([]types.ResponseHeadersPolicyCustomHeader, 0) } else { sv = *v } originalDecoder := decoder for { t, done, err := decoder.Token() if err != nil { return err } if done { break } switch { case strings.EqualFold("ResponseHeadersPolicyCustomHeader", t.Name.Local): var col types.ResponseHeadersPolicyCustomHeader nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) destAddr := &col if err := awsRestxml_deserializeDocumentResponseHeadersPolicyCustomHeader(&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 awsRestxml_deserializeDocumentResponseHeadersPolicyCustomHeaderListUnwrapped(v *[]types.ResponseHeadersPolicyCustomHeader, decoder smithyxml.NodeDecoder) error { var sv []types.ResponseHeadersPolicyCustomHeader if *v == nil { sv = make([]types.ResponseHeadersPolicyCustomHeader, 0) } else { sv = *v } switch { default: var mv types.ResponseHeadersPolicyCustomHeader t := decoder.StartEl _ = t nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) destAddr := &mv if err := awsRestxml_deserializeDocumentResponseHeadersPolicyCustomHeader(&destAddr, nodeDecoder); err != nil { return err } mv = *destAddr sv = append(sv, mv) } *v = sv return nil } func awsRestxml_deserializeDocumentResponseHeadersPolicyCustomHeadersConfig(v **types.ResponseHeadersPolicyCustomHeadersConfig, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.ResponseHeadersPolicyCustomHeadersConfig if *v == nil { sv = &types.ResponseHeadersPolicyCustomHeadersConfig{} } 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("Items", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentResponseHeadersPolicyCustomHeaderList(&sv.Items, nodeDecoder); err != nil { return err } case strings.EqualFold("Quantity", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) i64, err := strconv.ParseInt(xtv, 10, 64) if err != nil { return err } sv.Quantity = ptr.Int32(int32(i64)) } 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 awsRestxml_deserializeDocumentResponseHeadersPolicyFrameOptions(v **types.ResponseHeadersPolicyFrameOptions, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.ResponseHeadersPolicyFrameOptions if *v == nil { sv = &types.ResponseHeadersPolicyFrameOptions{} } 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("FrameOption", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.FrameOption = types.FrameOptionsList(xtv) } case strings.EqualFold("Override", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv, err := strconv.ParseBool(string(val)) if err != nil { return fmt.Errorf("expected boolean to be of type *bool, got %T instead", val) } sv.Override = ptr.Bool(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 awsRestxml_deserializeDocumentResponseHeadersPolicyInUse(v **types.ResponseHeadersPolicyInUse, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.ResponseHeadersPolicyInUse if *v == nil { sv = &types.ResponseHeadersPolicyInUse{} } 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 awsRestxml_deserializeDocumentResponseHeadersPolicyList(v **types.ResponseHeadersPolicyList, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.ResponseHeadersPolicyList if *v == nil { sv = &types.ResponseHeadersPolicyList{} } 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("Items", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentResponseHeadersPolicySummaryList(&sv.Items, nodeDecoder); err != nil { return err } case strings.EqualFold("MaxItems", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) i64, err := strconv.ParseInt(xtv, 10, 64) if err != nil { return err } sv.MaxItems = ptr.Int32(int32(i64)) } case strings.EqualFold("NextMarker", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.NextMarker = ptr.String(xtv) } case strings.EqualFold("Quantity", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) i64, err := strconv.ParseInt(xtv, 10, 64) if err != nil { return err } sv.Quantity = ptr.Int32(int32(i64)) } 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 awsRestxml_deserializeDocumentResponseHeadersPolicyReferrerPolicy(v **types.ResponseHeadersPolicyReferrerPolicy, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.ResponseHeadersPolicyReferrerPolicy if *v == nil { sv = &types.ResponseHeadersPolicyReferrerPolicy{} } 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("Override", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv, err := strconv.ParseBool(string(val)) if err != nil { return fmt.Errorf("expected boolean to be of type *bool, got %T instead", val) } sv.Override = ptr.Bool(xtv) } case strings.EqualFold("ReferrerPolicy", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.ReferrerPolicy = types.ReferrerPolicyList(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 awsRestxml_deserializeDocumentResponseHeadersPolicyRemoveHeader(v **types.ResponseHeadersPolicyRemoveHeader, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.ResponseHeadersPolicyRemoveHeader if *v == nil { sv = &types.ResponseHeadersPolicyRemoveHeader{} } 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("Header", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.Header = 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 awsRestxml_deserializeDocumentResponseHeadersPolicyRemoveHeaderList(v *[]types.ResponseHeadersPolicyRemoveHeader, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv []types.ResponseHeadersPolicyRemoveHeader if *v == nil { sv = make([]types.ResponseHeadersPolicyRemoveHeader, 0) } else { sv = *v } originalDecoder := decoder for { t, done, err := decoder.Token() if err != nil { return err } if done { break } switch { case strings.EqualFold("ResponseHeadersPolicyRemoveHeader", t.Name.Local): var col types.ResponseHeadersPolicyRemoveHeader nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) destAddr := &col if err := awsRestxml_deserializeDocumentResponseHeadersPolicyRemoveHeader(&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 awsRestxml_deserializeDocumentResponseHeadersPolicyRemoveHeaderListUnwrapped(v *[]types.ResponseHeadersPolicyRemoveHeader, decoder smithyxml.NodeDecoder) error { var sv []types.ResponseHeadersPolicyRemoveHeader if *v == nil { sv = make([]types.ResponseHeadersPolicyRemoveHeader, 0) } else { sv = *v } switch { default: var mv types.ResponseHeadersPolicyRemoveHeader t := decoder.StartEl _ = t nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) destAddr := &mv if err := awsRestxml_deserializeDocumentResponseHeadersPolicyRemoveHeader(&destAddr, nodeDecoder); err != nil { return err } mv = *destAddr sv = append(sv, mv) } *v = sv return nil } func awsRestxml_deserializeDocumentResponseHeadersPolicyRemoveHeadersConfig(v **types.ResponseHeadersPolicyRemoveHeadersConfig, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.ResponseHeadersPolicyRemoveHeadersConfig if *v == nil { sv = &types.ResponseHeadersPolicyRemoveHeadersConfig{} } 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("Items", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentResponseHeadersPolicyRemoveHeaderList(&sv.Items, nodeDecoder); err != nil { return err } case strings.EqualFold("Quantity", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) i64, err := strconv.ParseInt(xtv, 10, 64) if err != nil { return err } sv.Quantity = ptr.Int32(int32(i64)) } 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 awsRestxml_deserializeDocumentResponseHeadersPolicySecurityHeadersConfig(v **types.ResponseHeadersPolicySecurityHeadersConfig, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.ResponseHeadersPolicySecurityHeadersConfig if *v == nil { sv = &types.ResponseHeadersPolicySecurityHeadersConfig{} } 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("ContentSecurityPolicy", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentResponseHeadersPolicyContentSecurityPolicy(&sv.ContentSecurityPolicy, nodeDecoder); err != nil { return err } case strings.EqualFold("ContentTypeOptions", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentResponseHeadersPolicyContentTypeOptions(&sv.ContentTypeOptions, nodeDecoder); err != nil { return err } case strings.EqualFold("FrameOptions", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentResponseHeadersPolicyFrameOptions(&sv.FrameOptions, nodeDecoder); err != nil { return err } case strings.EqualFold("ReferrerPolicy", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentResponseHeadersPolicyReferrerPolicy(&sv.ReferrerPolicy, nodeDecoder); err != nil { return err } case strings.EqualFold("StrictTransportSecurity", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentResponseHeadersPolicyStrictTransportSecurity(&sv.StrictTransportSecurity, nodeDecoder); err != nil { return err } case strings.EqualFold("XSSProtection", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentResponseHeadersPolicyXSSProtection(&sv.XSSProtection, nodeDecoder); err != nil { return err } 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 awsRestxml_deserializeDocumentResponseHeadersPolicyServerTimingHeadersConfig(v **types.ResponseHeadersPolicyServerTimingHeadersConfig, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.ResponseHeadersPolicyServerTimingHeadersConfig if *v == nil { sv = &types.ResponseHeadersPolicyServerTimingHeadersConfig{} } 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("Enabled", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv, err := strconv.ParseBool(string(val)) if err != nil { return fmt.Errorf("expected boolean to be of type *bool, got %T instead", val) } sv.Enabled = ptr.Bool(xtv) } case strings.EqualFold("SamplingRate", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) f64, err := strconv.ParseFloat(xtv, 64) if err != nil { return err } sv.SamplingRate = ptr.Float64(f64) } 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 awsRestxml_deserializeDocumentResponseHeadersPolicyStrictTransportSecurity(v **types.ResponseHeadersPolicyStrictTransportSecurity, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.ResponseHeadersPolicyStrictTransportSecurity if *v == nil { sv = &types.ResponseHeadersPolicyStrictTransportSecurity{} } 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("AccessControlMaxAgeSec", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) i64, err := strconv.ParseInt(xtv, 10, 64) if err != nil { return err } sv.AccessControlMaxAgeSec = ptr.Int32(int32(i64)) } case strings.EqualFold("IncludeSubdomains", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv, err := strconv.ParseBool(string(val)) if err != nil { return fmt.Errorf("expected boolean to be of type *bool, got %T instead", val) } sv.IncludeSubdomains = ptr.Bool(xtv) } case strings.EqualFold("Override", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv, err := strconv.ParseBool(string(val)) if err != nil { return fmt.Errorf("expected boolean to be of type *bool, got %T instead", val) } sv.Override = ptr.Bool(xtv) } case strings.EqualFold("Preload", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv, err := strconv.ParseBool(string(val)) if err != nil { return fmt.Errorf("expected boolean to be of type *bool, got %T instead", val) } sv.Preload = ptr.Bool(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 awsRestxml_deserializeDocumentResponseHeadersPolicySummary(v **types.ResponseHeadersPolicySummary, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.ResponseHeadersPolicySummary if *v == nil { sv = &types.ResponseHeadersPolicySummary{} } 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("ResponseHeadersPolicy", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentResponseHeadersPolicy(&sv.ResponseHeadersPolicy, nodeDecoder); err != nil { return err } case strings.EqualFold("Type", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.Type = types.ResponseHeadersPolicyType(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 awsRestxml_deserializeDocumentResponseHeadersPolicySummaryList(v *[]types.ResponseHeadersPolicySummary, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv []types.ResponseHeadersPolicySummary if *v == nil { sv = make([]types.ResponseHeadersPolicySummary, 0) } else { sv = *v } originalDecoder := decoder for { t, done, err := decoder.Token() if err != nil { return err } if done { break } switch { case strings.EqualFold("ResponseHeadersPolicySummary", t.Name.Local): var col types.ResponseHeadersPolicySummary nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) destAddr := &col if err := awsRestxml_deserializeDocumentResponseHeadersPolicySummary(&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 awsRestxml_deserializeDocumentResponseHeadersPolicySummaryListUnwrapped(v *[]types.ResponseHeadersPolicySummary, decoder smithyxml.NodeDecoder) error { var sv []types.ResponseHeadersPolicySummary if *v == nil { sv = make([]types.ResponseHeadersPolicySummary, 0) } else { sv = *v } switch { default: var mv types.ResponseHeadersPolicySummary t := decoder.StartEl _ = t nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) destAddr := &mv if err := awsRestxml_deserializeDocumentResponseHeadersPolicySummary(&destAddr, nodeDecoder); err != nil { return err } mv = *destAddr sv = append(sv, mv) } *v = sv return nil } func awsRestxml_deserializeDocumentResponseHeadersPolicyXSSProtection(v **types.ResponseHeadersPolicyXSSProtection, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.ResponseHeadersPolicyXSSProtection if *v == nil { sv = &types.ResponseHeadersPolicyXSSProtection{} } 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("ModeBlock", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv, err := strconv.ParseBool(string(val)) if err != nil { return fmt.Errorf("expected boolean to be of type *bool, got %T instead", val) } sv.ModeBlock = ptr.Bool(xtv) } case strings.EqualFold("Override", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv, err := strconv.ParseBool(string(val)) if err != nil { return fmt.Errorf("expected boolean to be of type *bool, got %T instead", val) } sv.Override = ptr.Bool(xtv) } case strings.EqualFold("Protection", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv, err := strconv.ParseBool(string(val)) if err != nil { return fmt.Errorf("expected boolean to be of type *bool, got %T instead", val) } sv.Protection = ptr.Bool(xtv) } case strings.EqualFold("ReportUri", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.ReportUri = 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 awsRestxml_deserializeDocumentRestrictions(v **types.Restrictions, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.Restrictions if *v == nil { sv = &types.Restrictions{} } 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("GeoRestriction", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentGeoRestriction(&sv.GeoRestriction, nodeDecoder); err != nil { return err } 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 awsRestxml_deserializeDocumentS3Origin(v **types.S3Origin, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.S3Origin if *v == nil { sv = &types.S3Origin{} } 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("DomainName", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.DomainName = ptr.String(xtv) } case strings.EqualFold("OriginAccessIdentity", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.OriginAccessIdentity = 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 awsRestxml_deserializeDocumentS3OriginConfig(v **types.S3OriginConfig, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.S3OriginConfig if *v == nil { sv = &types.S3OriginConfig{} } 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("OriginAccessIdentity", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.OriginAccessIdentity = 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 awsRestxml_deserializeDocumentSessionStickinessConfig(v **types.SessionStickinessConfig, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.SessionStickinessConfig if *v == nil { sv = &types.SessionStickinessConfig{} } 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("IdleTTL", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) i64, err := strconv.ParseInt(xtv, 10, 64) if err != nil { return err } sv.IdleTTL = ptr.Int32(int32(i64)) } case strings.EqualFold("MaximumTTL", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) i64, err := strconv.ParseInt(xtv, 10, 64) if err != nil { return err } sv.MaximumTTL = ptr.Int32(int32(i64)) } 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 awsRestxml_deserializeDocumentSigner(v **types.Signer, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.Signer if *v == nil { sv = &types.Signer{} } 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("AwsAccountNumber", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.AwsAccountNumber = ptr.String(xtv) } case strings.EqualFold("KeyPairIds", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentKeyPairIds(&sv.KeyPairIds, nodeDecoder); err != nil { return err } 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 awsRestxml_deserializeDocumentSignerList(v *[]types.Signer, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv []types.Signer if *v == nil { sv = make([]types.Signer, 0) } else { sv = *v } originalDecoder := decoder for { t, done, err := decoder.Token() if err != nil { return err } if done { break } switch { case strings.EqualFold("Signer", t.Name.Local): var col types.Signer nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) destAddr := &col if err := awsRestxml_deserializeDocumentSigner(&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 awsRestxml_deserializeDocumentSignerListUnwrapped(v *[]types.Signer, decoder smithyxml.NodeDecoder) error { var sv []types.Signer if *v == nil { sv = make([]types.Signer, 0) } else { sv = *v } switch { default: var mv types.Signer t := decoder.StartEl _ = t nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) destAddr := &mv if err := awsRestxml_deserializeDocumentSigner(&destAddr, nodeDecoder); err != nil { return err } mv = *destAddr sv = append(sv, mv) } *v = sv return nil } func awsRestxml_deserializeDocumentSslProtocolsList(v *[]types.SslProtocol, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv []types.SslProtocol if *v == nil { sv = make([]types.SslProtocol, 0) } else { sv = *v } originalDecoder := decoder for { t, done, err := decoder.Token() if err != nil { return err } if done { break } memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) decoder = memberDecoder switch { case strings.EqualFold("SslProtocol", t.Name.Local): var col types.SslProtocol val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) col = types.SslProtocol(xtv) } sv = append(sv, col) default: err = decoder.Decoder.Skip() if err != nil { return err } } decoder = originalDecoder } *v = sv return nil } func awsRestxml_deserializeDocumentSslProtocolsListUnwrapped(v *[]types.SslProtocol, decoder smithyxml.NodeDecoder) error { var sv []types.SslProtocol if *v == nil { sv = make([]types.SslProtocol, 0) } else { sv = *v } switch { default: var mv types.SslProtocol t := decoder.StartEl _ = t val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) mv = types.SslProtocol(xtv) } sv = append(sv, mv) } *v = sv return nil } func awsRestxml_deserializeDocumentStagingDistributionDnsNameList(v *[]string, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv []string if *v == nil { sv = make([]string, 0) } else { sv = *v } originalDecoder := decoder for { t, done, err := decoder.Token() if err != nil { return err } if done { break } memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) decoder = memberDecoder switch { case strings.EqualFold("DnsName", t.Name.Local): var col string val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) col = xtv } sv = append(sv, col) default: err = decoder.Decoder.Skip() if err != nil { return err } } decoder = originalDecoder } *v = sv return nil } func awsRestxml_deserializeDocumentStagingDistributionDnsNameListUnwrapped(v *[]string, decoder smithyxml.NodeDecoder) error { var sv []string if *v == nil { sv = make([]string, 0) } else { sv = *v } switch { default: var mv string t := decoder.StartEl _ = t val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) mv = xtv } sv = append(sv, mv) } *v = sv return nil } func awsRestxml_deserializeDocumentStagingDistributionDnsNames(v **types.StagingDistributionDnsNames, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.StagingDistributionDnsNames if *v == nil { sv = &types.StagingDistributionDnsNames{} } 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("Items", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentStagingDistributionDnsNameList(&sv.Items, nodeDecoder); err != nil { return err } case strings.EqualFold("Quantity", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) i64, err := strconv.ParseInt(xtv, 10, 64) if err != nil { return err } sv.Quantity = ptr.Int32(int32(i64)) } 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 awsRestxml_deserializeDocumentStagingDistributionInUse(v **types.StagingDistributionInUse, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.StagingDistributionInUse if *v == nil { sv = &types.StagingDistributionInUse{} } 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 awsRestxml_deserializeDocumentStatusCodeList(v *[]int32, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv []int32 if *v == nil { sv = make([]int32, 0) } else { sv = *v } originalDecoder := decoder for { t, done, err := decoder.Token() if err != nil { return err } if done { break } memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) decoder = memberDecoder switch { case strings.EqualFold("StatusCode", t.Name.Local): var col int32 val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) i64, err := strconv.ParseInt(xtv, 10, 64) if err != nil { return err } col = int32(i64) } sv = append(sv, col) default: err = decoder.Decoder.Skip() if err != nil { return err } } decoder = originalDecoder } *v = sv return nil } func awsRestxml_deserializeDocumentStatusCodeListUnwrapped(v *[]int32, decoder smithyxml.NodeDecoder) error { var sv []int32 if *v == nil { sv = make([]int32, 0) } else { sv = *v } switch { default: var mv int32 t := decoder.StartEl _ = t val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) i64, err := strconv.ParseInt(xtv, 10, 64) if err != nil { return err } mv = int32(i64) } sv = append(sv, mv) } *v = sv return nil } func awsRestxml_deserializeDocumentStatusCodes(v **types.StatusCodes, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.StatusCodes if *v == nil { sv = &types.StatusCodes{} } 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("Items", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentStatusCodeList(&sv.Items, nodeDecoder); err != nil { return err } case strings.EqualFold("Quantity", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) i64, err := strconv.ParseInt(xtv, 10, 64) if err != nil { return err } sv.Quantity = ptr.Int32(int32(i64)) } 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 awsRestxml_deserializeDocumentStreamingDistribution(v **types.StreamingDistribution, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.StreamingDistribution if *v == nil { sv = &types.StreamingDistribution{} } 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("ActiveTrustedSigners", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentActiveTrustedSigners(&sv.ActiveTrustedSigners, nodeDecoder); err != nil { return err } case strings.EqualFold("ARN", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.ARN = ptr.String(xtv) } case strings.EqualFold("DomainName", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.DomainName = ptr.String(xtv) } case strings.EqualFold("Id", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.Id = ptr.String(xtv) } case strings.EqualFold("LastModifiedTime", 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.LastModifiedTime = ptr.Time(t) } case strings.EqualFold("Status", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.Status = ptr.String(xtv) } case strings.EqualFold("StreamingDistributionConfig", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentStreamingDistributionConfig(&sv.StreamingDistributionConfig, nodeDecoder); err != nil { return err } 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 awsRestxml_deserializeDocumentStreamingDistributionAlreadyExists(v **types.StreamingDistributionAlreadyExists, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.StreamingDistributionAlreadyExists if *v == nil { sv = &types.StreamingDistributionAlreadyExists{} } 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 awsRestxml_deserializeDocumentStreamingDistributionConfig(v **types.StreamingDistributionConfig, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.StreamingDistributionConfig if *v == nil { sv = &types.StreamingDistributionConfig{} } 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("Aliases", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentAliases(&sv.Aliases, nodeDecoder); err != nil { return err } case strings.EqualFold("CallerReference", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.CallerReference = ptr.String(xtv) } case strings.EqualFold("Comment", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.Comment = ptr.String(xtv) } case strings.EqualFold("Enabled", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv, err := strconv.ParseBool(string(val)) if err != nil { return fmt.Errorf("expected boolean to be of type *bool, got %T instead", val) } sv.Enabled = ptr.Bool(xtv) } case strings.EqualFold("Logging", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentStreamingLoggingConfig(&sv.Logging, nodeDecoder); err != nil { return err } case strings.EqualFold("PriceClass", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.PriceClass = types.PriceClass(xtv) } case strings.EqualFold("S3Origin", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentS3Origin(&sv.S3Origin, nodeDecoder); err != nil { return err } case strings.EqualFold("TrustedSigners", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentTrustedSigners(&sv.TrustedSigners, nodeDecoder); err != nil { return err } 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 awsRestxml_deserializeDocumentStreamingDistributionList(v **types.StreamingDistributionList, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.StreamingDistributionList if *v == nil { sv = &types.StreamingDistributionList{} } 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("IsTruncated", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv, err := strconv.ParseBool(string(val)) if err != nil { return fmt.Errorf("expected boolean to be of type *bool, got %T instead", val) } sv.IsTruncated = ptr.Bool(xtv) } case strings.EqualFold("Items", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentStreamingDistributionSummaryList(&sv.Items, 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) } case strings.EqualFold("MaxItems", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) i64, err := strconv.ParseInt(xtv, 10, 64) if err != nil { return err } sv.MaxItems = ptr.Int32(int32(i64)) } case strings.EqualFold("NextMarker", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.NextMarker = ptr.String(xtv) } case strings.EqualFold("Quantity", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) i64, err := strconv.ParseInt(xtv, 10, 64) if err != nil { return err } sv.Quantity = ptr.Int32(int32(i64)) } 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 awsRestxml_deserializeDocumentStreamingDistributionNotDisabled(v **types.StreamingDistributionNotDisabled, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.StreamingDistributionNotDisabled if *v == nil { sv = &types.StreamingDistributionNotDisabled{} } 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 awsRestxml_deserializeDocumentStreamingDistributionSummary(v **types.StreamingDistributionSummary, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.StreamingDistributionSummary if *v == nil { sv = &types.StreamingDistributionSummary{} } 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("Aliases", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentAliases(&sv.Aliases, nodeDecoder); err != nil { return err } case strings.EqualFold("ARN", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.ARN = ptr.String(xtv) } case strings.EqualFold("Comment", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.Comment = ptr.String(xtv) } case strings.EqualFold("DomainName", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.DomainName = ptr.String(xtv) } case strings.EqualFold("Enabled", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv, err := strconv.ParseBool(string(val)) if err != nil { return fmt.Errorf("expected boolean to be of type *bool, got %T instead", val) } sv.Enabled = ptr.Bool(xtv) } case strings.EqualFold("Id", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.Id = ptr.String(xtv) } case strings.EqualFold("LastModifiedTime", 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.LastModifiedTime = ptr.Time(t) } case strings.EqualFold("PriceClass", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.PriceClass = types.PriceClass(xtv) } case strings.EqualFold("S3Origin", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentS3Origin(&sv.S3Origin, nodeDecoder); err != nil { return err } case strings.EqualFold("Status", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.Status = ptr.String(xtv) } case strings.EqualFold("TrustedSigners", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentTrustedSigners(&sv.TrustedSigners, nodeDecoder); err != nil { return err } 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 awsRestxml_deserializeDocumentStreamingDistributionSummaryList(v *[]types.StreamingDistributionSummary, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv []types.StreamingDistributionSummary if *v == nil { sv = make([]types.StreamingDistributionSummary, 0) } else { sv = *v } originalDecoder := decoder for { t, done, err := decoder.Token() if err != nil { return err } if done { break } switch { case strings.EqualFold("StreamingDistributionSummary", t.Name.Local): var col types.StreamingDistributionSummary nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) destAddr := &col if err := awsRestxml_deserializeDocumentStreamingDistributionSummary(&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 awsRestxml_deserializeDocumentStreamingDistributionSummaryListUnwrapped(v *[]types.StreamingDistributionSummary, decoder smithyxml.NodeDecoder) error { var sv []types.StreamingDistributionSummary if *v == nil { sv = make([]types.StreamingDistributionSummary, 0) } else { sv = *v } switch { default: var mv types.StreamingDistributionSummary t := decoder.StartEl _ = t nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) destAddr := &mv if err := awsRestxml_deserializeDocumentStreamingDistributionSummary(&destAddr, nodeDecoder); err != nil { return err } mv = *destAddr sv = append(sv, mv) } *v = sv return nil } func awsRestxml_deserializeDocumentStreamingLoggingConfig(v **types.StreamingLoggingConfig, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.StreamingLoggingConfig if *v == nil { sv = &types.StreamingLoggingConfig{} } 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("Bucket", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.Bucket = ptr.String(xtv) } case strings.EqualFold("Enabled", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv, err := strconv.ParseBool(string(val)) if err != nil { return fmt.Errorf("expected boolean to be of type *bool, got %T instead", val) } sv.Enabled = ptr.Bool(xtv) } case strings.EqualFold("Prefix", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.Prefix = 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 awsRestxml_deserializeDocumentTag(v **types.Tag, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.Tag if *v == nil { sv = &types.Tag{} } 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("Key", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.Key = ptr.String(xtv) } case strings.EqualFold("Value", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.Value = 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 awsRestxml_deserializeDocumentTagList(v *[]types.Tag, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv []types.Tag if *v == nil { sv = make([]types.Tag, 0) } else { sv = *v } originalDecoder := decoder for { t, done, err := decoder.Token() if err != nil { return err } if done { break } switch { case strings.EqualFold("Tag", t.Name.Local): var col types.Tag nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) destAddr := &col if err := awsRestxml_deserializeDocumentTag(&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 awsRestxml_deserializeDocumentTagListUnwrapped(v *[]types.Tag, decoder smithyxml.NodeDecoder) error { var sv []types.Tag if *v == nil { sv = make([]types.Tag, 0) } else { sv = *v } switch { default: var mv types.Tag t := decoder.StartEl _ = t nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) destAddr := &mv if err := awsRestxml_deserializeDocumentTag(&destAddr, nodeDecoder); err != nil { return err } mv = *destAddr sv = append(sv, mv) } *v = sv return nil } func awsRestxml_deserializeDocumentTags(v **types.Tags, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.Tags if *v == nil { sv = &types.Tags{} } 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("Items", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentTagList(&sv.Items, nodeDecoder); err != nil { return err } 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 awsRestxml_deserializeDocumentTestFunctionFailed(v **types.TestFunctionFailed, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.TestFunctionFailed if *v == nil { sv = &types.TestFunctionFailed{} } 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 awsRestxml_deserializeDocumentTestResult(v **types.TestResult, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.TestResult if *v == nil { sv = &types.TestResult{} } 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("ComputeUtilization", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.ComputeUtilization = ptr.String(xtv) } case strings.EqualFold("FunctionErrorMessage", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.FunctionErrorMessage = ptr.String(xtv) } case strings.EqualFold("FunctionExecutionLogs", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentFunctionExecutionLogList(&sv.FunctionExecutionLogs, nodeDecoder); err != nil { return err } case strings.EqualFold("FunctionOutput", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.FunctionOutput = ptr.String(xtv) } case strings.EqualFold("FunctionSummary", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentFunctionSummary(&sv.FunctionSummary, nodeDecoder); err != nil { return err } 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 awsRestxml_deserializeDocumentTooLongCSPInResponseHeadersPolicy(v **types.TooLongCSPInResponseHeadersPolicy, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.TooLongCSPInResponseHeadersPolicy if *v == nil { sv = &types.TooLongCSPInResponseHeadersPolicy{} } 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 awsRestxml_deserializeDocumentTooManyCacheBehaviors(v **types.TooManyCacheBehaviors, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.TooManyCacheBehaviors if *v == nil { sv = &types.TooManyCacheBehaviors{} } 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 awsRestxml_deserializeDocumentTooManyCachePolicies(v **types.TooManyCachePolicies, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.TooManyCachePolicies if *v == nil { sv = &types.TooManyCachePolicies{} } 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 awsRestxml_deserializeDocumentTooManyCertificates(v **types.TooManyCertificates, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.TooManyCertificates if *v == nil { sv = &types.TooManyCertificates{} } 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 awsRestxml_deserializeDocumentTooManyCloudFrontOriginAccessIdentities(v **types.TooManyCloudFrontOriginAccessIdentities, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.TooManyCloudFrontOriginAccessIdentities if *v == nil { sv = &types.TooManyCloudFrontOriginAccessIdentities{} } 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 awsRestxml_deserializeDocumentTooManyContinuousDeploymentPolicies(v **types.TooManyContinuousDeploymentPolicies, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.TooManyContinuousDeploymentPolicies if *v == nil { sv = &types.TooManyContinuousDeploymentPolicies{} } 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 awsRestxml_deserializeDocumentTooManyCookieNamesInWhiteList(v **types.TooManyCookieNamesInWhiteList, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.TooManyCookieNamesInWhiteList if *v == nil { sv = &types.TooManyCookieNamesInWhiteList{} } 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 awsRestxml_deserializeDocumentTooManyCookiesInCachePolicy(v **types.TooManyCookiesInCachePolicy, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.TooManyCookiesInCachePolicy if *v == nil { sv = &types.TooManyCookiesInCachePolicy{} } 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 awsRestxml_deserializeDocumentTooManyCookiesInOriginRequestPolicy(v **types.TooManyCookiesInOriginRequestPolicy, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.TooManyCookiesInOriginRequestPolicy if *v == nil { sv = &types.TooManyCookiesInOriginRequestPolicy{} } 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 awsRestxml_deserializeDocumentTooManyCustomHeadersInResponseHeadersPolicy(v **types.TooManyCustomHeadersInResponseHeadersPolicy, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.TooManyCustomHeadersInResponseHeadersPolicy if *v == nil { sv = &types.TooManyCustomHeadersInResponseHeadersPolicy{} } 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 awsRestxml_deserializeDocumentTooManyDistributionCNAMEs(v **types.TooManyDistributionCNAMEs, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.TooManyDistributionCNAMEs if *v == nil { sv = &types.TooManyDistributionCNAMEs{} } 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 awsRestxml_deserializeDocumentTooManyDistributions(v **types.TooManyDistributions, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.TooManyDistributions if *v == nil { sv = &types.TooManyDistributions{} } 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 awsRestxml_deserializeDocumentTooManyDistributionsAssociatedToCachePolicy(v **types.TooManyDistributionsAssociatedToCachePolicy, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.TooManyDistributionsAssociatedToCachePolicy if *v == nil { sv = &types.TooManyDistributionsAssociatedToCachePolicy{} } 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 awsRestxml_deserializeDocumentTooManyDistributionsAssociatedToFieldLevelEncryptionConfig(v **types.TooManyDistributionsAssociatedToFieldLevelEncryptionConfig, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.TooManyDistributionsAssociatedToFieldLevelEncryptionConfig if *v == nil { sv = &types.TooManyDistributionsAssociatedToFieldLevelEncryptionConfig{} } 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 awsRestxml_deserializeDocumentTooManyDistributionsAssociatedToKeyGroup(v **types.TooManyDistributionsAssociatedToKeyGroup, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.TooManyDistributionsAssociatedToKeyGroup if *v == nil { sv = &types.TooManyDistributionsAssociatedToKeyGroup{} } 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 awsRestxml_deserializeDocumentTooManyDistributionsAssociatedToOriginAccessControl(v **types.TooManyDistributionsAssociatedToOriginAccessControl, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.TooManyDistributionsAssociatedToOriginAccessControl if *v == nil { sv = &types.TooManyDistributionsAssociatedToOriginAccessControl{} } 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 awsRestxml_deserializeDocumentTooManyDistributionsAssociatedToOriginRequestPolicy(v **types.TooManyDistributionsAssociatedToOriginRequestPolicy, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.TooManyDistributionsAssociatedToOriginRequestPolicy if *v == nil { sv = &types.TooManyDistributionsAssociatedToOriginRequestPolicy{} } 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 awsRestxml_deserializeDocumentTooManyDistributionsAssociatedToResponseHeadersPolicy(v **types.TooManyDistributionsAssociatedToResponseHeadersPolicy, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.TooManyDistributionsAssociatedToResponseHeadersPolicy if *v == nil { sv = &types.TooManyDistributionsAssociatedToResponseHeadersPolicy{} } 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 awsRestxml_deserializeDocumentTooManyDistributionsWithFunctionAssociations(v **types.TooManyDistributionsWithFunctionAssociations, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.TooManyDistributionsWithFunctionAssociations if *v == nil { sv = &types.TooManyDistributionsWithFunctionAssociations{} } 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 awsRestxml_deserializeDocumentTooManyDistributionsWithLambdaAssociations(v **types.TooManyDistributionsWithLambdaAssociations, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.TooManyDistributionsWithLambdaAssociations if *v == nil { sv = &types.TooManyDistributionsWithLambdaAssociations{} } 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 awsRestxml_deserializeDocumentTooManyDistributionsWithSingleFunctionARN(v **types.TooManyDistributionsWithSingleFunctionARN, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.TooManyDistributionsWithSingleFunctionARN if *v == nil { sv = &types.TooManyDistributionsWithSingleFunctionARN{} } 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 awsRestxml_deserializeDocumentTooManyFieldLevelEncryptionConfigs(v **types.TooManyFieldLevelEncryptionConfigs, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.TooManyFieldLevelEncryptionConfigs if *v == nil { sv = &types.TooManyFieldLevelEncryptionConfigs{} } 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 awsRestxml_deserializeDocumentTooManyFieldLevelEncryptionContentTypeProfiles(v **types.TooManyFieldLevelEncryptionContentTypeProfiles, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.TooManyFieldLevelEncryptionContentTypeProfiles if *v == nil { sv = &types.TooManyFieldLevelEncryptionContentTypeProfiles{} } 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 awsRestxml_deserializeDocumentTooManyFieldLevelEncryptionEncryptionEntities(v **types.TooManyFieldLevelEncryptionEncryptionEntities, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.TooManyFieldLevelEncryptionEncryptionEntities if *v == nil { sv = &types.TooManyFieldLevelEncryptionEncryptionEntities{} } 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 awsRestxml_deserializeDocumentTooManyFieldLevelEncryptionFieldPatterns(v **types.TooManyFieldLevelEncryptionFieldPatterns, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.TooManyFieldLevelEncryptionFieldPatterns if *v == nil { sv = &types.TooManyFieldLevelEncryptionFieldPatterns{} } 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 awsRestxml_deserializeDocumentTooManyFieldLevelEncryptionProfiles(v **types.TooManyFieldLevelEncryptionProfiles, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.TooManyFieldLevelEncryptionProfiles if *v == nil { sv = &types.TooManyFieldLevelEncryptionProfiles{} } 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 awsRestxml_deserializeDocumentTooManyFieldLevelEncryptionQueryArgProfiles(v **types.TooManyFieldLevelEncryptionQueryArgProfiles, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.TooManyFieldLevelEncryptionQueryArgProfiles if *v == nil { sv = &types.TooManyFieldLevelEncryptionQueryArgProfiles{} } 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 awsRestxml_deserializeDocumentTooManyFunctionAssociations(v **types.TooManyFunctionAssociations, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.TooManyFunctionAssociations if *v == nil { sv = &types.TooManyFunctionAssociations{} } 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 awsRestxml_deserializeDocumentTooManyFunctions(v **types.TooManyFunctions, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.TooManyFunctions if *v == nil { sv = &types.TooManyFunctions{} } 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 awsRestxml_deserializeDocumentTooManyHeadersInCachePolicy(v **types.TooManyHeadersInCachePolicy, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.TooManyHeadersInCachePolicy if *v == nil { sv = &types.TooManyHeadersInCachePolicy{} } 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 awsRestxml_deserializeDocumentTooManyHeadersInForwardedValues(v **types.TooManyHeadersInForwardedValues, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.TooManyHeadersInForwardedValues if *v == nil { sv = &types.TooManyHeadersInForwardedValues{} } 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 awsRestxml_deserializeDocumentTooManyHeadersInOriginRequestPolicy(v **types.TooManyHeadersInOriginRequestPolicy, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.TooManyHeadersInOriginRequestPolicy if *v == nil { sv = &types.TooManyHeadersInOriginRequestPolicy{} } 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 awsRestxml_deserializeDocumentTooManyInvalidationsInProgress(v **types.TooManyInvalidationsInProgress, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.TooManyInvalidationsInProgress if *v == nil { sv = &types.TooManyInvalidationsInProgress{} } 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 awsRestxml_deserializeDocumentTooManyKeyGroups(v **types.TooManyKeyGroups, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.TooManyKeyGroups if *v == nil { sv = &types.TooManyKeyGroups{} } 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 awsRestxml_deserializeDocumentTooManyKeyGroupsAssociatedToDistribution(v **types.TooManyKeyGroupsAssociatedToDistribution, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.TooManyKeyGroupsAssociatedToDistribution if *v == nil { sv = &types.TooManyKeyGroupsAssociatedToDistribution{} } 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 awsRestxml_deserializeDocumentTooManyLambdaFunctionAssociations(v **types.TooManyLambdaFunctionAssociations, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.TooManyLambdaFunctionAssociations if *v == nil { sv = &types.TooManyLambdaFunctionAssociations{} } 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 awsRestxml_deserializeDocumentTooManyOriginAccessControls(v **types.TooManyOriginAccessControls, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.TooManyOriginAccessControls if *v == nil { sv = &types.TooManyOriginAccessControls{} } 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 awsRestxml_deserializeDocumentTooManyOriginCustomHeaders(v **types.TooManyOriginCustomHeaders, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.TooManyOriginCustomHeaders if *v == nil { sv = &types.TooManyOriginCustomHeaders{} } 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 awsRestxml_deserializeDocumentTooManyOriginGroupsPerDistribution(v **types.TooManyOriginGroupsPerDistribution, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.TooManyOriginGroupsPerDistribution if *v == nil { sv = &types.TooManyOriginGroupsPerDistribution{} } 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 awsRestxml_deserializeDocumentTooManyOriginRequestPolicies(v **types.TooManyOriginRequestPolicies, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.TooManyOriginRequestPolicies if *v == nil { sv = &types.TooManyOriginRequestPolicies{} } 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 awsRestxml_deserializeDocumentTooManyOrigins(v **types.TooManyOrigins, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.TooManyOrigins if *v == nil { sv = &types.TooManyOrigins{} } 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 awsRestxml_deserializeDocumentTooManyPublicKeys(v **types.TooManyPublicKeys, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.TooManyPublicKeys if *v == nil { sv = &types.TooManyPublicKeys{} } 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 awsRestxml_deserializeDocumentTooManyPublicKeysInKeyGroup(v **types.TooManyPublicKeysInKeyGroup, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.TooManyPublicKeysInKeyGroup if *v == nil { sv = &types.TooManyPublicKeysInKeyGroup{} } 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 awsRestxml_deserializeDocumentTooManyQueryStringParameters(v **types.TooManyQueryStringParameters, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.TooManyQueryStringParameters if *v == nil { sv = &types.TooManyQueryStringParameters{} } 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 awsRestxml_deserializeDocumentTooManyQueryStringsInCachePolicy(v **types.TooManyQueryStringsInCachePolicy, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.TooManyQueryStringsInCachePolicy if *v == nil { sv = &types.TooManyQueryStringsInCachePolicy{} } 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 awsRestxml_deserializeDocumentTooManyQueryStringsInOriginRequestPolicy(v **types.TooManyQueryStringsInOriginRequestPolicy, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.TooManyQueryStringsInOriginRequestPolicy if *v == nil { sv = &types.TooManyQueryStringsInOriginRequestPolicy{} } 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 awsRestxml_deserializeDocumentTooManyRealtimeLogConfigs(v **types.TooManyRealtimeLogConfigs, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.TooManyRealtimeLogConfigs if *v == nil { sv = &types.TooManyRealtimeLogConfigs{} } 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 awsRestxml_deserializeDocumentTooManyRemoveHeadersInResponseHeadersPolicy(v **types.TooManyRemoveHeadersInResponseHeadersPolicy, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.TooManyRemoveHeadersInResponseHeadersPolicy if *v == nil { sv = &types.TooManyRemoveHeadersInResponseHeadersPolicy{} } 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 awsRestxml_deserializeDocumentTooManyResponseHeadersPolicies(v **types.TooManyResponseHeadersPolicies, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.TooManyResponseHeadersPolicies if *v == nil { sv = &types.TooManyResponseHeadersPolicies{} } 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 awsRestxml_deserializeDocumentTooManyStreamingDistributionCNAMEs(v **types.TooManyStreamingDistributionCNAMEs, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.TooManyStreamingDistributionCNAMEs if *v == nil { sv = &types.TooManyStreamingDistributionCNAMEs{} } 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 awsRestxml_deserializeDocumentTooManyStreamingDistributions(v **types.TooManyStreamingDistributions, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.TooManyStreamingDistributions if *v == nil { sv = &types.TooManyStreamingDistributions{} } 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 awsRestxml_deserializeDocumentTooManyTrustedSigners(v **types.TooManyTrustedSigners, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.TooManyTrustedSigners if *v == nil { sv = &types.TooManyTrustedSigners{} } 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 awsRestxml_deserializeDocumentTrafficConfig(v **types.TrafficConfig, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.TrafficConfig if *v == nil { sv = &types.TrafficConfig{} } 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("SingleHeaderConfig", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentContinuousDeploymentSingleHeaderConfig(&sv.SingleHeaderConfig, nodeDecoder); err != nil { return err } case strings.EqualFold("SingleWeightConfig", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentContinuousDeploymentSingleWeightConfig(&sv.SingleWeightConfig, nodeDecoder); err != nil { return err } case strings.EqualFold("Type", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.Type = types.ContinuousDeploymentPolicyType(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 awsRestxml_deserializeDocumentTrustedKeyGroupDoesNotExist(v **types.TrustedKeyGroupDoesNotExist, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.TrustedKeyGroupDoesNotExist if *v == nil { sv = &types.TrustedKeyGroupDoesNotExist{} } 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 awsRestxml_deserializeDocumentTrustedKeyGroupIdList(v *[]string, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv []string if *v == nil { sv = make([]string, 0) } else { sv = *v } originalDecoder := decoder for { t, done, err := decoder.Token() if err != nil { return err } if done { break } memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) decoder = memberDecoder switch { case strings.EqualFold("KeyGroup", t.Name.Local): var col string val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) col = xtv } sv = append(sv, col) default: err = decoder.Decoder.Skip() if err != nil { return err } } decoder = originalDecoder } *v = sv return nil } func awsRestxml_deserializeDocumentTrustedKeyGroupIdListUnwrapped(v *[]string, decoder smithyxml.NodeDecoder) error { var sv []string if *v == nil { sv = make([]string, 0) } else { sv = *v } switch { default: var mv string t := decoder.StartEl _ = t val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) mv = xtv } sv = append(sv, mv) } *v = sv return nil } func awsRestxml_deserializeDocumentTrustedKeyGroups(v **types.TrustedKeyGroups, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.TrustedKeyGroups if *v == nil { sv = &types.TrustedKeyGroups{} } 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("Enabled", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv, err := strconv.ParseBool(string(val)) if err != nil { return fmt.Errorf("expected boolean to be of type *bool, got %T instead", val) } sv.Enabled = ptr.Bool(xtv) } case strings.EqualFold("Items", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentTrustedKeyGroupIdList(&sv.Items, nodeDecoder); err != nil { return err } case strings.EqualFold("Quantity", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) i64, err := strconv.ParseInt(xtv, 10, 64) if err != nil { return err } sv.Quantity = ptr.Int32(int32(i64)) } 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 awsRestxml_deserializeDocumentTrustedSignerDoesNotExist(v **types.TrustedSignerDoesNotExist, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.TrustedSignerDoesNotExist if *v == nil { sv = &types.TrustedSignerDoesNotExist{} } 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 awsRestxml_deserializeDocumentTrustedSigners(v **types.TrustedSigners, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.TrustedSigners if *v == nil { sv = &types.TrustedSigners{} } 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("Enabled", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv, err := strconv.ParseBool(string(val)) if err != nil { return fmt.Errorf("expected boolean to be of type *bool, got %T instead", val) } sv.Enabled = ptr.Bool(xtv) } case strings.EqualFold("Items", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsRestxml_deserializeDocumentAwsAccountNumberList(&sv.Items, nodeDecoder); err != nil { return err } case strings.EqualFold("Quantity", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) i64, err := strconv.ParseInt(xtv, 10, 64) if err != nil { return err } sv.Quantity = ptr.Int32(int32(i64)) } 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 awsRestxml_deserializeDocumentUnsupportedOperation(v **types.UnsupportedOperation, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.UnsupportedOperation if *v == nil { sv = &types.UnsupportedOperation{} } 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 awsRestxml_deserializeDocumentViewerCertificate(v **types.ViewerCertificate, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } var sv *types.ViewerCertificate if *v == nil { sv = &types.ViewerCertificate{} } 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("ACMCertificateArn", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.ACMCertificateArn = ptr.String(xtv) } case strings.EqualFold("Certificate", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.Certificate = ptr.String(xtv) } case strings.EqualFold("CertificateSource", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.CertificateSource = types.CertificateSource(xtv) } case strings.EqualFold("CloudFrontDefaultCertificate", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv, err := strconv.ParseBool(string(val)) if err != nil { return fmt.Errorf("expected boolean to be of type *bool, got %T instead", val) } sv.CloudFrontDefaultCertificate = ptr.Bool(xtv) } case strings.EqualFold("IAMCertificateId", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.IAMCertificateId = ptr.String(xtv) } case strings.EqualFold("MinimumProtocolVersion", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.MinimumProtocolVersion = types.MinimumProtocolVersion(xtv) } case strings.EqualFold("SSLSupportMethod", t.Name.Local): val, err := decoder.Value() if err != nil { return err } if val == nil { break } { xtv := string(val) sv.SSLSupportMethod = types.SSLSupportMethod(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 }