service/apprunner/deserializers.go (7,821 lines of code) (raw):
// Code generated by smithy-go-codegen DO NOT EDIT.
package apprunner
import (
"bytes"
"context"
"encoding/json"
"fmt"
"github.com/aws/aws-sdk-go-v2/aws/protocol/restjson"
"github.com/aws/aws-sdk-go-v2/service/apprunner/types"
smithy "github.com/aws/smithy-go"
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"
"github.com/aws/smithy-go/tracing"
smithyhttp "github.com/aws/smithy-go/transport/http"
"io"
"strings"
"time"
)
func deserializeS3Expires(v string) (*time.Time, error) {
t, err := smithytime.ParseHTTPDate(v)
if err != nil {
return nil, nil
}
return &t, nil
}
type awsAwsjson10_deserializeOpAssociateCustomDomain struct {
}
func (*awsAwsjson10_deserializeOpAssociateCustomDomain) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson10_deserializeOpAssociateCustomDomain) 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
}
_, span := tracing.StartSpan(ctx, "OperationDeserializer")
endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
defer endTimer()
defer span.End()
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, awsAwsjson10_deserializeOpErrorAssociateCustomDomain(response, &metadata)
}
output := &AssociateCustomDomainOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsAwsjson10_deserializeOpDocumentAssociateCustomDomainOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
return out, metadata, err
}
func awsAwsjson10_deserializeOpErrorAssociateCustomDomain(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
bodyInfo, err := getProtocolErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
errorCode = restjson.SanitizeErrorCode(typ)
}
if len(bodyInfo.Message) != 0 {
errorMessage = bodyInfo.Message
}
switch {
case strings.EqualFold("InternalServiceErrorException", errorCode):
return awsAwsjson10_deserializeErrorInternalServiceErrorException(response, errorBody)
case strings.EqualFold("InvalidRequestException", errorCode):
return awsAwsjson10_deserializeErrorInvalidRequestException(response, errorBody)
case strings.EqualFold("InvalidStateException", errorCode):
return awsAwsjson10_deserializeErrorInvalidStateException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson10_deserializeOpCreateAutoScalingConfiguration struct {
}
func (*awsAwsjson10_deserializeOpCreateAutoScalingConfiguration) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson10_deserializeOpCreateAutoScalingConfiguration) 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
}
_, span := tracing.StartSpan(ctx, "OperationDeserializer")
endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
defer endTimer()
defer span.End()
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, awsAwsjson10_deserializeOpErrorCreateAutoScalingConfiguration(response, &metadata)
}
output := &CreateAutoScalingConfigurationOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsAwsjson10_deserializeOpDocumentCreateAutoScalingConfigurationOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
return out, metadata, err
}
func awsAwsjson10_deserializeOpErrorCreateAutoScalingConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
bodyInfo, err := getProtocolErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
errorCode = restjson.SanitizeErrorCode(typ)
}
if len(bodyInfo.Message) != 0 {
errorMessage = bodyInfo.Message
}
switch {
case strings.EqualFold("InternalServiceErrorException", errorCode):
return awsAwsjson10_deserializeErrorInternalServiceErrorException(response, errorBody)
case strings.EqualFold("InvalidRequestException", errorCode):
return awsAwsjson10_deserializeErrorInvalidRequestException(response, errorBody)
case strings.EqualFold("ServiceQuotaExceededException", errorCode):
return awsAwsjson10_deserializeErrorServiceQuotaExceededException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson10_deserializeOpCreateConnection struct {
}
func (*awsAwsjson10_deserializeOpCreateConnection) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson10_deserializeOpCreateConnection) 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
}
_, span := tracing.StartSpan(ctx, "OperationDeserializer")
endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
defer endTimer()
defer span.End()
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, awsAwsjson10_deserializeOpErrorCreateConnection(response, &metadata)
}
output := &CreateConnectionOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsAwsjson10_deserializeOpDocumentCreateConnectionOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
return out, metadata, err
}
func awsAwsjson10_deserializeOpErrorCreateConnection(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
bodyInfo, err := getProtocolErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
errorCode = restjson.SanitizeErrorCode(typ)
}
if len(bodyInfo.Message) != 0 {
errorMessage = bodyInfo.Message
}
switch {
case strings.EqualFold("InternalServiceErrorException", errorCode):
return awsAwsjson10_deserializeErrorInternalServiceErrorException(response, errorBody)
case strings.EqualFold("InvalidRequestException", errorCode):
return awsAwsjson10_deserializeErrorInvalidRequestException(response, errorBody)
case strings.EqualFold("ServiceQuotaExceededException", errorCode):
return awsAwsjson10_deserializeErrorServiceQuotaExceededException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson10_deserializeOpCreateObservabilityConfiguration struct {
}
func (*awsAwsjson10_deserializeOpCreateObservabilityConfiguration) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson10_deserializeOpCreateObservabilityConfiguration) 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
}
_, span := tracing.StartSpan(ctx, "OperationDeserializer")
endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
defer endTimer()
defer span.End()
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, awsAwsjson10_deserializeOpErrorCreateObservabilityConfiguration(response, &metadata)
}
output := &CreateObservabilityConfigurationOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsAwsjson10_deserializeOpDocumentCreateObservabilityConfigurationOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
return out, metadata, err
}
func awsAwsjson10_deserializeOpErrorCreateObservabilityConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
bodyInfo, err := getProtocolErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
errorCode = restjson.SanitizeErrorCode(typ)
}
if len(bodyInfo.Message) != 0 {
errorMessage = bodyInfo.Message
}
switch {
case strings.EqualFold("InternalServiceErrorException", errorCode):
return awsAwsjson10_deserializeErrorInternalServiceErrorException(response, errorBody)
case strings.EqualFold("InvalidRequestException", errorCode):
return awsAwsjson10_deserializeErrorInvalidRequestException(response, errorBody)
case strings.EqualFold("ServiceQuotaExceededException", errorCode):
return awsAwsjson10_deserializeErrorServiceQuotaExceededException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson10_deserializeOpCreateService struct {
}
func (*awsAwsjson10_deserializeOpCreateService) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson10_deserializeOpCreateService) 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
}
_, span := tracing.StartSpan(ctx, "OperationDeserializer")
endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
defer endTimer()
defer span.End()
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, awsAwsjson10_deserializeOpErrorCreateService(response, &metadata)
}
output := &CreateServiceOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsAwsjson10_deserializeOpDocumentCreateServiceOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
return out, metadata, err
}
func awsAwsjson10_deserializeOpErrorCreateService(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
bodyInfo, err := getProtocolErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
errorCode = restjson.SanitizeErrorCode(typ)
}
if len(bodyInfo.Message) != 0 {
errorMessage = bodyInfo.Message
}
switch {
case strings.EqualFold("InternalServiceErrorException", errorCode):
return awsAwsjson10_deserializeErrorInternalServiceErrorException(response, errorBody)
case strings.EqualFold("InvalidRequestException", errorCode):
return awsAwsjson10_deserializeErrorInvalidRequestException(response, errorBody)
case strings.EqualFold("ServiceQuotaExceededException", errorCode):
return awsAwsjson10_deserializeErrorServiceQuotaExceededException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson10_deserializeOpCreateVpcConnector struct {
}
func (*awsAwsjson10_deserializeOpCreateVpcConnector) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson10_deserializeOpCreateVpcConnector) 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
}
_, span := tracing.StartSpan(ctx, "OperationDeserializer")
endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
defer endTimer()
defer span.End()
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, awsAwsjson10_deserializeOpErrorCreateVpcConnector(response, &metadata)
}
output := &CreateVpcConnectorOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsAwsjson10_deserializeOpDocumentCreateVpcConnectorOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
return out, metadata, err
}
func awsAwsjson10_deserializeOpErrorCreateVpcConnector(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
bodyInfo, err := getProtocolErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
errorCode = restjson.SanitizeErrorCode(typ)
}
if len(bodyInfo.Message) != 0 {
errorMessage = bodyInfo.Message
}
switch {
case strings.EqualFold("InternalServiceErrorException", errorCode):
return awsAwsjson10_deserializeErrorInternalServiceErrorException(response, errorBody)
case strings.EqualFold("InvalidRequestException", errorCode):
return awsAwsjson10_deserializeErrorInvalidRequestException(response, errorBody)
case strings.EqualFold("ServiceQuotaExceededException", errorCode):
return awsAwsjson10_deserializeErrorServiceQuotaExceededException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson10_deserializeOpCreateVpcIngressConnection struct {
}
func (*awsAwsjson10_deserializeOpCreateVpcIngressConnection) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson10_deserializeOpCreateVpcIngressConnection) 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
}
_, span := tracing.StartSpan(ctx, "OperationDeserializer")
endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
defer endTimer()
defer span.End()
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, awsAwsjson10_deserializeOpErrorCreateVpcIngressConnection(response, &metadata)
}
output := &CreateVpcIngressConnectionOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsAwsjson10_deserializeOpDocumentCreateVpcIngressConnectionOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
return out, metadata, err
}
func awsAwsjson10_deserializeOpErrorCreateVpcIngressConnection(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
bodyInfo, err := getProtocolErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
errorCode = restjson.SanitizeErrorCode(typ)
}
if len(bodyInfo.Message) != 0 {
errorMessage = bodyInfo.Message
}
switch {
case strings.EqualFold("InternalServiceErrorException", errorCode):
return awsAwsjson10_deserializeErrorInternalServiceErrorException(response, errorBody)
case strings.EqualFold("InvalidRequestException", errorCode):
return awsAwsjson10_deserializeErrorInvalidRequestException(response, errorBody)
case strings.EqualFold("InvalidStateException", errorCode):
return awsAwsjson10_deserializeErrorInvalidStateException(response, errorBody)
case strings.EqualFold("ServiceQuotaExceededException", errorCode):
return awsAwsjson10_deserializeErrorServiceQuotaExceededException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson10_deserializeOpDeleteAutoScalingConfiguration struct {
}
func (*awsAwsjson10_deserializeOpDeleteAutoScalingConfiguration) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson10_deserializeOpDeleteAutoScalingConfiguration) 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
}
_, span := tracing.StartSpan(ctx, "OperationDeserializer")
endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
defer endTimer()
defer span.End()
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, awsAwsjson10_deserializeOpErrorDeleteAutoScalingConfiguration(response, &metadata)
}
output := &DeleteAutoScalingConfigurationOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsAwsjson10_deserializeOpDocumentDeleteAutoScalingConfigurationOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
return out, metadata, err
}
func awsAwsjson10_deserializeOpErrorDeleteAutoScalingConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
bodyInfo, err := getProtocolErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
errorCode = restjson.SanitizeErrorCode(typ)
}
if len(bodyInfo.Message) != 0 {
errorMessage = bodyInfo.Message
}
switch {
case strings.EqualFold("InternalServiceErrorException", errorCode):
return awsAwsjson10_deserializeErrorInternalServiceErrorException(response, errorBody)
case strings.EqualFold("InvalidRequestException", errorCode):
return awsAwsjson10_deserializeErrorInvalidRequestException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsAwsjson10_deserializeErrorResourceNotFoundException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson10_deserializeOpDeleteConnection struct {
}
func (*awsAwsjson10_deserializeOpDeleteConnection) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson10_deserializeOpDeleteConnection) 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
}
_, span := tracing.StartSpan(ctx, "OperationDeserializer")
endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
defer endTimer()
defer span.End()
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, awsAwsjson10_deserializeOpErrorDeleteConnection(response, &metadata)
}
output := &DeleteConnectionOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsAwsjson10_deserializeOpDocumentDeleteConnectionOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
return out, metadata, err
}
func awsAwsjson10_deserializeOpErrorDeleteConnection(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
bodyInfo, err := getProtocolErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
errorCode = restjson.SanitizeErrorCode(typ)
}
if len(bodyInfo.Message) != 0 {
errorMessage = bodyInfo.Message
}
switch {
case strings.EqualFold("InternalServiceErrorException", errorCode):
return awsAwsjson10_deserializeErrorInternalServiceErrorException(response, errorBody)
case strings.EqualFold("InvalidRequestException", errorCode):
return awsAwsjson10_deserializeErrorInvalidRequestException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsAwsjson10_deserializeErrorResourceNotFoundException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson10_deserializeOpDeleteObservabilityConfiguration struct {
}
func (*awsAwsjson10_deserializeOpDeleteObservabilityConfiguration) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson10_deserializeOpDeleteObservabilityConfiguration) 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
}
_, span := tracing.StartSpan(ctx, "OperationDeserializer")
endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
defer endTimer()
defer span.End()
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, awsAwsjson10_deserializeOpErrorDeleteObservabilityConfiguration(response, &metadata)
}
output := &DeleteObservabilityConfigurationOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsAwsjson10_deserializeOpDocumentDeleteObservabilityConfigurationOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
return out, metadata, err
}
func awsAwsjson10_deserializeOpErrorDeleteObservabilityConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
bodyInfo, err := getProtocolErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
errorCode = restjson.SanitizeErrorCode(typ)
}
if len(bodyInfo.Message) != 0 {
errorMessage = bodyInfo.Message
}
switch {
case strings.EqualFold("InternalServiceErrorException", errorCode):
return awsAwsjson10_deserializeErrorInternalServiceErrorException(response, errorBody)
case strings.EqualFold("InvalidRequestException", errorCode):
return awsAwsjson10_deserializeErrorInvalidRequestException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsAwsjson10_deserializeErrorResourceNotFoundException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson10_deserializeOpDeleteService struct {
}
func (*awsAwsjson10_deserializeOpDeleteService) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson10_deserializeOpDeleteService) 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
}
_, span := tracing.StartSpan(ctx, "OperationDeserializer")
endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
defer endTimer()
defer span.End()
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, awsAwsjson10_deserializeOpErrorDeleteService(response, &metadata)
}
output := &DeleteServiceOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsAwsjson10_deserializeOpDocumentDeleteServiceOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
return out, metadata, err
}
func awsAwsjson10_deserializeOpErrorDeleteService(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
bodyInfo, err := getProtocolErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
errorCode = restjson.SanitizeErrorCode(typ)
}
if len(bodyInfo.Message) != 0 {
errorMessage = bodyInfo.Message
}
switch {
case strings.EqualFold("InternalServiceErrorException", errorCode):
return awsAwsjson10_deserializeErrorInternalServiceErrorException(response, errorBody)
case strings.EqualFold("InvalidRequestException", errorCode):
return awsAwsjson10_deserializeErrorInvalidRequestException(response, errorBody)
case strings.EqualFold("InvalidStateException", errorCode):
return awsAwsjson10_deserializeErrorInvalidStateException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsAwsjson10_deserializeErrorResourceNotFoundException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson10_deserializeOpDeleteVpcConnector struct {
}
func (*awsAwsjson10_deserializeOpDeleteVpcConnector) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson10_deserializeOpDeleteVpcConnector) 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
}
_, span := tracing.StartSpan(ctx, "OperationDeserializer")
endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
defer endTimer()
defer span.End()
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, awsAwsjson10_deserializeOpErrorDeleteVpcConnector(response, &metadata)
}
output := &DeleteVpcConnectorOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsAwsjson10_deserializeOpDocumentDeleteVpcConnectorOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
return out, metadata, err
}
func awsAwsjson10_deserializeOpErrorDeleteVpcConnector(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
bodyInfo, err := getProtocolErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
errorCode = restjson.SanitizeErrorCode(typ)
}
if len(bodyInfo.Message) != 0 {
errorMessage = bodyInfo.Message
}
switch {
case strings.EqualFold("InternalServiceErrorException", errorCode):
return awsAwsjson10_deserializeErrorInternalServiceErrorException(response, errorBody)
case strings.EqualFold("InvalidRequestException", errorCode):
return awsAwsjson10_deserializeErrorInvalidRequestException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsAwsjson10_deserializeErrorResourceNotFoundException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson10_deserializeOpDeleteVpcIngressConnection struct {
}
func (*awsAwsjson10_deserializeOpDeleteVpcIngressConnection) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson10_deserializeOpDeleteVpcIngressConnection) 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
}
_, span := tracing.StartSpan(ctx, "OperationDeserializer")
endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
defer endTimer()
defer span.End()
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, awsAwsjson10_deserializeOpErrorDeleteVpcIngressConnection(response, &metadata)
}
output := &DeleteVpcIngressConnectionOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsAwsjson10_deserializeOpDocumentDeleteVpcIngressConnectionOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
return out, metadata, err
}
func awsAwsjson10_deserializeOpErrorDeleteVpcIngressConnection(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
bodyInfo, err := getProtocolErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
errorCode = restjson.SanitizeErrorCode(typ)
}
if len(bodyInfo.Message) != 0 {
errorMessage = bodyInfo.Message
}
switch {
case strings.EqualFold("InternalServiceErrorException", errorCode):
return awsAwsjson10_deserializeErrorInternalServiceErrorException(response, errorBody)
case strings.EqualFold("InvalidRequestException", errorCode):
return awsAwsjson10_deserializeErrorInvalidRequestException(response, errorBody)
case strings.EqualFold("InvalidStateException", errorCode):
return awsAwsjson10_deserializeErrorInvalidStateException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsAwsjson10_deserializeErrorResourceNotFoundException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson10_deserializeOpDescribeAutoScalingConfiguration struct {
}
func (*awsAwsjson10_deserializeOpDescribeAutoScalingConfiguration) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson10_deserializeOpDescribeAutoScalingConfiguration) 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
}
_, span := tracing.StartSpan(ctx, "OperationDeserializer")
endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
defer endTimer()
defer span.End()
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, awsAwsjson10_deserializeOpErrorDescribeAutoScalingConfiguration(response, &metadata)
}
output := &DescribeAutoScalingConfigurationOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsAwsjson10_deserializeOpDocumentDescribeAutoScalingConfigurationOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
return out, metadata, err
}
func awsAwsjson10_deserializeOpErrorDescribeAutoScalingConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
bodyInfo, err := getProtocolErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
errorCode = restjson.SanitizeErrorCode(typ)
}
if len(bodyInfo.Message) != 0 {
errorMessage = bodyInfo.Message
}
switch {
case strings.EqualFold("InternalServiceErrorException", errorCode):
return awsAwsjson10_deserializeErrorInternalServiceErrorException(response, errorBody)
case strings.EqualFold("InvalidRequestException", errorCode):
return awsAwsjson10_deserializeErrorInvalidRequestException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsAwsjson10_deserializeErrorResourceNotFoundException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson10_deserializeOpDescribeCustomDomains struct {
}
func (*awsAwsjson10_deserializeOpDescribeCustomDomains) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson10_deserializeOpDescribeCustomDomains) 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
}
_, span := tracing.StartSpan(ctx, "OperationDeserializer")
endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
defer endTimer()
defer span.End()
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, awsAwsjson10_deserializeOpErrorDescribeCustomDomains(response, &metadata)
}
output := &DescribeCustomDomainsOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsAwsjson10_deserializeOpDocumentDescribeCustomDomainsOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
return out, metadata, err
}
func awsAwsjson10_deserializeOpErrorDescribeCustomDomains(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
bodyInfo, err := getProtocolErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
errorCode = restjson.SanitizeErrorCode(typ)
}
if len(bodyInfo.Message) != 0 {
errorMessage = bodyInfo.Message
}
switch {
case strings.EqualFold("InternalServiceErrorException", errorCode):
return awsAwsjson10_deserializeErrorInternalServiceErrorException(response, errorBody)
case strings.EqualFold("InvalidRequestException", errorCode):
return awsAwsjson10_deserializeErrorInvalidRequestException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsAwsjson10_deserializeErrorResourceNotFoundException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson10_deserializeOpDescribeObservabilityConfiguration struct {
}
func (*awsAwsjson10_deserializeOpDescribeObservabilityConfiguration) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson10_deserializeOpDescribeObservabilityConfiguration) 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
}
_, span := tracing.StartSpan(ctx, "OperationDeserializer")
endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
defer endTimer()
defer span.End()
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, awsAwsjson10_deserializeOpErrorDescribeObservabilityConfiguration(response, &metadata)
}
output := &DescribeObservabilityConfigurationOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsAwsjson10_deserializeOpDocumentDescribeObservabilityConfigurationOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
return out, metadata, err
}
func awsAwsjson10_deserializeOpErrorDescribeObservabilityConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
bodyInfo, err := getProtocolErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
errorCode = restjson.SanitizeErrorCode(typ)
}
if len(bodyInfo.Message) != 0 {
errorMessage = bodyInfo.Message
}
switch {
case strings.EqualFold("InternalServiceErrorException", errorCode):
return awsAwsjson10_deserializeErrorInternalServiceErrorException(response, errorBody)
case strings.EqualFold("InvalidRequestException", errorCode):
return awsAwsjson10_deserializeErrorInvalidRequestException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsAwsjson10_deserializeErrorResourceNotFoundException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson10_deserializeOpDescribeService struct {
}
func (*awsAwsjson10_deserializeOpDescribeService) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson10_deserializeOpDescribeService) 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
}
_, span := tracing.StartSpan(ctx, "OperationDeserializer")
endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
defer endTimer()
defer span.End()
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, awsAwsjson10_deserializeOpErrorDescribeService(response, &metadata)
}
output := &DescribeServiceOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsAwsjson10_deserializeOpDocumentDescribeServiceOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
return out, metadata, err
}
func awsAwsjson10_deserializeOpErrorDescribeService(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
bodyInfo, err := getProtocolErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
errorCode = restjson.SanitizeErrorCode(typ)
}
if len(bodyInfo.Message) != 0 {
errorMessage = bodyInfo.Message
}
switch {
case strings.EqualFold("InternalServiceErrorException", errorCode):
return awsAwsjson10_deserializeErrorInternalServiceErrorException(response, errorBody)
case strings.EqualFold("InvalidRequestException", errorCode):
return awsAwsjson10_deserializeErrorInvalidRequestException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsAwsjson10_deserializeErrorResourceNotFoundException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson10_deserializeOpDescribeVpcConnector struct {
}
func (*awsAwsjson10_deserializeOpDescribeVpcConnector) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson10_deserializeOpDescribeVpcConnector) 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
}
_, span := tracing.StartSpan(ctx, "OperationDeserializer")
endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
defer endTimer()
defer span.End()
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, awsAwsjson10_deserializeOpErrorDescribeVpcConnector(response, &metadata)
}
output := &DescribeVpcConnectorOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsAwsjson10_deserializeOpDocumentDescribeVpcConnectorOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
return out, metadata, err
}
func awsAwsjson10_deserializeOpErrorDescribeVpcConnector(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
bodyInfo, err := getProtocolErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
errorCode = restjson.SanitizeErrorCode(typ)
}
if len(bodyInfo.Message) != 0 {
errorMessage = bodyInfo.Message
}
switch {
case strings.EqualFold("InternalServiceErrorException", errorCode):
return awsAwsjson10_deserializeErrorInternalServiceErrorException(response, errorBody)
case strings.EqualFold("InvalidRequestException", errorCode):
return awsAwsjson10_deserializeErrorInvalidRequestException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsAwsjson10_deserializeErrorResourceNotFoundException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson10_deserializeOpDescribeVpcIngressConnection struct {
}
func (*awsAwsjson10_deserializeOpDescribeVpcIngressConnection) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson10_deserializeOpDescribeVpcIngressConnection) 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
}
_, span := tracing.StartSpan(ctx, "OperationDeserializer")
endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
defer endTimer()
defer span.End()
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, awsAwsjson10_deserializeOpErrorDescribeVpcIngressConnection(response, &metadata)
}
output := &DescribeVpcIngressConnectionOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsAwsjson10_deserializeOpDocumentDescribeVpcIngressConnectionOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
return out, metadata, err
}
func awsAwsjson10_deserializeOpErrorDescribeVpcIngressConnection(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
bodyInfo, err := getProtocolErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
errorCode = restjson.SanitizeErrorCode(typ)
}
if len(bodyInfo.Message) != 0 {
errorMessage = bodyInfo.Message
}
switch {
case strings.EqualFold("InternalServiceErrorException", errorCode):
return awsAwsjson10_deserializeErrorInternalServiceErrorException(response, errorBody)
case strings.EqualFold("InvalidRequestException", errorCode):
return awsAwsjson10_deserializeErrorInvalidRequestException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsAwsjson10_deserializeErrorResourceNotFoundException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson10_deserializeOpDisassociateCustomDomain struct {
}
func (*awsAwsjson10_deserializeOpDisassociateCustomDomain) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson10_deserializeOpDisassociateCustomDomain) 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
}
_, span := tracing.StartSpan(ctx, "OperationDeserializer")
endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
defer endTimer()
defer span.End()
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, awsAwsjson10_deserializeOpErrorDisassociateCustomDomain(response, &metadata)
}
output := &DisassociateCustomDomainOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsAwsjson10_deserializeOpDocumentDisassociateCustomDomainOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
return out, metadata, err
}
func awsAwsjson10_deserializeOpErrorDisassociateCustomDomain(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
bodyInfo, err := getProtocolErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
errorCode = restjson.SanitizeErrorCode(typ)
}
if len(bodyInfo.Message) != 0 {
errorMessage = bodyInfo.Message
}
switch {
case strings.EqualFold("InternalServiceErrorException", errorCode):
return awsAwsjson10_deserializeErrorInternalServiceErrorException(response, errorBody)
case strings.EqualFold("InvalidRequestException", errorCode):
return awsAwsjson10_deserializeErrorInvalidRequestException(response, errorBody)
case strings.EqualFold("InvalidStateException", errorCode):
return awsAwsjson10_deserializeErrorInvalidStateException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsAwsjson10_deserializeErrorResourceNotFoundException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson10_deserializeOpListAutoScalingConfigurations struct {
}
func (*awsAwsjson10_deserializeOpListAutoScalingConfigurations) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson10_deserializeOpListAutoScalingConfigurations) 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
}
_, span := tracing.StartSpan(ctx, "OperationDeserializer")
endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
defer endTimer()
defer span.End()
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, awsAwsjson10_deserializeOpErrorListAutoScalingConfigurations(response, &metadata)
}
output := &ListAutoScalingConfigurationsOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsAwsjson10_deserializeOpDocumentListAutoScalingConfigurationsOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
return out, metadata, err
}
func awsAwsjson10_deserializeOpErrorListAutoScalingConfigurations(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
bodyInfo, err := getProtocolErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
errorCode = restjson.SanitizeErrorCode(typ)
}
if len(bodyInfo.Message) != 0 {
errorMessage = bodyInfo.Message
}
switch {
case strings.EqualFold("InternalServiceErrorException", errorCode):
return awsAwsjson10_deserializeErrorInternalServiceErrorException(response, errorBody)
case strings.EqualFold("InvalidRequestException", errorCode):
return awsAwsjson10_deserializeErrorInvalidRequestException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson10_deserializeOpListConnections struct {
}
func (*awsAwsjson10_deserializeOpListConnections) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson10_deserializeOpListConnections) 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
}
_, span := tracing.StartSpan(ctx, "OperationDeserializer")
endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
defer endTimer()
defer span.End()
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, awsAwsjson10_deserializeOpErrorListConnections(response, &metadata)
}
output := &ListConnectionsOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsAwsjson10_deserializeOpDocumentListConnectionsOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
return out, metadata, err
}
func awsAwsjson10_deserializeOpErrorListConnections(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
bodyInfo, err := getProtocolErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
errorCode = restjson.SanitizeErrorCode(typ)
}
if len(bodyInfo.Message) != 0 {
errorMessage = bodyInfo.Message
}
switch {
case strings.EqualFold("InternalServiceErrorException", errorCode):
return awsAwsjson10_deserializeErrorInternalServiceErrorException(response, errorBody)
case strings.EqualFold("InvalidRequestException", errorCode):
return awsAwsjson10_deserializeErrorInvalidRequestException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson10_deserializeOpListObservabilityConfigurations struct {
}
func (*awsAwsjson10_deserializeOpListObservabilityConfigurations) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson10_deserializeOpListObservabilityConfigurations) 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
}
_, span := tracing.StartSpan(ctx, "OperationDeserializer")
endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
defer endTimer()
defer span.End()
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, awsAwsjson10_deserializeOpErrorListObservabilityConfigurations(response, &metadata)
}
output := &ListObservabilityConfigurationsOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsAwsjson10_deserializeOpDocumentListObservabilityConfigurationsOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
return out, metadata, err
}
func awsAwsjson10_deserializeOpErrorListObservabilityConfigurations(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
bodyInfo, err := getProtocolErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
errorCode = restjson.SanitizeErrorCode(typ)
}
if len(bodyInfo.Message) != 0 {
errorMessage = bodyInfo.Message
}
switch {
case strings.EqualFold("InternalServiceErrorException", errorCode):
return awsAwsjson10_deserializeErrorInternalServiceErrorException(response, errorBody)
case strings.EqualFold("InvalidRequestException", errorCode):
return awsAwsjson10_deserializeErrorInvalidRequestException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson10_deserializeOpListOperations struct {
}
func (*awsAwsjson10_deserializeOpListOperations) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson10_deserializeOpListOperations) 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
}
_, span := tracing.StartSpan(ctx, "OperationDeserializer")
endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
defer endTimer()
defer span.End()
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, awsAwsjson10_deserializeOpErrorListOperations(response, &metadata)
}
output := &ListOperationsOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsAwsjson10_deserializeOpDocumentListOperationsOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
return out, metadata, err
}
func awsAwsjson10_deserializeOpErrorListOperations(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
bodyInfo, err := getProtocolErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
errorCode = restjson.SanitizeErrorCode(typ)
}
if len(bodyInfo.Message) != 0 {
errorMessage = bodyInfo.Message
}
switch {
case strings.EqualFold("InternalServiceErrorException", errorCode):
return awsAwsjson10_deserializeErrorInternalServiceErrorException(response, errorBody)
case strings.EqualFold("InvalidRequestException", errorCode):
return awsAwsjson10_deserializeErrorInvalidRequestException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsAwsjson10_deserializeErrorResourceNotFoundException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson10_deserializeOpListServices struct {
}
func (*awsAwsjson10_deserializeOpListServices) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson10_deserializeOpListServices) 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
}
_, span := tracing.StartSpan(ctx, "OperationDeserializer")
endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
defer endTimer()
defer span.End()
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, awsAwsjson10_deserializeOpErrorListServices(response, &metadata)
}
output := &ListServicesOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsAwsjson10_deserializeOpDocumentListServicesOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
return out, metadata, err
}
func awsAwsjson10_deserializeOpErrorListServices(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
bodyInfo, err := getProtocolErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
errorCode = restjson.SanitizeErrorCode(typ)
}
if len(bodyInfo.Message) != 0 {
errorMessage = bodyInfo.Message
}
switch {
case strings.EqualFold("InternalServiceErrorException", errorCode):
return awsAwsjson10_deserializeErrorInternalServiceErrorException(response, errorBody)
case strings.EqualFold("InvalidRequestException", errorCode):
return awsAwsjson10_deserializeErrorInvalidRequestException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson10_deserializeOpListServicesForAutoScalingConfiguration struct {
}
func (*awsAwsjson10_deserializeOpListServicesForAutoScalingConfiguration) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson10_deserializeOpListServicesForAutoScalingConfiguration) 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
}
_, span := tracing.StartSpan(ctx, "OperationDeserializer")
endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
defer endTimer()
defer span.End()
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, awsAwsjson10_deserializeOpErrorListServicesForAutoScalingConfiguration(response, &metadata)
}
output := &ListServicesForAutoScalingConfigurationOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsAwsjson10_deserializeOpDocumentListServicesForAutoScalingConfigurationOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
return out, metadata, err
}
func awsAwsjson10_deserializeOpErrorListServicesForAutoScalingConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
bodyInfo, err := getProtocolErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
errorCode = restjson.SanitizeErrorCode(typ)
}
if len(bodyInfo.Message) != 0 {
errorMessage = bodyInfo.Message
}
switch {
case strings.EqualFold("InternalServiceErrorException", errorCode):
return awsAwsjson10_deserializeErrorInternalServiceErrorException(response, errorBody)
case strings.EqualFold("InvalidRequestException", errorCode):
return awsAwsjson10_deserializeErrorInvalidRequestException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsAwsjson10_deserializeErrorResourceNotFoundException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson10_deserializeOpListTagsForResource struct {
}
func (*awsAwsjson10_deserializeOpListTagsForResource) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson10_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
}
_, span := tracing.StartSpan(ctx, "OperationDeserializer")
endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
defer endTimer()
defer span.End()
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, awsAwsjson10_deserializeOpErrorListTagsForResource(response, &metadata)
}
output := &ListTagsForResourceOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsAwsjson10_deserializeOpDocumentListTagsForResourceOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
return out, metadata, err
}
func awsAwsjson10_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
headerCode := response.Header.Get("X-Amzn-ErrorType")
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
bodyInfo, err := getProtocolErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
errorCode = restjson.SanitizeErrorCode(typ)
}
if len(bodyInfo.Message) != 0 {
errorMessage = bodyInfo.Message
}
switch {
case strings.EqualFold("InternalServiceErrorException", errorCode):
return awsAwsjson10_deserializeErrorInternalServiceErrorException(response, errorBody)
case strings.EqualFold("InvalidRequestException", errorCode):
return awsAwsjson10_deserializeErrorInvalidRequestException(response, errorBody)
case strings.EqualFold("InvalidStateException", errorCode):
return awsAwsjson10_deserializeErrorInvalidStateException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsAwsjson10_deserializeErrorResourceNotFoundException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson10_deserializeOpListVpcConnectors struct {
}
func (*awsAwsjson10_deserializeOpListVpcConnectors) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson10_deserializeOpListVpcConnectors) 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
}
_, span := tracing.StartSpan(ctx, "OperationDeserializer")
endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
defer endTimer()
defer span.End()
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, awsAwsjson10_deserializeOpErrorListVpcConnectors(response, &metadata)
}
output := &ListVpcConnectorsOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsAwsjson10_deserializeOpDocumentListVpcConnectorsOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
return out, metadata, err
}
func awsAwsjson10_deserializeOpErrorListVpcConnectors(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
bodyInfo, err := getProtocolErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
errorCode = restjson.SanitizeErrorCode(typ)
}
if len(bodyInfo.Message) != 0 {
errorMessage = bodyInfo.Message
}
switch {
case strings.EqualFold("InternalServiceErrorException", errorCode):
return awsAwsjson10_deserializeErrorInternalServiceErrorException(response, errorBody)
case strings.EqualFold("InvalidRequestException", errorCode):
return awsAwsjson10_deserializeErrorInvalidRequestException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson10_deserializeOpListVpcIngressConnections struct {
}
func (*awsAwsjson10_deserializeOpListVpcIngressConnections) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson10_deserializeOpListVpcIngressConnections) 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
}
_, span := tracing.StartSpan(ctx, "OperationDeserializer")
endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
defer endTimer()
defer span.End()
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, awsAwsjson10_deserializeOpErrorListVpcIngressConnections(response, &metadata)
}
output := &ListVpcIngressConnectionsOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsAwsjson10_deserializeOpDocumentListVpcIngressConnectionsOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
return out, metadata, err
}
func awsAwsjson10_deserializeOpErrorListVpcIngressConnections(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
bodyInfo, err := getProtocolErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
errorCode = restjson.SanitizeErrorCode(typ)
}
if len(bodyInfo.Message) != 0 {
errorMessage = bodyInfo.Message
}
switch {
case strings.EqualFold("InternalServiceErrorException", errorCode):
return awsAwsjson10_deserializeErrorInternalServiceErrorException(response, errorBody)
case strings.EqualFold("InvalidRequestException", errorCode):
return awsAwsjson10_deserializeErrorInvalidRequestException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson10_deserializeOpPauseService struct {
}
func (*awsAwsjson10_deserializeOpPauseService) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson10_deserializeOpPauseService) 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
}
_, span := tracing.StartSpan(ctx, "OperationDeserializer")
endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
defer endTimer()
defer span.End()
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, awsAwsjson10_deserializeOpErrorPauseService(response, &metadata)
}
output := &PauseServiceOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsAwsjson10_deserializeOpDocumentPauseServiceOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
return out, metadata, err
}
func awsAwsjson10_deserializeOpErrorPauseService(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
bodyInfo, err := getProtocolErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
errorCode = restjson.SanitizeErrorCode(typ)
}
if len(bodyInfo.Message) != 0 {
errorMessage = bodyInfo.Message
}
switch {
case strings.EqualFold("InternalServiceErrorException", errorCode):
return awsAwsjson10_deserializeErrorInternalServiceErrorException(response, errorBody)
case strings.EqualFold("InvalidRequestException", errorCode):
return awsAwsjson10_deserializeErrorInvalidRequestException(response, errorBody)
case strings.EqualFold("InvalidStateException", errorCode):
return awsAwsjson10_deserializeErrorInvalidStateException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsAwsjson10_deserializeErrorResourceNotFoundException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson10_deserializeOpResumeService struct {
}
func (*awsAwsjson10_deserializeOpResumeService) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson10_deserializeOpResumeService) 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
}
_, span := tracing.StartSpan(ctx, "OperationDeserializer")
endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
defer endTimer()
defer span.End()
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, awsAwsjson10_deserializeOpErrorResumeService(response, &metadata)
}
output := &ResumeServiceOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsAwsjson10_deserializeOpDocumentResumeServiceOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
return out, metadata, err
}
func awsAwsjson10_deserializeOpErrorResumeService(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
bodyInfo, err := getProtocolErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
errorCode = restjson.SanitizeErrorCode(typ)
}
if len(bodyInfo.Message) != 0 {
errorMessage = bodyInfo.Message
}
switch {
case strings.EqualFold("InternalServiceErrorException", errorCode):
return awsAwsjson10_deserializeErrorInternalServiceErrorException(response, errorBody)
case strings.EqualFold("InvalidRequestException", errorCode):
return awsAwsjson10_deserializeErrorInvalidRequestException(response, errorBody)
case strings.EqualFold("InvalidStateException", errorCode):
return awsAwsjson10_deserializeErrorInvalidStateException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsAwsjson10_deserializeErrorResourceNotFoundException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson10_deserializeOpStartDeployment struct {
}
func (*awsAwsjson10_deserializeOpStartDeployment) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson10_deserializeOpStartDeployment) 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
}
_, span := tracing.StartSpan(ctx, "OperationDeserializer")
endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
defer endTimer()
defer span.End()
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, awsAwsjson10_deserializeOpErrorStartDeployment(response, &metadata)
}
output := &StartDeploymentOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsAwsjson10_deserializeOpDocumentStartDeploymentOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
return out, metadata, err
}
func awsAwsjson10_deserializeOpErrorStartDeployment(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
bodyInfo, err := getProtocolErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
errorCode = restjson.SanitizeErrorCode(typ)
}
if len(bodyInfo.Message) != 0 {
errorMessage = bodyInfo.Message
}
switch {
case strings.EqualFold("InternalServiceErrorException", errorCode):
return awsAwsjson10_deserializeErrorInternalServiceErrorException(response, errorBody)
case strings.EqualFold("InvalidRequestException", errorCode):
return awsAwsjson10_deserializeErrorInvalidRequestException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsAwsjson10_deserializeErrorResourceNotFoundException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson10_deserializeOpTagResource struct {
}
func (*awsAwsjson10_deserializeOpTagResource) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson10_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
}
_, span := tracing.StartSpan(ctx, "OperationDeserializer")
endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
defer endTimer()
defer span.End()
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, awsAwsjson10_deserializeOpErrorTagResource(response, &metadata)
}
output := &TagResourceOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsAwsjson10_deserializeOpDocumentTagResourceOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
return out, metadata, err
}
func awsAwsjson10_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
headerCode := response.Header.Get("X-Amzn-ErrorType")
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
bodyInfo, err := getProtocolErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
errorCode = restjson.SanitizeErrorCode(typ)
}
if len(bodyInfo.Message) != 0 {
errorMessage = bodyInfo.Message
}
switch {
case strings.EqualFold("InternalServiceErrorException", errorCode):
return awsAwsjson10_deserializeErrorInternalServiceErrorException(response, errorBody)
case strings.EqualFold("InvalidRequestException", errorCode):
return awsAwsjson10_deserializeErrorInvalidRequestException(response, errorBody)
case strings.EqualFold("InvalidStateException", errorCode):
return awsAwsjson10_deserializeErrorInvalidStateException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsAwsjson10_deserializeErrorResourceNotFoundException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson10_deserializeOpUntagResource struct {
}
func (*awsAwsjson10_deserializeOpUntagResource) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson10_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
}
_, span := tracing.StartSpan(ctx, "OperationDeserializer")
endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
defer endTimer()
defer span.End()
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, awsAwsjson10_deserializeOpErrorUntagResource(response, &metadata)
}
output := &UntagResourceOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsAwsjson10_deserializeOpDocumentUntagResourceOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
return out, metadata, err
}
func awsAwsjson10_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
headerCode := response.Header.Get("X-Amzn-ErrorType")
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
bodyInfo, err := getProtocolErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
errorCode = restjson.SanitizeErrorCode(typ)
}
if len(bodyInfo.Message) != 0 {
errorMessage = bodyInfo.Message
}
switch {
case strings.EqualFold("InternalServiceErrorException", errorCode):
return awsAwsjson10_deserializeErrorInternalServiceErrorException(response, errorBody)
case strings.EqualFold("InvalidRequestException", errorCode):
return awsAwsjson10_deserializeErrorInvalidRequestException(response, errorBody)
case strings.EqualFold("InvalidStateException", errorCode):
return awsAwsjson10_deserializeErrorInvalidStateException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsAwsjson10_deserializeErrorResourceNotFoundException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson10_deserializeOpUpdateDefaultAutoScalingConfiguration struct {
}
func (*awsAwsjson10_deserializeOpUpdateDefaultAutoScalingConfiguration) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson10_deserializeOpUpdateDefaultAutoScalingConfiguration) 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
}
_, span := tracing.StartSpan(ctx, "OperationDeserializer")
endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
defer endTimer()
defer span.End()
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, awsAwsjson10_deserializeOpErrorUpdateDefaultAutoScalingConfiguration(response, &metadata)
}
output := &UpdateDefaultAutoScalingConfigurationOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsAwsjson10_deserializeOpDocumentUpdateDefaultAutoScalingConfigurationOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
return out, metadata, err
}
func awsAwsjson10_deserializeOpErrorUpdateDefaultAutoScalingConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
bodyInfo, err := getProtocolErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
errorCode = restjson.SanitizeErrorCode(typ)
}
if len(bodyInfo.Message) != 0 {
errorMessage = bodyInfo.Message
}
switch {
case strings.EqualFold("InternalServiceErrorException", errorCode):
return awsAwsjson10_deserializeErrorInternalServiceErrorException(response, errorBody)
case strings.EqualFold("InvalidRequestException", errorCode):
return awsAwsjson10_deserializeErrorInvalidRequestException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsAwsjson10_deserializeErrorResourceNotFoundException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson10_deserializeOpUpdateService struct {
}
func (*awsAwsjson10_deserializeOpUpdateService) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson10_deserializeOpUpdateService) 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
}
_, span := tracing.StartSpan(ctx, "OperationDeserializer")
endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
defer endTimer()
defer span.End()
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, awsAwsjson10_deserializeOpErrorUpdateService(response, &metadata)
}
output := &UpdateServiceOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsAwsjson10_deserializeOpDocumentUpdateServiceOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
return out, metadata, err
}
func awsAwsjson10_deserializeOpErrorUpdateService(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
bodyInfo, err := getProtocolErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
errorCode = restjson.SanitizeErrorCode(typ)
}
if len(bodyInfo.Message) != 0 {
errorMessage = bodyInfo.Message
}
switch {
case strings.EqualFold("InternalServiceErrorException", errorCode):
return awsAwsjson10_deserializeErrorInternalServiceErrorException(response, errorBody)
case strings.EqualFold("InvalidRequestException", errorCode):
return awsAwsjson10_deserializeErrorInvalidRequestException(response, errorBody)
case strings.EqualFold("InvalidStateException", errorCode):
return awsAwsjson10_deserializeErrorInvalidStateException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsAwsjson10_deserializeErrorResourceNotFoundException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson10_deserializeOpUpdateVpcIngressConnection struct {
}
func (*awsAwsjson10_deserializeOpUpdateVpcIngressConnection) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson10_deserializeOpUpdateVpcIngressConnection) 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
}
_, span := tracing.StartSpan(ctx, "OperationDeserializer")
endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
defer endTimer()
defer span.End()
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, awsAwsjson10_deserializeOpErrorUpdateVpcIngressConnection(response, &metadata)
}
output := &UpdateVpcIngressConnectionOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsAwsjson10_deserializeOpDocumentUpdateVpcIngressConnectionOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
return out, metadata, err
}
func awsAwsjson10_deserializeOpErrorUpdateVpcIngressConnection(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
bodyInfo, err := getProtocolErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
errorCode = restjson.SanitizeErrorCode(typ)
}
if len(bodyInfo.Message) != 0 {
errorMessage = bodyInfo.Message
}
switch {
case strings.EqualFold("InternalServiceErrorException", errorCode):
return awsAwsjson10_deserializeErrorInternalServiceErrorException(response, errorBody)
case strings.EqualFold("InvalidRequestException", errorCode):
return awsAwsjson10_deserializeErrorInvalidRequestException(response, errorBody)
case strings.EqualFold("InvalidStateException", errorCode):
return awsAwsjson10_deserializeErrorInvalidStateException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsAwsjson10_deserializeErrorResourceNotFoundException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsAwsjson10_deserializeErrorInternalServiceErrorException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
output := &types.InternalServiceErrorException{}
err := awsAwsjson10_deserializeDocumentInternalServiceErrorException(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
return output
}
func awsAwsjson10_deserializeErrorInvalidRequestException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
output := &types.InvalidRequestException{}
err := awsAwsjson10_deserializeDocumentInvalidRequestException(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
return output
}
func awsAwsjson10_deserializeErrorInvalidStateException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
output := &types.InvalidStateException{}
err := awsAwsjson10_deserializeDocumentInvalidStateException(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
return output
}
func awsAwsjson10_deserializeErrorResourceNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
output := &types.ResourceNotFoundException{}
err := awsAwsjson10_deserializeDocumentResourceNotFoundException(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
return output
}
func awsAwsjson10_deserializeErrorServiceQuotaExceededException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
output := &types.ServiceQuotaExceededException{}
err := awsAwsjson10_deserializeDocumentServiceQuotaExceededException(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
return output
}
func awsAwsjson10_deserializeDocumentAuthenticationConfiguration(v **types.AuthenticationConfiguration, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.AuthenticationConfiguration
if *v == nil {
sv = &types.AuthenticationConfiguration{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "AccessRoleArn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected RoleArn to be of type string, got %T instead", value)
}
sv.AccessRoleArn = ptr.String(jtv)
}
case "ConnectionArn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AppRunnerResourceArn to be of type string, got %T instead", value)
}
sv.ConnectionArn = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson10_deserializeDocumentAutoScalingConfiguration(v **types.AutoScalingConfiguration, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.AutoScalingConfiguration
if *v == nil {
sv = &types.AutoScalingConfiguration{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "AutoScalingConfigurationArn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AppRunnerResourceArn to be of type string, got %T instead", value)
}
sv.AutoScalingConfigurationArn = ptr.String(jtv)
}
case "AutoScalingConfigurationName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AutoScalingConfigurationName to be of type string, got %T instead", value)
}
sv.AutoScalingConfigurationName = ptr.String(jtv)
}
case "AutoScalingConfigurationRevision":
if value != nil {
jtv, ok := value.(json.Number)
if !ok {
return fmt.Errorf("expected AutoScalingConfigurationRevision to be json.Number, got %T instead", value)
}
i64, err := jtv.Int64()
if err != nil {
return err
}
sv.AutoScalingConfigurationRevision = ptr.Int32(int32(i64))
}
case "CreatedAt":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value)
}
}
case "DeletedAt":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.DeletedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value)
}
}
case "HasAssociatedService":
if value != nil {
jtv, ok := value.(bool)
if !ok {
return fmt.Errorf("expected HasAssociatedService to be of type *bool, got %T instead", value)
}
sv.HasAssociatedService = ptr.Bool(jtv)
}
case "IsDefault":
if value != nil {
jtv, ok := value.(bool)
if !ok {
return fmt.Errorf("expected IsDefault to be of type *bool, got %T instead", value)
}
sv.IsDefault = ptr.Bool(jtv)
}
case "Latest":
if value != nil {
jtv, ok := value.(bool)
if !ok {
return fmt.Errorf("expected Latest to be of type *bool, got %T instead", value)
}
sv.Latest = ptr.Bool(jtv)
}
case "MaxConcurrency":
if value != nil {
jtv, ok := value.(json.Number)
if !ok {
return fmt.Errorf("expected MaxConcurrency to be json.Number, got %T instead", value)
}
i64, err := jtv.Int64()
if err != nil {
return err
}
sv.MaxConcurrency = ptr.Int32(int32(i64))
}
case "MaxSize":
if value != nil {
jtv, ok := value.(json.Number)
if !ok {
return fmt.Errorf("expected MaxSize to be json.Number, got %T instead", value)
}
i64, err := jtv.Int64()
if err != nil {
return err
}
sv.MaxSize = ptr.Int32(int32(i64))
}
case "MinSize":
if value != nil {
jtv, ok := value.(json.Number)
if !ok {
return fmt.Errorf("expected MinSize to be json.Number, got %T instead", value)
}
i64, err := jtv.Int64()
if err != nil {
return err
}
sv.MinSize = ptr.Int32(int32(i64))
}
case "Status":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AutoScalingConfigurationStatus to be of type string, got %T instead", value)
}
sv.Status = types.AutoScalingConfigurationStatus(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson10_deserializeDocumentAutoScalingConfigurationSummary(v **types.AutoScalingConfigurationSummary, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.AutoScalingConfigurationSummary
if *v == nil {
sv = &types.AutoScalingConfigurationSummary{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "AutoScalingConfigurationArn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AppRunnerResourceArn to be of type string, got %T instead", value)
}
sv.AutoScalingConfigurationArn = ptr.String(jtv)
}
case "AutoScalingConfigurationName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AutoScalingConfigurationName to be of type string, got %T instead", value)
}
sv.AutoScalingConfigurationName = ptr.String(jtv)
}
case "AutoScalingConfigurationRevision":
if value != nil {
jtv, ok := value.(json.Number)
if !ok {
return fmt.Errorf("expected Integer to be json.Number, got %T instead", value)
}
i64, err := jtv.Int64()
if err != nil {
return err
}
sv.AutoScalingConfigurationRevision = int32(i64)
}
case "CreatedAt":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value)
}
}
case "HasAssociatedService":
if value != nil {
jtv, ok := value.(bool)
if !ok {
return fmt.Errorf("expected HasAssociatedService to be of type *bool, got %T instead", value)
}
sv.HasAssociatedService = ptr.Bool(jtv)
}
case "IsDefault":
if value != nil {
jtv, ok := value.(bool)
if !ok {
return fmt.Errorf("expected IsDefault to be of type *bool, got %T instead", value)
}
sv.IsDefault = ptr.Bool(jtv)
}
case "Status":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AutoScalingConfigurationStatus to be of type string, got %T instead", value)
}
sv.Status = types.AutoScalingConfigurationStatus(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson10_deserializeDocumentAutoScalingConfigurationSummaryList(v *[]types.AutoScalingConfigurationSummary, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.([]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var cv []types.AutoScalingConfigurationSummary
if *v == nil {
cv = []types.AutoScalingConfigurationSummary{}
} else {
cv = *v
}
for _, value := range shape {
var col types.AutoScalingConfigurationSummary
destAddr := &col
if err := awsAwsjson10_deserializeDocumentAutoScalingConfigurationSummary(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsAwsjson10_deserializeDocumentCertificateValidationRecord(v **types.CertificateValidationRecord, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.CertificateValidationRecord
if *v == nil {
sv = &types.CertificateValidationRecord{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Name":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.Name = ptr.String(jtv)
}
case "Status":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected CertificateValidationRecordStatus to be of type string, got %T instead", value)
}
sv.Status = types.CertificateValidationRecordStatus(jtv)
}
case "Type":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.Type = ptr.String(jtv)
}
case "Value":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.Value = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson10_deserializeDocumentCertificateValidationRecordList(v *[]types.CertificateValidationRecord, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.([]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var cv []types.CertificateValidationRecord
if *v == nil {
cv = []types.CertificateValidationRecord{}
} else {
cv = *v
}
for _, value := range shape {
var col types.CertificateValidationRecord
destAddr := &col
if err := awsAwsjson10_deserializeDocumentCertificateValidationRecord(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsAwsjson10_deserializeDocumentCodeConfiguration(v **types.CodeConfiguration, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.CodeConfiguration
if *v == nil {
sv = &types.CodeConfiguration{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "CodeConfigurationValues":
if err := awsAwsjson10_deserializeDocumentCodeConfigurationValues(&sv.CodeConfigurationValues, value); err != nil {
return err
}
case "ConfigurationSource":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ConfigurationSource to be of type string, got %T instead", value)
}
sv.ConfigurationSource = types.ConfigurationSource(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson10_deserializeDocumentCodeConfigurationValues(v **types.CodeConfigurationValues, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.CodeConfigurationValues
if *v == nil {
sv = &types.CodeConfigurationValues{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "BuildCommand":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected BuildCommand to be of type string, got %T instead", value)
}
sv.BuildCommand = ptr.String(jtv)
}
case "Port":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.Port = ptr.String(jtv)
}
case "Runtime":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected Runtime to be of type string, got %T instead", value)
}
sv.Runtime = types.Runtime(jtv)
}
case "RuntimeEnvironmentSecrets":
if err := awsAwsjson10_deserializeDocumentRuntimeEnvironmentSecrets(&sv.RuntimeEnvironmentSecrets, value); err != nil {
return err
}
case "RuntimeEnvironmentVariables":
if err := awsAwsjson10_deserializeDocumentRuntimeEnvironmentVariables(&sv.RuntimeEnvironmentVariables, value); err != nil {
return err
}
case "StartCommand":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected StartCommand to be of type string, got %T instead", value)
}
sv.StartCommand = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson10_deserializeDocumentCodeRepository(v **types.CodeRepository, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.CodeRepository
if *v == nil {
sv = &types.CodeRepository{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "CodeConfiguration":
if err := awsAwsjson10_deserializeDocumentCodeConfiguration(&sv.CodeConfiguration, value); err != nil {
return err
}
case "RepositoryUrl":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.RepositoryUrl = ptr.String(jtv)
}
case "SourceCodeVersion":
if err := awsAwsjson10_deserializeDocumentSourceCodeVersion(&sv.SourceCodeVersion, value); err != nil {
return err
}
case "SourceDirectory":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected SourceDirectory to be of type string, got %T instead", value)
}
sv.SourceDirectory = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson10_deserializeDocumentConnection(v **types.Connection, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.Connection
if *v == nil {
sv = &types.Connection{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "ConnectionArn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AppRunnerResourceArn to be of type string, got %T instead", value)
}
sv.ConnectionArn = ptr.String(jtv)
}
case "ConnectionName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ConnectionName to be of type string, got %T instead", value)
}
sv.ConnectionName = ptr.String(jtv)
}
case "CreatedAt":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value)
}
}
case "ProviderType":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ProviderType to be of type string, got %T instead", value)
}
sv.ProviderType = types.ProviderType(jtv)
}
case "Status":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ConnectionStatus to be of type string, got %T instead", value)
}
sv.Status = types.ConnectionStatus(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson10_deserializeDocumentConnectionSummary(v **types.ConnectionSummary, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.ConnectionSummary
if *v == nil {
sv = &types.ConnectionSummary{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "ConnectionArn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AppRunnerResourceArn to be of type string, got %T instead", value)
}
sv.ConnectionArn = ptr.String(jtv)
}
case "ConnectionName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ConnectionName to be of type string, got %T instead", value)
}
sv.ConnectionName = ptr.String(jtv)
}
case "CreatedAt":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value)
}
}
case "ProviderType":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ProviderType to be of type string, got %T instead", value)
}
sv.ProviderType = types.ProviderType(jtv)
}
case "Status":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ConnectionStatus to be of type string, got %T instead", value)
}
sv.Status = types.ConnectionStatus(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson10_deserializeDocumentConnectionSummaryList(v *[]types.ConnectionSummary, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.([]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var cv []types.ConnectionSummary
if *v == nil {
cv = []types.ConnectionSummary{}
} else {
cv = *v
}
for _, value := range shape {
var col types.ConnectionSummary
destAddr := &col
if err := awsAwsjson10_deserializeDocumentConnectionSummary(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsAwsjson10_deserializeDocumentCustomDomain(v **types.CustomDomain, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.CustomDomain
if *v == nil {
sv = &types.CustomDomain{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "CertificateValidationRecords":
if err := awsAwsjson10_deserializeDocumentCertificateValidationRecordList(&sv.CertificateValidationRecords, value); err != nil {
return err
}
case "DomainName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected DomainName to be of type string, got %T instead", value)
}
sv.DomainName = ptr.String(jtv)
}
case "EnableWWWSubdomain":
if value != nil {
jtv, ok := value.(bool)
if !ok {
return fmt.Errorf("expected NullableBoolean to be of type *bool, got %T instead", value)
}
sv.EnableWWWSubdomain = ptr.Bool(jtv)
}
case "Status":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected CustomDomainAssociationStatus to be of type string, got %T instead", value)
}
sv.Status = types.CustomDomainAssociationStatus(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson10_deserializeDocumentCustomDomainList(v *[]types.CustomDomain, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.([]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var cv []types.CustomDomain
if *v == nil {
cv = []types.CustomDomain{}
} else {
cv = *v
}
for _, value := range shape {
var col types.CustomDomain
destAddr := &col
if err := awsAwsjson10_deserializeDocumentCustomDomain(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsAwsjson10_deserializeDocumentEgressConfiguration(v **types.EgressConfiguration, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.EgressConfiguration
if *v == nil {
sv = &types.EgressConfiguration{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "EgressType":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected EgressType to be of type string, got %T instead", value)
}
sv.EgressType = types.EgressType(jtv)
}
case "VpcConnectorArn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AppRunnerResourceArn to be of type string, got %T instead", value)
}
sv.VpcConnectorArn = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson10_deserializeDocumentEncryptionConfiguration(v **types.EncryptionConfiguration, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.EncryptionConfiguration
if *v == nil {
sv = &types.EncryptionConfiguration{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "KmsKey":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected KmsKeyArn to be of type string, got %T instead", value)
}
sv.KmsKey = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson10_deserializeDocumentHealthCheckConfiguration(v **types.HealthCheckConfiguration, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.HealthCheckConfiguration
if *v == nil {
sv = &types.HealthCheckConfiguration{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "HealthyThreshold":
if value != nil {
jtv, ok := value.(json.Number)
if !ok {
return fmt.Errorf("expected HealthCheckHealthyThreshold to be json.Number, got %T instead", value)
}
i64, err := jtv.Int64()
if err != nil {
return err
}
sv.HealthyThreshold = ptr.Int32(int32(i64))
}
case "Interval":
if value != nil {
jtv, ok := value.(json.Number)
if !ok {
return fmt.Errorf("expected HealthCheckInterval to be json.Number, got %T instead", value)
}
i64, err := jtv.Int64()
if err != nil {
return err
}
sv.Interval = ptr.Int32(int32(i64))
}
case "Path":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected HealthCheckPath to be of type string, got %T instead", value)
}
sv.Path = ptr.String(jtv)
}
case "Protocol":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected HealthCheckProtocol to be of type string, got %T instead", value)
}
sv.Protocol = types.HealthCheckProtocol(jtv)
}
case "Timeout":
if value != nil {
jtv, ok := value.(json.Number)
if !ok {
return fmt.Errorf("expected HealthCheckTimeout to be json.Number, got %T instead", value)
}
i64, err := jtv.Int64()
if err != nil {
return err
}
sv.Timeout = ptr.Int32(int32(i64))
}
case "UnhealthyThreshold":
if value != nil {
jtv, ok := value.(json.Number)
if !ok {
return fmt.Errorf("expected HealthCheckUnhealthyThreshold to be json.Number, got %T instead", value)
}
i64, err := jtv.Int64()
if err != nil {
return err
}
sv.UnhealthyThreshold = ptr.Int32(int32(i64))
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson10_deserializeDocumentImageConfiguration(v **types.ImageConfiguration, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.ImageConfiguration
if *v == nil {
sv = &types.ImageConfiguration{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Port":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.Port = ptr.String(jtv)
}
case "RuntimeEnvironmentSecrets":
if err := awsAwsjson10_deserializeDocumentRuntimeEnvironmentSecrets(&sv.RuntimeEnvironmentSecrets, value); err != nil {
return err
}
case "RuntimeEnvironmentVariables":
if err := awsAwsjson10_deserializeDocumentRuntimeEnvironmentVariables(&sv.RuntimeEnvironmentVariables, value); err != nil {
return err
}
case "StartCommand":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected StartCommand to be of type string, got %T instead", value)
}
sv.StartCommand = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson10_deserializeDocumentImageRepository(v **types.ImageRepository, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.ImageRepository
if *v == nil {
sv = &types.ImageRepository{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "ImageConfiguration":
if err := awsAwsjson10_deserializeDocumentImageConfiguration(&sv.ImageConfiguration, value); err != nil {
return err
}
case "ImageIdentifier":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ImageIdentifier to be of type string, got %T instead", value)
}
sv.ImageIdentifier = ptr.String(jtv)
}
case "ImageRepositoryType":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ImageRepositoryType to be of type string, got %T instead", value)
}
sv.ImageRepositoryType = types.ImageRepositoryType(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson10_deserializeDocumentIngressConfiguration(v **types.IngressConfiguration, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.IngressConfiguration
if *v == nil {
sv = &types.IngressConfiguration{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "IsPubliclyAccessible":
if value != nil {
jtv, ok := value.(bool)
if !ok {
return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value)
}
sv.IsPubliclyAccessible = jtv
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson10_deserializeDocumentIngressVpcConfiguration(v **types.IngressVpcConfiguration, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.IngressVpcConfiguration
if *v == nil {
sv = &types.IngressVpcConfiguration{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "VpcEndpointId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.VpcEndpointId = ptr.String(jtv)
}
case "VpcId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.VpcId = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson10_deserializeDocumentInstanceConfiguration(v **types.InstanceConfiguration, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.InstanceConfiguration
if *v == nil {
sv = &types.InstanceConfiguration{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Cpu":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected Cpu to be of type string, got %T instead", value)
}
sv.Cpu = ptr.String(jtv)
}
case "InstanceRoleArn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected RoleArn to be of type string, got %T instead", value)
}
sv.InstanceRoleArn = ptr.String(jtv)
}
case "Memory":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected Memory to be of type string, got %T instead", value)
}
sv.Memory = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson10_deserializeDocumentInternalServiceErrorException(v **types.InternalServiceErrorException, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.InternalServiceErrorException
if *v == nil {
sv = &types.InternalServiceErrorException{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "message", "Message":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson10_deserializeDocumentInvalidRequestException(v **types.InvalidRequestException, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.InvalidRequestException
if *v == nil {
sv = &types.InvalidRequestException{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "message", "Message":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson10_deserializeDocumentInvalidStateException(v **types.InvalidStateException, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.InvalidStateException
if *v == nil {
sv = &types.InvalidStateException{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "message", "Message":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson10_deserializeDocumentNetworkConfiguration(v **types.NetworkConfiguration, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.NetworkConfiguration
if *v == nil {
sv = &types.NetworkConfiguration{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "EgressConfiguration":
if err := awsAwsjson10_deserializeDocumentEgressConfiguration(&sv.EgressConfiguration, value); err != nil {
return err
}
case "IngressConfiguration":
if err := awsAwsjson10_deserializeDocumentIngressConfiguration(&sv.IngressConfiguration, value); err != nil {
return err
}
case "IpAddressType":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected IpAddressType to be of type string, got %T instead", value)
}
sv.IpAddressType = types.IpAddressType(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson10_deserializeDocumentObservabilityConfiguration(v **types.ObservabilityConfiguration, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.ObservabilityConfiguration
if *v == nil {
sv = &types.ObservabilityConfiguration{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "CreatedAt":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value)
}
}
case "DeletedAt":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.DeletedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value)
}
}
case "Latest":
if value != nil {
jtv, ok := value.(bool)
if !ok {
return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value)
}
sv.Latest = jtv
}
case "ObservabilityConfigurationArn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AppRunnerResourceArn to be of type string, got %T instead", value)
}
sv.ObservabilityConfigurationArn = ptr.String(jtv)
}
case "ObservabilityConfigurationName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ObservabilityConfigurationName to be of type string, got %T instead", value)
}
sv.ObservabilityConfigurationName = ptr.String(jtv)
}
case "ObservabilityConfigurationRevision":
if value != nil {
jtv, ok := value.(json.Number)
if !ok {
return fmt.Errorf("expected Integer to be json.Number, got %T instead", value)
}
i64, err := jtv.Int64()
if err != nil {
return err
}
sv.ObservabilityConfigurationRevision = int32(i64)
}
case "Status":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ObservabilityConfigurationStatus to be of type string, got %T instead", value)
}
sv.Status = types.ObservabilityConfigurationStatus(jtv)
}
case "TraceConfiguration":
if err := awsAwsjson10_deserializeDocumentTraceConfiguration(&sv.TraceConfiguration, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson10_deserializeDocumentObservabilityConfigurationSummary(v **types.ObservabilityConfigurationSummary, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.ObservabilityConfigurationSummary
if *v == nil {
sv = &types.ObservabilityConfigurationSummary{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "ObservabilityConfigurationArn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AppRunnerResourceArn to be of type string, got %T instead", value)
}
sv.ObservabilityConfigurationArn = ptr.String(jtv)
}
case "ObservabilityConfigurationName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ObservabilityConfigurationName to be of type string, got %T instead", value)
}
sv.ObservabilityConfigurationName = ptr.String(jtv)
}
case "ObservabilityConfigurationRevision":
if value != nil {
jtv, ok := value.(json.Number)
if !ok {
return fmt.Errorf("expected Integer to be json.Number, got %T instead", value)
}
i64, err := jtv.Int64()
if err != nil {
return err
}
sv.ObservabilityConfigurationRevision = int32(i64)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson10_deserializeDocumentObservabilityConfigurationSummaryList(v *[]types.ObservabilityConfigurationSummary, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.([]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var cv []types.ObservabilityConfigurationSummary
if *v == nil {
cv = []types.ObservabilityConfigurationSummary{}
} else {
cv = *v
}
for _, value := range shape {
var col types.ObservabilityConfigurationSummary
destAddr := &col
if err := awsAwsjson10_deserializeDocumentObservabilityConfigurationSummary(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsAwsjson10_deserializeDocumentOperationSummary(v **types.OperationSummary, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.OperationSummary
if *v == nil {
sv = &types.OperationSummary{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "EndedAt":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.EndedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value)
}
}
case "Id":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected UUID to be of type string, got %T instead", value)
}
sv.Id = ptr.String(jtv)
}
case "StartedAt":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.StartedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value)
}
}
case "Status":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected OperationStatus to be of type string, got %T instead", value)
}
sv.Status = types.OperationStatus(jtv)
}
case "TargetArn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AppRunnerResourceArn to be of type string, got %T instead", value)
}
sv.TargetArn = ptr.String(jtv)
}
case "Type":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected OperationType to be of type string, got %T instead", value)
}
sv.Type = types.OperationType(jtv)
}
case "UpdatedAt":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.UpdatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value)
}
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson10_deserializeDocumentOperationSummaryList(v *[]types.OperationSummary, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.([]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var cv []types.OperationSummary
if *v == nil {
cv = []types.OperationSummary{}
} else {
cv = *v
}
for _, value := range shape {
var col types.OperationSummary
destAddr := &col
if err := awsAwsjson10_deserializeDocumentOperationSummary(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsAwsjson10_deserializeDocumentResourceNotFoundException(v **types.ResourceNotFoundException, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.ResourceNotFoundException
if *v == nil {
sv = &types.ResourceNotFoundException{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "message", "Message":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson10_deserializeDocumentRuntimeEnvironmentSecrets(v *map[string]string, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var mv map[string]string
if *v == nil {
mv = map[string]string{}
} else {
mv = *v
}
for key, value := range shape {
var parsedVal string
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected RuntimeEnvironmentSecretsValue to be of type string, got %T instead", value)
}
parsedVal = jtv
}
mv[key] = parsedVal
}
*v = mv
return nil
}
func awsAwsjson10_deserializeDocumentRuntimeEnvironmentVariables(v *map[string]string, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var mv map[string]string
if *v == nil {
mv = map[string]string{}
} else {
mv = *v
}
for key, value := range shape {
var parsedVal string
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected RuntimeEnvironmentVariablesValue to be of type string, got %T instead", value)
}
parsedVal = jtv
}
mv[key] = parsedVal
}
*v = mv
return nil
}
func awsAwsjson10_deserializeDocumentService(v **types.Service, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.Service
if *v == nil {
sv = &types.Service{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "AutoScalingConfigurationSummary":
if err := awsAwsjson10_deserializeDocumentAutoScalingConfigurationSummary(&sv.AutoScalingConfigurationSummary, value); err != nil {
return err
}
case "CreatedAt":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value)
}
}
case "DeletedAt":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.DeletedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value)
}
}
case "EncryptionConfiguration":
if err := awsAwsjson10_deserializeDocumentEncryptionConfiguration(&sv.EncryptionConfiguration, value); err != nil {
return err
}
case "HealthCheckConfiguration":
if err := awsAwsjson10_deserializeDocumentHealthCheckConfiguration(&sv.HealthCheckConfiguration, value); err != nil {
return err
}
case "InstanceConfiguration":
if err := awsAwsjson10_deserializeDocumentInstanceConfiguration(&sv.InstanceConfiguration, value); err != nil {
return err
}
case "NetworkConfiguration":
if err := awsAwsjson10_deserializeDocumentNetworkConfiguration(&sv.NetworkConfiguration, value); err != nil {
return err
}
case "ObservabilityConfiguration":
if err := awsAwsjson10_deserializeDocumentServiceObservabilityConfiguration(&sv.ObservabilityConfiguration, value); err != nil {
return err
}
case "ServiceArn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AppRunnerResourceArn to be of type string, got %T instead", value)
}
sv.ServiceArn = ptr.String(jtv)
}
case "ServiceId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ServiceId to be of type string, got %T instead", value)
}
sv.ServiceId = ptr.String(jtv)
}
case "ServiceName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ServiceName to be of type string, got %T instead", value)
}
sv.ServiceName = ptr.String(jtv)
}
case "ServiceUrl":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.ServiceUrl = ptr.String(jtv)
}
case "SourceConfiguration":
if err := awsAwsjson10_deserializeDocumentSourceConfiguration(&sv.SourceConfiguration, value); err != nil {
return err
}
case "Status":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ServiceStatus to be of type string, got %T instead", value)
}
sv.Status = types.ServiceStatus(jtv)
}
case "UpdatedAt":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.UpdatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value)
}
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson10_deserializeDocumentServiceArnList(v *[]string, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.([]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var cv []string
if *v == nil {
cv = []string{}
} else {
cv = *v
}
for _, value := range shape {
var col string
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AppRunnerResourceArn to be of type string, got %T instead", value)
}
col = jtv
}
cv = append(cv, col)
}
*v = cv
return nil
}
func awsAwsjson10_deserializeDocumentServiceObservabilityConfiguration(v **types.ServiceObservabilityConfiguration, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.ServiceObservabilityConfiguration
if *v == nil {
sv = &types.ServiceObservabilityConfiguration{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "ObservabilityConfigurationArn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AppRunnerResourceArn to be of type string, got %T instead", value)
}
sv.ObservabilityConfigurationArn = ptr.String(jtv)
}
case "ObservabilityEnabled":
if value != nil {
jtv, ok := value.(bool)
if !ok {
return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value)
}
sv.ObservabilityEnabled = jtv
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson10_deserializeDocumentServiceQuotaExceededException(v **types.ServiceQuotaExceededException, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.ServiceQuotaExceededException
if *v == nil {
sv = &types.ServiceQuotaExceededException{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "message", "Message":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson10_deserializeDocumentServiceSummary(v **types.ServiceSummary, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.ServiceSummary
if *v == nil {
sv = &types.ServiceSummary{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "CreatedAt":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value)
}
}
case "ServiceArn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AppRunnerResourceArn to be of type string, got %T instead", value)
}
sv.ServiceArn = ptr.String(jtv)
}
case "ServiceId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ServiceId to be of type string, got %T instead", value)
}
sv.ServiceId = ptr.String(jtv)
}
case "ServiceName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ServiceName to be of type string, got %T instead", value)
}
sv.ServiceName = ptr.String(jtv)
}
case "ServiceUrl":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.ServiceUrl = ptr.String(jtv)
}
case "Status":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ServiceStatus to be of type string, got %T instead", value)
}
sv.Status = types.ServiceStatus(jtv)
}
case "UpdatedAt":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.UpdatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value)
}
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson10_deserializeDocumentServiceSummaryList(v *[]types.ServiceSummary, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.([]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var cv []types.ServiceSummary
if *v == nil {
cv = []types.ServiceSummary{}
} else {
cv = *v
}
for _, value := range shape {
var col types.ServiceSummary
destAddr := &col
if err := awsAwsjson10_deserializeDocumentServiceSummary(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsAwsjson10_deserializeDocumentSourceCodeVersion(v **types.SourceCodeVersion, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.SourceCodeVersion
if *v == nil {
sv = &types.SourceCodeVersion{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Type":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected SourceCodeVersionType to be of type string, got %T instead", value)
}
sv.Type = types.SourceCodeVersionType(jtv)
}
case "Value":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.Value = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson10_deserializeDocumentSourceConfiguration(v **types.SourceConfiguration, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.SourceConfiguration
if *v == nil {
sv = &types.SourceConfiguration{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "AuthenticationConfiguration":
if err := awsAwsjson10_deserializeDocumentAuthenticationConfiguration(&sv.AuthenticationConfiguration, value); err != nil {
return err
}
case "AutoDeploymentsEnabled":
if value != nil {
jtv, ok := value.(bool)
if !ok {
return fmt.Errorf("expected NullableBoolean to be of type *bool, got %T instead", value)
}
sv.AutoDeploymentsEnabled = ptr.Bool(jtv)
}
case "CodeRepository":
if err := awsAwsjson10_deserializeDocumentCodeRepository(&sv.CodeRepository, value); err != nil {
return err
}
case "ImageRepository":
if err := awsAwsjson10_deserializeDocumentImageRepository(&sv.ImageRepository, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson10_deserializeDocumentStringList(v *[]string, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.([]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var cv []string
if *v == nil {
cv = []string{}
} else {
cv = *v
}
for _, value := range shape {
var col string
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
col = jtv
}
cv = append(cv, col)
}
*v = cv
return nil
}
func awsAwsjson10_deserializeDocumentTag(v **types.Tag, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.Tag
if *v == nil {
sv = &types.Tag{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Key":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected TagKey to be of type string, got %T instead", value)
}
sv.Key = ptr.String(jtv)
}
case "Value":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected TagValue to be of type string, got %T instead", value)
}
sv.Value = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson10_deserializeDocumentTagList(v *[]types.Tag, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.([]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var cv []types.Tag
if *v == nil {
cv = []types.Tag{}
} else {
cv = *v
}
for _, value := range shape {
var col types.Tag
destAddr := &col
if err := awsAwsjson10_deserializeDocumentTag(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsAwsjson10_deserializeDocumentTraceConfiguration(v **types.TraceConfiguration, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.TraceConfiguration
if *v == nil {
sv = &types.TraceConfiguration{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Vendor":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected TracingVendor to be of type string, got %T instead", value)
}
sv.Vendor = types.TracingVendor(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson10_deserializeDocumentVpcConnector(v **types.VpcConnector, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.VpcConnector
if *v == nil {
sv = &types.VpcConnector{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "CreatedAt":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value)
}
}
case "DeletedAt":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.DeletedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value)
}
}
case "SecurityGroups":
if err := awsAwsjson10_deserializeDocumentStringList(&sv.SecurityGroups, value); err != nil {
return err
}
case "Status":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected VpcConnectorStatus to be of type string, got %T instead", value)
}
sv.Status = types.VpcConnectorStatus(jtv)
}
case "Subnets":
if err := awsAwsjson10_deserializeDocumentStringList(&sv.Subnets, value); err != nil {
return err
}
case "VpcConnectorArn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AppRunnerResourceArn to be of type string, got %T instead", value)
}
sv.VpcConnectorArn = ptr.String(jtv)
}
case "VpcConnectorName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected VpcConnectorName to be of type string, got %T instead", value)
}
sv.VpcConnectorName = ptr.String(jtv)
}
case "VpcConnectorRevision":
if value != nil {
jtv, ok := value.(json.Number)
if !ok {
return fmt.Errorf("expected Integer to be json.Number, got %T instead", value)
}
i64, err := jtv.Int64()
if err != nil {
return err
}
sv.VpcConnectorRevision = int32(i64)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson10_deserializeDocumentVpcConnectors(v *[]types.VpcConnector, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.([]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var cv []types.VpcConnector
if *v == nil {
cv = []types.VpcConnector{}
} else {
cv = *v
}
for _, value := range shape {
var col types.VpcConnector
destAddr := &col
if err := awsAwsjson10_deserializeDocumentVpcConnector(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsAwsjson10_deserializeDocumentVpcDNSTarget(v **types.VpcDNSTarget, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.VpcDNSTarget
if *v == nil {
sv = &types.VpcDNSTarget{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "DomainName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected DomainName to be of type string, got %T instead", value)
}
sv.DomainName = ptr.String(jtv)
}
case "VpcId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.VpcId = ptr.String(jtv)
}
case "VpcIngressConnectionArn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AppRunnerResourceArn to be of type string, got %T instead", value)
}
sv.VpcIngressConnectionArn = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson10_deserializeDocumentVpcDNSTargetList(v *[]types.VpcDNSTarget, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.([]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var cv []types.VpcDNSTarget
if *v == nil {
cv = []types.VpcDNSTarget{}
} else {
cv = *v
}
for _, value := range shape {
var col types.VpcDNSTarget
destAddr := &col
if err := awsAwsjson10_deserializeDocumentVpcDNSTarget(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsAwsjson10_deserializeDocumentVpcIngressConnection(v **types.VpcIngressConnection, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.VpcIngressConnection
if *v == nil {
sv = &types.VpcIngressConnection{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "AccountId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected CustomerAccountId to be of type string, got %T instead", value)
}
sv.AccountId = ptr.String(jtv)
}
case "CreatedAt":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value)
}
}
case "DeletedAt":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.DeletedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value)
}
}
case "DomainName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected DomainName to be of type string, got %T instead", value)
}
sv.DomainName = ptr.String(jtv)
}
case "IngressVpcConfiguration":
if err := awsAwsjson10_deserializeDocumentIngressVpcConfiguration(&sv.IngressVpcConfiguration, value); err != nil {
return err
}
case "ServiceArn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AppRunnerResourceArn to be of type string, got %T instead", value)
}
sv.ServiceArn = ptr.String(jtv)
}
case "Status":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected VpcIngressConnectionStatus to be of type string, got %T instead", value)
}
sv.Status = types.VpcIngressConnectionStatus(jtv)
}
case "VpcIngressConnectionArn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AppRunnerResourceArn to be of type string, got %T instead", value)
}
sv.VpcIngressConnectionArn = ptr.String(jtv)
}
case "VpcIngressConnectionName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected VpcIngressConnectionName to be of type string, got %T instead", value)
}
sv.VpcIngressConnectionName = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson10_deserializeDocumentVpcIngressConnectionSummary(v **types.VpcIngressConnectionSummary, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.VpcIngressConnectionSummary
if *v == nil {
sv = &types.VpcIngressConnectionSummary{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "ServiceArn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AppRunnerResourceArn to be of type string, got %T instead", value)
}
sv.ServiceArn = ptr.String(jtv)
}
case "VpcIngressConnectionArn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AppRunnerResourceArn to be of type string, got %T instead", value)
}
sv.VpcIngressConnectionArn = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson10_deserializeDocumentVpcIngressConnectionSummaryList(v *[]types.VpcIngressConnectionSummary, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.([]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var cv []types.VpcIngressConnectionSummary
if *v == nil {
cv = []types.VpcIngressConnectionSummary{}
} else {
cv = *v
}
for _, value := range shape {
var col types.VpcIngressConnectionSummary
destAddr := &col
if err := awsAwsjson10_deserializeDocumentVpcIngressConnectionSummary(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsAwsjson10_deserializeOpDocumentAssociateCustomDomainOutput(v **AssociateCustomDomainOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *AssociateCustomDomainOutput
if *v == nil {
sv = &AssociateCustomDomainOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "CustomDomain":
if err := awsAwsjson10_deserializeDocumentCustomDomain(&sv.CustomDomain, value); err != nil {
return err
}
case "DNSTarget":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.DNSTarget = ptr.String(jtv)
}
case "ServiceArn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AppRunnerResourceArn to be of type string, got %T instead", value)
}
sv.ServiceArn = ptr.String(jtv)
}
case "VpcDNSTargets":
if err := awsAwsjson10_deserializeDocumentVpcDNSTargetList(&sv.VpcDNSTargets, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson10_deserializeOpDocumentCreateAutoScalingConfigurationOutput(v **CreateAutoScalingConfigurationOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *CreateAutoScalingConfigurationOutput
if *v == nil {
sv = &CreateAutoScalingConfigurationOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "AutoScalingConfiguration":
if err := awsAwsjson10_deserializeDocumentAutoScalingConfiguration(&sv.AutoScalingConfiguration, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson10_deserializeOpDocumentCreateConnectionOutput(v **CreateConnectionOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *CreateConnectionOutput
if *v == nil {
sv = &CreateConnectionOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Connection":
if err := awsAwsjson10_deserializeDocumentConnection(&sv.Connection, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson10_deserializeOpDocumentCreateObservabilityConfigurationOutput(v **CreateObservabilityConfigurationOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *CreateObservabilityConfigurationOutput
if *v == nil {
sv = &CreateObservabilityConfigurationOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "ObservabilityConfiguration":
if err := awsAwsjson10_deserializeDocumentObservabilityConfiguration(&sv.ObservabilityConfiguration, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson10_deserializeOpDocumentCreateServiceOutput(v **CreateServiceOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *CreateServiceOutput
if *v == nil {
sv = &CreateServiceOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "OperationId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected UUID to be of type string, got %T instead", value)
}
sv.OperationId = ptr.String(jtv)
}
case "Service":
if err := awsAwsjson10_deserializeDocumentService(&sv.Service, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson10_deserializeOpDocumentCreateVpcConnectorOutput(v **CreateVpcConnectorOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *CreateVpcConnectorOutput
if *v == nil {
sv = &CreateVpcConnectorOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "VpcConnector":
if err := awsAwsjson10_deserializeDocumentVpcConnector(&sv.VpcConnector, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson10_deserializeOpDocumentCreateVpcIngressConnectionOutput(v **CreateVpcIngressConnectionOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *CreateVpcIngressConnectionOutput
if *v == nil {
sv = &CreateVpcIngressConnectionOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "VpcIngressConnection":
if err := awsAwsjson10_deserializeDocumentVpcIngressConnection(&sv.VpcIngressConnection, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson10_deserializeOpDocumentDeleteAutoScalingConfigurationOutput(v **DeleteAutoScalingConfigurationOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *DeleteAutoScalingConfigurationOutput
if *v == nil {
sv = &DeleteAutoScalingConfigurationOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "AutoScalingConfiguration":
if err := awsAwsjson10_deserializeDocumentAutoScalingConfiguration(&sv.AutoScalingConfiguration, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson10_deserializeOpDocumentDeleteConnectionOutput(v **DeleteConnectionOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *DeleteConnectionOutput
if *v == nil {
sv = &DeleteConnectionOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Connection":
if err := awsAwsjson10_deserializeDocumentConnection(&sv.Connection, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson10_deserializeOpDocumentDeleteObservabilityConfigurationOutput(v **DeleteObservabilityConfigurationOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *DeleteObservabilityConfigurationOutput
if *v == nil {
sv = &DeleteObservabilityConfigurationOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "ObservabilityConfiguration":
if err := awsAwsjson10_deserializeDocumentObservabilityConfiguration(&sv.ObservabilityConfiguration, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson10_deserializeOpDocumentDeleteServiceOutput(v **DeleteServiceOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *DeleteServiceOutput
if *v == nil {
sv = &DeleteServiceOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "OperationId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected UUID to be of type string, got %T instead", value)
}
sv.OperationId = ptr.String(jtv)
}
case "Service":
if err := awsAwsjson10_deserializeDocumentService(&sv.Service, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson10_deserializeOpDocumentDeleteVpcConnectorOutput(v **DeleteVpcConnectorOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *DeleteVpcConnectorOutput
if *v == nil {
sv = &DeleteVpcConnectorOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "VpcConnector":
if err := awsAwsjson10_deserializeDocumentVpcConnector(&sv.VpcConnector, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson10_deserializeOpDocumentDeleteVpcIngressConnectionOutput(v **DeleteVpcIngressConnectionOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *DeleteVpcIngressConnectionOutput
if *v == nil {
sv = &DeleteVpcIngressConnectionOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "VpcIngressConnection":
if err := awsAwsjson10_deserializeDocumentVpcIngressConnection(&sv.VpcIngressConnection, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson10_deserializeOpDocumentDescribeAutoScalingConfigurationOutput(v **DescribeAutoScalingConfigurationOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *DescribeAutoScalingConfigurationOutput
if *v == nil {
sv = &DescribeAutoScalingConfigurationOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "AutoScalingConfiguration":
if err := awsAwsjson10_deserializeDocumentAutoScalingConfiguration(&sv.AutoScalingConfiguration, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson10_deserializeOpDocumentDescribeCustomDomainsOutput(v **DescribeCustomDomainsOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *DescribeCustomDomainsOutput
if *v == nil {
sv = &DescribeCustomDomainsOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "CustomDomains":
if err := awsAwsjson10_deserializeDocumentCustomDomainList(&sv.CustomDomains, value); err != nil {
return err
}
case "DNSTarget":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.DNSTarget = ptr.String(jtv)
}
case "NextToken":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.NextToken = ptr.String(jtv)
}
case "ServiceArn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AppRunnerResourceArn to be of type string, got %T instead", value)
}
sv.ServiceArn = ptr.String(jtv)
}
case "VpcDNSTargets":
if err := awsAwsjson10_deserializeDocumentVpcDNSTargetList(&sv.VpcDNSTargets, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson10_deserializeOpDocumentDescribeObservabilityConfigurationOutput(v **DescribeObservabilityConfigurationOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *DescribeObservabilityConfigurationOutput
if *v == nil {
sv = &DescribeObservabilityConfigurationOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "ObservabilityConfiguration":
if err := awsAwsjson10_deserializeDocumentObservabilityConfiguration(&sv.ObservabilityConfiguration, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson10_deserializeOpDocumentDescribeServiceOutput(v **DescribeServiceOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *DescribeServiceOutput
if *v == nil {
sv = &DescribeServiceOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Service":
if err := awsAwsjson10_deserializeDocumentService(&sv.Service, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson10_deserializeOpDocumentDescribeVpcConnectorOutput(v **DescribeVpcConnectorOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *DescribeVpcConnectorOutput
if *v == nil {
sv = &DescribeVpcConnectorOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "VpcConnector":
if err := awsAwsjson10_deserializeDocumentVpcConnector(&sv.VpcConnector, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson10_deserializeOpDocumentDescribeVpcIngressConnectionOutput(v **DescribeVpcIngressConnectionOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *DescribeVpcIngressConnectionOutput
if *v == nil {
sv = &DescribeVpcIngressConnectionOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "VpcIngressConnection":
if err := awsAwsjson10_deserializeDocumentVpcIngressConnection(&sv.VpcIngressConnection, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson10_deserializeOpDocumentDisassociateCustomDomainOutput(v **DisassociateCustomDomainOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *DisassociateCustomDomainOutput
if *v == nil {
sv = &DisassociateCustomDomainOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "CustomDomain":
if err := awsAwsjson10_deserializeDocumentCustomDomain(&sv.CustomDomain, value); err != nil {
return err
}
case "DNSTarget":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.DNSTarget = ptr.String(jtv)
}
case "ServiceArn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AppRunnerResourceArn to be of type string, got %T instead", value)
}
sv.ServiceArn = ptr.String(jtv)
}
case "VpcDNSTargets":
if err := awsAwsjson10_deserializeDocumentVpcDNSTargetList(&sv.VpcDNSTargets, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson10_deserializeOpDocumentListAutoScalingConfigurationsOutput(v **ListAutoScalingConfigurationsOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *ListAutoScalingConfigurationsOutput
if *v == nil {
sv = &ListAutoScalingConfigurationsOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "AutoScalingConfigurationSummaryList":
if err := awsAwsjson10_deserializeDocumentAutoScalingConfigurationSummaryList(&sv.AutoScalingConfigurationSummaryList, value); err != nil {
return err
}
case "NextToken":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected NextToken to be of type string, got %T instead", value)
}
sv.NextToken = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson10_deserializeOpDocumentListConnectionsOutput(v **ListConnectionsOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *ListConnectionsOutput
if *v == nil {
sv = &ListConnectionsOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "ConnectionSummaryList":
if err := awsAwsjson10_deserializeDocumentConnectionSummaryList(&sv.ConnectionSummaryList, value); err != nil {
return err
}
case "NextToken":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected NextToken to be of type string, got %T instead", value)
}
sv.NextToken = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson10_deserializeOpDocumentListObservabilityConfigurationsOutput(v **ListObservabilityConfigurationsOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *ListObservabilityConfigurationsOutput
if *v == nil {
sv = &ListObservabilityConfigurationsOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "NextToken":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected NextToken to be of type string, got %T instead", value)
}
sv.NextToken = ptr.String(jtv)
}
case "ObservabilityConfigurationSummaryList":
if err := awsAwsjson10_deserializeDocumentObservabilityConfigurationSummaryList(&sv.ObservabilityConfigurationSummaryList, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson10_deserializeOpDocumentListOperationsOutput(v **ListOperationsOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *ListOperationsOutput
if *v == nil {
sv = &ListOperationsOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "NextToken":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.NextToken = ptr.String(jtv)
}
case "OperationSummaryList":
if err := awsAwsjson10_deserializeDocumentOperationSummaryList(&sv.OperationSummaryList, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson10_deserializeOpDocumentListServicesForAutoScalingConfigurationOutput(v **ListServicesForAutoScalingConfigurationOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *ListServicesForAutoScalingConfigurationOutput
if *v == nil {
sv = &ListServicesForAutoScalingConfigurationOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "NextToken":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected NextToken to be of type string, got %T instead", value)
}
sv.NextToken = ptr.String(jtv)
}
case "ServiceArnList":
if err := awsAwsjson10_deserializeDocumentServiceArnList(&sv.ServiceArnList, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson10_deserializeOpDocumentListServicesOutput(v **ListServicesOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *ListServicesOutput
if *v == nil {
sv = &ListServicesOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "NextToken":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.NextToken = ptr.String(jtv)
}
case "ServiceSummaryList":
if err := awsAwsjson10_deserializeDocumentServiceSummaryList(&sv.ServiceSummaryList, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson10_deserializeOpDocumentListTagsForResourceOutput(v **ListTagsForResourceOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *ListTagsForResourceOutput
if *v == nil {
sv = &ListTagsForResourceOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Tags":
if err := awsAwsjson10_deserializeDocumentTagList(&sv.Tags, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson10_deserializeOpDocumentListVpcConnectorsOutput(v **ListVpcConnectorsOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *ListVpcConnectorsOutput
if *v == nil {
sv = &ListVpcConnectorsOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "NextToken":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected NextToken to be of type string, got %T instead", value)
}
sv.NextToken = ptr.String(jtv)
}
case "VpcConnectors":
if err := awsAwsjson10_deserializeDocumentVpcConnectors(&sv.VpcConnectors, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson10_deserializeOpDocumentListVpcIngressConnectionsOutput(v **ListVpcIngressConnectionsOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *ListVpcIngressConnectionsOutput
if *v == nil {
sv = &ListVpcIngressConnectionsOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "NextToken":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected NextToken to be of type string, got %T instead", value)
}
sv.NextToken = ptr.String(jtv)
}
case "VpcIngressConnectionSummaryList":
if err := awsAwsjson10_deserializeDocumentVpcIngressConnectionSummaryList(&sv.VpcIngressConnectionSummaryList, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson10_deserializeOpDocumentPauseServiceOutput(v **PauseServiceOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *PauseServiceOutput
if *v == nil {
sv = &PauseServiceOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "OperationId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected UUID to be of type string, got %T instead", value)
}
sv.OperationId = ptr.String(jtv)
}
case "Service":
if err := awsAwsjson10_deserializeDocumentService(&sv.Service, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson10_deserializeOpDocumentResumeServiceOutput(v **ResumeServiceOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *ResumeServiceOutput
if *v == nil {
sv = &ResumeServiceOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "OperationId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected UUID to be of type string, got %T instead", value)
}
sv.OperationId = ptr.String(jtv)
}
case "Service":
if err := awsAwsjson10_deserializeDocumentService(&sv.Service, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson10_deserializeOpDocumentStartDeploymentOutput(v **StartDeploymentOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *StartDeploymentOutput
if *v == nil {
sv = &StartDeploymentOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "OperationId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected UUID to be of type string, got %T instead", value)
}
sv.OperationId = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson10_deserializeOpDocumentTagResourceOutput(v **TagResourceOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *TagResourceOutput
if *v == nil {
sv = &TagResourceOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson10_deserializeOpDocumentUntagResourceOutput(v **UntagResourceOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *UntagResourceOutput
if *v == nil {
sv = &UntagResourceOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson10_deserializeOpDocumentUpdateDefaultAutoScalingConfigurationOutput(v **UpdateDefaultAutoScalingConfigurationOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *UpdateDefaultAutoScalingConfigurationOutput
if *v == nil {
sv = &UpdateDefaultAutoScalingConfigurationOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "AutoScalingConfiguration":
if err := awsAwsjson10_deserializeDocumentAutoScalingConfiguration(&sv.AutoScalingConfiguration, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson10_deserializeOpDocumentUpdateServiceOutput(v **UpdateServiceOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *UpdateServiceOutput
if *v == nil {
sv = &UpdateServiceOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "OperationId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected UUID to be of type string, got %T instead", value)
}
sv.OperationId = ptr.String(jtv)
}
case "Service":
if err := awsAwsjson10_deserializeDocumentService(&sv.Service, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson10_deserializeOpDocumentUpdateVpcIngressConnectionOutput(v **UpdateVpcIngressConnectionOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *UpdateVpcIngressConnectionOutput
if *v == nil {
sv = &UpdateVpcIngressConnectionOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "VpcIngressConnection":
if err := awsAwsjson10_deserializeDocumentVpcIngressConnection(&sv.VpcIngressConnection, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type protocolErrorInfo struct {
Type string `json:"__type"`
Message string
Code any // nonstandard for awsjson but some services do present the type here
}
func getProtocolErrorInfo(decoder *json.Decoder) (protocolErrorInfo, error) {
var errInfo protocolErrorInfo
if err := decoder.Decode(&errInfo); err != nil {
if err == io.EOF {
return errInfo, nil
}
return errInfo, err
}
return errInfo, nil
}
func resolveProtocolErrorType(headerType string, bodyInfo protocolErrorInfo) (string, bool) {
if len(headerType) != 0 {
return headerType, true
} else if len(bodyInfo.Type) != 0 {
return bodyInfo.Type, true
} else if code, ok := bodyInfo.Code.(string); ok && len(code) != 0 {
return code, true
}
return "", false
}