// Code generated by smithy-go-codegen DO NOT EDIT.


package ecs

import (
	"bytes"
	"context"
	"fmt"
	"io"
	"encoding/json"
	"math"
	"github.com/aws/smithy-go/middleware"
	"github.com/aws/smithy-go/ptr"
	"github.com/aws/aws-sdk-go-v2/aws/protocol/restjson"
	smithy "github.com/aws/smithy-go"
	smithyhttp "github.com/aws/smithy-go/transport/http"
	smithyio "github.com/aws/smithy-go/io"
	smithytime "github.com/aws/smithy-go/time"
	"strings"
	"time"
	"github.com/aws/smithy-go/tracing"
	"github.com/aws/aws-sdk-go-v2/service/ecs/types"
)

func deserializeS3Expires(v string) (*time.Time, error) {
    t, err := smithytime.ParseHTTPDate(v)
    if err != nil {
        return nil, nil
    }
    return &t, nil
}

type awsAwsjson11_deserializeOpCreateCapacityProvider struct {
}

func (*awsAwsjson11_deserializeOpCreateCapacityProvider) ID() string {
	return "OperationDeserializer"
}

func (m *awsAwsjson11_deserializeOpCreateCapacityProvider) 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, awsAwsjson11_deserializeOpErrorCreateCapacityProvider(response, &metadata)
	}
	output := &CreateCapacityProviderOutput{}
	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 = awsAwsjson11_deserializeOpDocumentCreateCapacityProviderOutput(&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 awsAwsjson11_deserializeOpErrorCreateCapacityProvider(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("ClientException", errorCode):
			return awsAwsjson11_deserializeErrorClientException(response, errorBody)
		
		case strings.EqualFold("InvalidParameterException", errorCode):
			return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
		
		case strings.EqualFold("LimitExceededException", errorCode):
			return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody)
		
		case strings.EqualFold("ServerException", errorCode):
			return awsAwsjson11_deserializeErrorServerException(response, errorBody)
		
		case strings.EqualFold("UpdateInProgressException", errorCode):
			return awsAwsjson11_deserializeErrorUpdateInProgressException(response, errorBody)
		
		default:
			genericError := &smithy.GenericAPIError{
				Code: errorCode,
				Message: errorMessage,
			}
			return genericError
		
	}
}

type awsAwsjson11_deserializeOpCreateCluster struct {
}

func (*awsAwsjson11_deserializeOpCreateCluster) ID() string {
	return "OperationDeserializer"
}

func (m *awsAwsjson11_deserializeOpCreateCluster) 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, awsAwsjson11_deserializeOpErrorCreateCluster(response, &metadata)
	}
	output := &CreateClusterOutput{}
	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 = awsAwsjson11_deserializeOpDocumentCreateClusterOutput(&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 awsAwsjson11_deserializeOpErrorCreateCluster(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("ClientException", errorCode):
			return awsAwsjson11_deserializeErrorClientException(response, errorBody)
		
		case strings.EqualFold("InvalidParameterException", errorCode):
			return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
		
		case strings.EqualFold("NamespaceNotFoundException", errorCode):
			return awsAwsjson11_deserializeErrorNamespaceNotFoundException(response, errorBody)
		
		case strings.EqualFold("ServerException", errorCode):
			return awsAwsjson11_deserializeErrorServerException(response, errorBody)
		
		default:
			genericError := &smithy.GenericAPIError{
				Code: errorCode,
				Message: errorMessage,
			}
			return genericError
		
	}
}

type awsAwsjson11_deserializeOpCreateService struct {
}

func (*awsAwsjson11_deserializeOpCreateService) ID() string {
	return "OperationDeserializer"
}

func (m *awsAwsjson11_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, awsAwsjson11_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 = awsAwsjson11_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 awsAwsjson11_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("AccessDeniedException", errorCode):
			return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
		
		case strings.EqualFold("ClientException", errorCode):
			return awsAwsjson11_deserializeErrorClientException(response, errorBody)
		
		case strings.EqualFold("ClusterNotFoundException", errorCode):
			return awsAwsjson11_deserializeErrorClusterNotFoundException(response, errorBody)
		
		case strings.EqualFold("InvalidParameterException", errorCode):
			return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
		
		case strings.EqualFold("NamespaceNotFoundException", errorCode):
			return awsAwsjson11_deserializeErrorNamespaceNotFoundException(response, errorBody)
		
		case strings.EqualFold("PlatformTaskDefinitionIncompatibilityException", errorCode):
			return awsAwsjson11_deserializeErrorPlatformTaskDefinitionIncompatibilityException(response, errorBody)
		
		case strings.EqualFold("PlatformUnknownException", errorCode):
			return awsAwsjson11_deserializeErrorPlatformUnknownException(response, errorBody)
		
		case strings.EqualFold("ServerException", errorCode):
			return awsAwsjson11_deserializeErrorServerException(response, errorBody)
		
		case strings.EqualFold("UnsupportedFeatureException", errorCode):
			return awsAwsjson11_deserializeErrorUnsupportedFeatureException(response, errorBody)
		
		default:
			genericError := &smithy.GenericAPIError{
				Code: errorCode,
				Message: errorMessage,
			}
			return genericError
		
	}
}

type awsAwsjson11_deserializeOpCreateTaskSet struct {
}

func (*awsAwsjson11_deserializeOpCreateTaskSet) ID() string {
	return "OperationDeserializer"
}

func (m *awsAwsjson11_deserializeOpCreateTaskSet) 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, awsAwsjson11_deserializeOpErrorCreateTaskSet(response, &metadata)
	}
	output := &CreateTaskSetOutput{}
	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 = awsAwsjson11_deserializeOpDocumentCreateTaskSetOutput(&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 awsAwsjson11_deserializeOpErrorCreateTaskSet(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("AccessDeniedException", errorCode):
			return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
		
		case strings.EqualFold("ClientException", errorCode):
			return awsAwsjson11_deserializeErrorClientException(response, errorBody)
		
		case strings.EqualFold("ClusterNotFoundException", errorCode):
			return awsAwsjson11_deserializeErrorClusterNotFoundException(response, errorBody)
		
		case strings.EqualFold("InvalidParameterException", errorCode):
			return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
		
		case strings.EqualFold("NamespaceNotFoundException", errorCode):
			return awsAwsjson11_deserializeErrorNamespaceNotFoundException(response, errorBody)
		
		case strings.EqualFold("PlatformTaskDefinitionIncompatibilityException", errorCode):
			return awsAwsjson11_deserializeErrorPlatformTaskDefinitionIncompatibilityException(response, errorBody)
		
		case strings.EqualFold("PlatformUnknownException", errorCode):
			return awsAwsjson11_deserializeErrorPlatformUnknownException(response, errorBody)
		
		case strings.EqualFold("ServerException", errorCode):
			return awsAwsjson11_deserializeErrorServerException(response, errorBody)
		
		case strings.EqualFold("ServiceNotActiveException", errorCode):
			return awsAwsjson11_deserializeErrorServiceNotActiveException(response, errorBody)
		
		case strings.EqualFold("ServiceNotFoundException", errorCode):
			return awsAwsjson11_deserializeErrorServiceNotFoundException(response, errorBody)
		
		case strings.EqualFold("UnsupportedFeatureException", errorCode):
			return awsAwsjson11_deserializeErrorUnsupportedFeatureException(response, errorBody)
		
		default:
			genericError := &smithy.GenericAPIError{
				Code: errorCode,
				Message: errorMessage,
			}
			return genericError
		
	}
}

type awsAwsjson11_deserializeOpDeleteAccountSetting struct {
}

func (*awsAwsjson11_deserializeOpDeleteAccountSetting) ID() string {
	return "OperationDeserializer"
}

func (m *awsAwsjson11_deserializeOpDeleteAccountSetting) 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, awsAwsjson11_deserializeOpErrorDeleteAccountSetting(response, &metadata)
	}
	output := &DeleteAccountSettingOutput{}
	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 = awsAwsjson11_deserializeOpDocumentDeleteAccountSettingOutput(&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 awsAwsjson11_deserializeOpErrorDeleteAccountSetting(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("ClientException", errorCode):
			return awsAwsjson11_deserializeErrorClientException(response, errorBody)
		
		case strings.EqualFold("InvalidParameterException", errorCode):
			return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
		
		case strings.EqualFold("ServerException", errorCode):
			return awsAwsjson11_deserializeErrorServerException(response, errorBody)
		
		default:
			genericError := &smithy.GenericAPIError{
				Code: errorCode,
				Message: errorMessage,
			}
			return genericError
		
	}
}

type awsAwsjson11_deserializeOpDeleteAttributes struct {
}

func (*awsAwsjson11_deserializeOpDeleteAttributes) ID() string {
	return "OperationDeserializer"
}

func (m *awsAwsjson11_deserializeOpDeleteAttributes) 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, awsAwsjson11_deserializeOpErrorDeleteAttributes(response, &metadata)
	}
	output := &DeleteAttributesOutput{}
	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 = awsAwsjson11_deserializeOpDocumentDeleteAttributesOutput(&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 awsAwsjson11_deserializeOpErrorDeleteAttributes(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("ClusterNotFoundException", errorCode):
			return awsAwsjson11_deserializeErrorClusterNotFoundException(response, errorBody)
		
		case strings.EqualFold("InvalidParameterException", errorCode):
			return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
		
		case strings.EqualFold("TargetNotFoundException", errorCode):
			return awsAwsjson11_deserializeErrorTargetNotFoundException(response, errorBody)
		
		default:
			genericError := &smithy.GenericAPIError{
				Code: errorCode,
				Message: errorMessage,
			}
			return genericError
		
	}
}

type awsAwsjson11_deserializeOpDeleteCapacityProvider struct {
}

func (*awsAwsjson11_deserializeOpDeleteCapacityProvider) ID() string {
	return "OperationDeserializer"
}

func (m *awsAwsjson11_deserializeOpDeleteCapacityProvider) 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, awsAwsjson11_deserializeOpErrorDeleteCapacityProvider(response, &metadata)
	}
	output := &DeleteCapacityProviderOutput{}
	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 = awsAwsjson11_deserializeOpDocumentDeleteCapacityProviderOutput(&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 awsAwsjson11_deserializeOpErrorDeleteCapacityProvider(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("ClientException", errorCode):
			return awsAwsjson11_deserializeErrorClientException(response, errorBody)
		
		case strings.EqualFold("InvalidParameterException", errorCode):
			return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
		
		case strings.EqualFold("ServerException", errorCode):
			return awsAwsjson11_deserializeErrorServerException(response, errorBody)
		
		default:
			genericError := &smithy.GenericAPIError{
				Code: errorCode,
				Message: errorMessage,
			}
			return genericError
		
	}
}

type awsAwsjson11_deserializeOpDeleteCluster struct {
}

func (*awsAwsjson11_deserializeOpDeleteCluster) ID() string {
	return "OperationDeserializer"
}

func (m *awsAwsjson11_deserializeOpDeleteCluster) 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, awsAwsjson11_deserializeOpErrorDeleteCluster(response, &metadata)
	}
	output := &DeleteClusterOutput{}
	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 = awsAwsjson11_deserializeOpDocumentDeleteClusterOutput(&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 awsAwsjson11_deserializeOpErrorDeleteCluster(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("ClientException", errorCode):
			return awsAwsjson11_deserializeErrorClientException(response, errorBody)
		
		case strings.EqualFold("ClusterContainsContainerInstancesException", errorCode):
			return awsAwsjson11_deserializeErrorClusterContainsContainerInstancesException(response, errorBody)
		
		case strings.EqualFold("ClusterContainsServicesException", errorCode):
			return awsAwsjson11_deserializeErrorClusterContainsServicesException(response, errorBody)
		
		case strings.EqualFold("ClusterContainsTasksException", errorCode):
			return awsAwsjson11_deserializeErrorClusterContainsTasksException(response, errorBody)
		
		case strings.EqualFold("ClusterNotFoundException", errorCode):
			return awsAwsjson11_deserializeErrorClusterNotFoundException(response, errorBody)
		
		case strings.EqualFold("InvalidParameterException", errorCode):
			return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
		
		case strings.EqualFold("ServerException", errorCode):
			return awsAwsjson11_deserializeErrorServerException(response, errorBody)
		
		case strings.EqualFold("UpdateInProgressException", errorCode):
			return awsAwsjson11_deserializeErrorUpdateInProgressException(response, errorBody)
		
		default:
			genericError := &smithy.GenericAPIError{
				Code: errorCode,
				Message: errorMessage,
			}
			return genericError
		
	}
}

type awsAwsjson11_deserializeOpDeleteService struct {
}

func (*awsAwsjson11_deserializeOpDeleteService) ID() string {
	return "OperationDeserializer"
}

func (m *awsAwsjson11_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, awsAwsjson11_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 = awsAwsjson11_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 awsAwsjson11_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("ClientException", errorCode):
			return awsAwsjson11_deserializeErrorClientException(response, errorBody)
		
		case strings.EqualFold("ClusterNotFoundException", errorCode):
			return awsAwsjson11_deserializeErrorClusterNotFoundException(response, errorBody)
		
		case strings.EqualFold("InvalidParameterException", errorCode):
			return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
		
		case strings.EqualFold("ServerException", errorCode):
			return awsAwsjson11_deserializeErrorServerException(response, errorBody)
		
		case strings.EqualFold("ServiceNotFoundException", errorCode):
			return awsAwsjson11_deserializeErrorServiceNotFoundException(response, errorBody)
		
		default:
			genericError := &smithy.GenericAPIError{
				Code: errorCode,
				Message: errorMessage,
			}
			return genericError
		
	}
}

type awsAwsjson11_deserializeOpDeleteTaskDefinitions struct {
}

func (*awsAwsjson11_deserializeOpDeleteTaskDefinitions) ID() string {
	return "OperationDeserializer"
}

func (m *awsAwsjson11_deserializeOpDeleteTaskDefinitions) 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, awsAwsjson11_deserializeOpErrorDeleteTaskDefinitions(response, &metadata)
	}
	output := &DeleteTaskDefinitionsOutput{}
	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 = awsAwsjson11_deserializeOpDocumentDeleteTaskDefinitionsOutput(&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 awsAwsjson11_deserializeOpErrorDeleteTaskDefinitions(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("AccessDeniedException", errorCode):
			return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
		
		case strings.EqualFold("ClientException", errorCode):
			return awsAwsjson11_deserializeErrorClientException(response, errorBody)
		
		case strings.EqualFold("InvalidParameterException", errorCode):
			return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
		
		case strings.EqualFold("ServerException", errorCode):
			return awsAwsjson11_deserializeErrorServerException(response, errorBody)
		
		default:
			genericError := &smithy.GenericAPIError{
				Code: errorCode,
				Message: errorMessage,
			}
			return genericError
		
	}
}

type awsAwsjson11_deserializeOpDeleteTaskSet struct {
}

func (*awsAwsjson11_deserializeOpDeleteTaskSet) ID() string {
	return "OperationDeserializer"
}

func (m *awsAwsjson11_deserializeOpDeleteTaskSet) 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, awsAwsjson11_deserializeOpErrorDeleteTaskSet(response, &metadata)
	}
	output := &DeleteTaskSetOutput{}
	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 = awsAwsjson11_deserializeOpDocumentDeleteTaskSetOutput(&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 awsAwsjson11_deserializeOpErrorDeleteTaskSet(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("AccessDeniedException", errorCode):
			return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
		
		case strings.EqualFold("ClientException", errorCode):
			return awsAwsjson11_deserializeErrorClientException(response, errorBody)
		
		case strings.EqualFold("ClusterNotFoundException", errorCode):
			return awsAwsjson11_deserializeErrorClusterNotFoundException(response, errorBody)
		
		case strings.EqualFold("InvalidParameterException", errorCode):
			return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
		
		case strings.EqualFold("ServerException", errorCode):
			return awsAwsjson11_deserializeErrorServerException(response, errorBody)
		
		case strings.EqualFold("ServiceNotActiveException", errorCode):
			return awsAwsjson11_deserializeErrorServiceNotActiveException(response, errorBody)
		
		case strings.EqualFold("ServiceNotFoundException", errorCode):
			return awsAwsjson11_deserializeErrorServiceNotFoundException(response, errorBody)
		
		case strings.EqualFold("TaskSetNotFoundException", errorCode):
			return awsAwsjson11_deserializeErrorTaskSetNotFoundException(response, errorBody)
		
		case strings.EqualFold("UnsupportedFeatureException", errorCode):
			return awsAwsjson11_deserializeErrorUnsupportedFeatureException(response, errorBody)
		
		default:
			genericError := &smithy.GenericAPIError{
				Code: errorCode,
				Message: errorMessage,
			}
			return genericError
		
	}
}

type awsAwsjson11_deserializeOpDeregisterContainerInstance struct {
}

func (*awsAwsjson11_deserializeOpDeregisterContainerInstance) ID() string {
	return "OperationDeserializer"
}

func (m *awsAwsjson11_deserializeOpDeregisterContainerInstance) 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, awsAwsjson11_deserializeOpErrorDeregisterContainerInstance(response, &metadata)
	}
	output := &DeregisterContainerInstanceOutput{}
	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 = awsAwsjson11_deserializeOpDocumentDeregisterContainerInstanceOutput(&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 awsAwsjson11_deserializeOpErrorDeregisterContainerInstance(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("ClientException", errorCode):
			return awsAwsjson11_deserializeErrorClientException(response, errorBody)
		
		case strings.EqualFold("ClusterNotFoundException", errorCode):
			return awsAwsjson11_deserializeErrorClusterNotFoundException(response, errorBody)
		
		case strings.EqualFold("InvalidParameterException", errorCode):
			return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
		
		case strings.EqualFold("ServerException", errorCode):
			return awsAwsjson11_deserializeErrorServerException(response, errorBody)
		
		default:
			genericError := &smithy.GenericAPIError{
				Code: errorCode,
				Message: errorMessage,
			}
			return genericError
		
	}
}

type awsAwsjson11_deserializeOpDeregisterTaskDefinition struct {
}

func (*awsAwsjson11_deserializeOpDeregisterTaskDefinition) ID() string {
	return "OperationDeserializer"
}

func (m *awsAwsjson11_deserializeOpDeregisterTaskDefinition) 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, awsAwsjson11_deserializeOpErrorDeregisterTaskDefinition(response, &metadata)
	}
	output := &DeregisterTaskDefinitionOutput{}
	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 = awsAwsjson11_deserializeOpDocumentDeregisterTaskDefinitionOutput(&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 awsAwsjson11_deserializeOpErrorDeregisterTaskDefinition(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("ClientException", errorCode):
			return awsAwsjson11_deserializeErrorClientException(response, errorBody)
		
		case strings.EqualFold("InvalidParameterException", errorCode):
			return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
		
		case strings.EqualFold("ServerException", errorCode):
			return awsAwsjson11_deserializeErrorServerException(response, errorBody)
		
		default:
			genericError := &smithy.GenericAPIError{
				Code: errorCode,
				Message: errorMessage,
			}
			return genericError
		
	}
}

type awsAwsjson11_deserializeOpDescribeCapacityProviders struct {
}

func (*awsAwsjson11_deserializeOpDescribeCapacityProviders) ID() string {
	return "OperationDeserializer"
}

func (m *awsAwsjson11_deserializeOpDescribeCapacityProviders) 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, awsAwsjson11_deserializeOpErrorDescribeCapacityProviders(response, &metadata)
	}
	output := &DescribeCapacityProvidersOutput{}
	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 = awsAwsjson11_deserializeOpDocumentDescribeCapacityProvidersOutput(&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 awsAwsjson11_deserializeOpErrorDescribeCapacityProviders(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("ClientException", errorCode):
			return awsAwsjson11_deserializeErrorClientException(response, errorBody)
		
		case strings.EqualFold("InvalidParameterException", errorCode):
			return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
		
		case strings.EqualFold("ServerException", errorCode):
			return awsAwsjson11_deserializeErrorServerException(response, errorBody)
		
		default:
			genericError := &smithy.GenericAPIError{
				Code: errorCode,
				Message: errorMessage,
			}
			return genericError
		
	}
}

type awsAwsjson11_deserializeOpDescribeClusters struct {
}

func (*awsAwsjson11_deserializeOpDescribeClusters) ID() string {
	return "OperationDeserializer"
}

func (m *awsAwsjson11_deserializeOpDescribeClusters) 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, awsAwsjson11_deserializeOpErrorDescribeClusters(response, &metadata)
	}
	output := &DescribeClustersOutput{}
	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 = awsAwsjson11_deserializeOpDocumentDescribeClustersOutput(&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 awsAwsjson11_deserializeOpErrorDescribeClusters(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("ClientException", errorCode):
			return awsAwsjson11_deserializeErrorClientException(response, errorBody)
		
		case strings.EqualFold("InvalidParameterException", errorCode):
			return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
		
		case strings.EqualFold("ServerException", errorCode):
			return awsAwsjson11_deserializeErrorServerException(response, errorBody)
		
		default:
			genericError := &smithy.GenericAPIError{
				Code: errorCode,
				Message: errorMessage,
			}
			return genericError
		
	}
}

type awsAwsjson11_deserializeOpDescribeContainerInstances struct {
}

func (*awsAwsjson11_deserializeOpDescribeContainerInstances) ID() string {
	return "OperationDeserializer"
}

func (m *awsAwsjson11_deserializeOpDescribeContainerInstances) 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, awsAwsjson11_deserializeOpErrorDescribeContainerInstances(response, &metadata)
	}
	output := &DescribeContainerInstancesOutput{}
	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 = awsAwsjson11_deserializeOpDocumentDescribeContainerInstancesOutput(&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 awsAwsjson11_deserializeOpErrorDescribeContainerInstances(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("ClientException", errorCode):
			return awsAwsjson11_deserializeErrorClientException(response, errorBody)
		
		case strings.EqualFold("ClusterNotFoundException", errorCode):
			return awsAwsjson11_deserializeErrorClusterNotFoundException(response, errorBody)
		
		case strings.EqualFold("InvalidParameterException", errorCode):
			return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
		
		case strings.EqualFold("ServerException", errorCode):
			return awsAwsjson11_deserializeErrorServerException(response, errorBody)
		
		default:
			genericError := &smithy.GenericAPIError{
				Code: errorCode,
				Message: errorMessage,
			}
			return genericError
		
	}
}

type awsAwsjson11_deserializeOpDescribeServices struct {
}

func (*awsAwsjson11_deserializeOpDescribeServices) ID() string {
	return "OperationDeserializer"
}

func (m *awsAwsjson11_deserializeOpDescribeServices) 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, awsAwsjson11_deserializeOpErrorDescribeServices(response, &metadata)
	}
	output := &DescribeServicesOutput{}
	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 = awsAwsjson11_deserializeOpDocumentDescribeServicesOutput(&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 awsAwsjson11_deserializeOpErrorDescribeServices(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("ClientException", errorCode):
			return awsAwsjson11_deserializeErrorClientException(response, errorBody)
		
		case strings.EqualFold("ClusterNotFoundException", errorCode):
			return awsAwsjson11_deserializeErrorClusterNotFoundException(response, errorBody)
		
		case strings.EqualFold("InvalidParameterException", errorCode):
			return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
		
		case strings.EqualFold("ServerException", errorCode):
			return awsAwsjson11_deserializeErrorServerException(response, errorBody)
		
		default:
			genericError := &smithy.GenericAPIError{
				Code: errorCode,
				Message: errorMessage,
			}
			return genericError
		
	}
}

type awsAwsjson11_deserializeOpDescribeTaskDefinition struct {
}

func (*awsAwsjson11_deserializeOpDescribeTaskDefinition) ID() string {
	return "OperationDeserializer"
}

func (m *awsAwsjson11_deserializeOpDescribeTaskDefinition) 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, awsAwsjson11_deserializeOpErrorDescribeTaskDefinition(response, &metadata)
	}
	output := &DescribeTaskDefinitionOutput{}
	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 = awsAwsjson11_deserializeOpDocumentDescribeTaskDefinitionOutput(&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 awsAwsjson11_deserializeOpErrorDescribeTaskDefinition(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("ClientException", errorCode):
			return awsAwsjson11_deserializeErrorClientException(response, errorBody)
		
		case strings.EqualFold("InvalidParameterException", errorCode):
			return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
		
		case strings.EqualFold("ServerException", errorCode):
			return awsAwsjson11_deserializeErrorServerException(response, errorBody)
		
		default:
			genericError := &smithy.GenericAPIError{
				Code: errorCode,
				Message: errorMessage,
			}
			return genericError
		
	}
}

type awsAwsjson11_deserializeOpDescribeTasks struct {
}

func (*awsAwsjson11_deserializeOpDescribeTasks) ID() string {
	return "OperationDeserializer"
}

func (m *awsAwsjson11_deserializeOpDescribeTasks) 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, awsAwsjson11_deserializeOpErrorDescribeTasks(response, &metadata)
	}
	output := &DescribeTasksOutput{}
	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 = awsAwsjson11_deserializeOpDocumentDescribeTasksOutput(&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 awsAwsjson11_deserializeOpErrorDescribeTasks(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("ClientException", errorCode):
			return awsAwsjson11_deserializeErrorClientException(response, errorBody)
		
		case strings.EqualFold("ClusterNotFoundException", errorCode):
			return awsAwsjson11_deserializeErrorClusterNotFoundException(response, errorBody)
		
		case strings.EqualFold("InvalidParameterException", errorCode):
			return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
		
		case strings.EqualFold("ServerException", errorCode):
			return awsAwsjson11_deserializeErrorServerException(response, errorBody)
		
		default:
			genericError := &smithy.GenericAPIError{
				Code: errorCode,
				Message: errorMessage,
			}
			return genericError
		
	}
}

type awsAwsjson11_deserializeOpDescribeTaskSets struct {
}

func (*awsAwsjson11_deserializeOpDescribeTaskSets) ID() string {
	return "OperationDeserializer"
}

func (m *awsAwsjson11_deserializeOpDescribeTaskSets) 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, awsAwsjson11_deserializeOpErrorDescribeTaskSets(response, &metadata)
	}
	output := &DescribeTaskSetsOutput{}
	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 = awsAwsjson11_deserializeOpDocumentDescribeTaskSetsOutput(&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 awsAwsjson11_deserializeOpErrorDescribeTaskSets(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("AccessDeniedException", errorCode):
			return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
		
		case strings.EqualFold("ClientException", errorCode):
			return awsAwsjson11_deserializeErrorClientException(response, errorBody)
		
		case strings.EqualFold("ClusterNotFoundException", errorCode):
			return awsAwsjson11_deserializeErrorClusterNotFoundException(response, errorBody)
		
		case strings.EqualFold("InvalidParameterException", errorCode):
			return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
		
		case strings.EqualFold("ServerException", errorCode):
			return awsAwsjson11_deserializeErrorServerException(response, errorBody)
		
		case strings.EqualFold("ServiceNotActiveException", errorCode):
			return awsAwsjson11_deserializeErrorServiceNotActiveException(response, errorBody)
		
		case strings.EqualFold("ServiceNotFoundException", errorCode):
			return awsAwsjson11_deserializeErrorServiceNotFoundException(response, errorBody)
		
		case strings.EqualFold("UnsupportedFeatureException", errorCode):
			return awsAwsjson11_deserializeErrorUnsupportedFeatureException(response, errorBody)
		
		default:
			genericError := &smithy.GenericAPIError{
				Code: errorCode,
				Message: errorMessage,
			}
			return genericError
		
	}
}

type awsAwsjson11_deserializeOpDiscoverPollEndpoint struct {
}

func (*awsAwsjson11_deserializeOpDiscoverPollEndpoint) ID() string {
	return "OperationDeserializer"
}

func (m *awsAwsjson11_deserializeOpDiscoverPollEndpoint) 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, awsAwsjson11_deserializeOpErrorDiscoverPollEndpoint(response, &metadata)
	}
	output := &DiscoverPollEndpointOutput{}
	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 = awsAwsjson11_deserializeOpDocumentDiscoverPollEndpointOutput(&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 awsAwsjson11_deserializeOpErrorDiscoverPollEndpoint(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("ClientException", errorCode):
			return awsAwsjson11_deserializeErrorClientException(response, errorBody)
		
		case strings.EqualFold("ServerException", errorCode):
			return awsAwsjson11_deserializeErrorServerException(response, errorBody)
		
		default:
			genericError := &smithy.GenericAPIError{
				Code: errorCode,
				Message: errorMessage,
			}
			return genericError
		
	}
}

type awsAwsjson11_deserializeOpExecuteCommand struct {
}

func (*awsAwsjson11_deserializeOpExecuteCommand) ID() string {
	return "OperationDeserializer"
}

func (m *awsAwsjson11_deserializeOpExecuteCommand) 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, awsAwsjson11_deserializeOpErrorExecuteCommand(response, &metadata)
	}
	output := &ExecuteCommandOutput{}
	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 = awsAwsjson11_deserializeOpDocumentExecuteCommandOutput(&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 awsAwsjson11_deserializeOpErrorExecuteCommand(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("AccessDeniedException", errorCode):
			return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
		
		case strings.EqualFold("ClientException", errorCode):
			return awsAwsjson11_deserializeErrorClientException(response, errorBody)
		
		case strings.EqualFold("ClusterNotFoundException", errorCode):
			return awsAwsjson11_deserializeErrorClusterNotFoundException(response, errorBody)
		
		case strings.EqualFold("InvalidParameterException", errorCode):
			return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
		
		case strings.EqualFold("ServerException", errorCode):
			return awsAwsjson11_deserializeErrorServerException(response, errorBody)
		
		case strings.EqualFold("TargetNotConnectedException", errorCode):
			return awsAwsjson11_deserializeErrorTargetNotConnectedException(response, errorBody)
		
		default:
			genericError := &smithy.GenericAPIError{
				Code: errorCode,
				Message: errorMessage,
			}
			return genericError
		
	}
}

type awsAwsjson11_deserializeOpGetTaskProtection struct {
}

func (*awsAwsjson11_deserializeOpGetTaskProtection) ID() string {
	return "OperationDeserializer"
}

func (m *awsAwsjson11_deserializeOpGetTaskProtection) 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, awsAwsjson11_deserializeOpErrorGetTaskProtection(response, &metadata)
	}
	output := &GetTaskProtectionOutput{}
	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 = awsAwsjson11_deserializeOpDocumentGetTaskProtectionOutput(&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 awsAwsjson11_deserializeOpErrorGetTaskProtection(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("AccessDeniedException", errorCode):
			return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
		
		case strings.EqualFold("ClientException", errorCode):
			return awsAwsjson11_deserializeErrorClientException(response, errorBody)
		
		case strings.EqualFold("ClusterNotFoundException", errorCode):
			return awsAwsjson11_deserializeErrorClusterNotFoundException(response, errorBody)
		
		case strings.EqualFold("InvalidParameterException", errorCode):
			return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
		
		case strings.EqualFold("ResourceNotFoundException", errorCode):
			return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
		
		case strings.EqualFold("ServerException", errorCode):
			return awsAwsjson11_deserializeErrorServerException(response, errorBody)
		
		case strings.EqualFold("UnsupportedFeatureException", errorCode):
			return awsAwsjson11_deserializeErrorUnsupportedFeatureException(response, errorBody)
		
		default:
			genericError := &smithy.GenericAPIError{
				Code: errorCode,
				Message: errorMessage,
			}
			return genericError
		
	}
}

type awsAwsjson11_deserializeOpListAccountSettings struct {
}

func (*awsAwsjson11_deserializeOpListAccountSettings) ID() string {
	return "OperationDeserializer"
}

func (m *awsAwsjson11_deserializeOpListAccountSettings) 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, awsAwsjson11_deserializeOpErrorListAccountSettings(response, &metadata)
	}
	output := &ListAccountSettingsOutput{}
	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 = awsAwsjson11_deserializeOpDocumentListAccountSettingsOutput(&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 awsAwsjson11_deserializeOpErrorListAccountSettings(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("ClientException", errorCode):
			return awsAwsjson11_deserializeErrorClientException(response, errorBody)
		
		case strings.EqualFold("InvalidParameterException", errorCode):
			return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
		
		case strings.EqualFold("ServerException", errorCode):
			return awsAwsjson11_deserializeErrorServerException(response, errorBody)
		
		default:
			genericError := &smithy.GenericAPIError{
				Code: errorCode,
				Message: errorMessage,
			}
			return genericError
		
	}
}

type awsAwsjson11_deserializeOpListAttributes struct {
}

func (*awsAwsjson11_deserializeOpListAttributes) ID() string {
	return "OperationDeserializer"
}

func (m *awsAwsjson11_deserializeOpListAttributes) 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, awsAwsjson11_deserializeOpErrorListAttributes(response, &metadata)
	}
	output := &ListAttributesOutput{}
	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 = awsAwsjson11_deserializeOpDocumentListAttributesOutput(&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 awsAwsjson11_deserializeOpErrorListAttributes(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("ClusterNotFoundException", errorCode):
			return awsAwsjson11_deserializeErrorClusterNotFoundException(response, errorBody)
		
		case strings.EqualFold("InvalidParameterException", errorCode):
			return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
		
		default:
			genericError := &smithy.GenericAPIError{
				Code: errorCode,
				Message: errorMessage,
			}
			return genericError
		
	}
}

type awsAwsjson11_deserializeOpListClusters struct {
}

func (*awsAwsjson11_deserializeOpListClusters) ID() string {
	return "OperationDeserializer"
}

func (m *awsAwsjson11_deserializeOpListClusters) 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, awsAwsjson11_deserializeOpErrorListClusters(response, &metadata)
	}
	output := &ListClustersOutput{}
	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 = awsAwsjson11_deserializeOpDocumentListClustersOutput(&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 awsAwsjson11_deserializeOpErrorListClusters(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("ClientException", errorCode):
			return awsAwsjson11_deserializeErrorClientException(response, errorBody)
		
		case strings.EqualFold("InvalidParameterException", errorCode):
			return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
		
		case strings.EqualFold("ServerException", errorCode):
			return awsAwsjson11_deserializeErrorServerException(response, errorBody)
		
		default:
			genericError := &smithy.GenericAPIError{
				Code: errorCode,
				Message: errorMessage,
			}
			return genericError
		
	}
}

type awsAwsjson11_deserializeOpListContainerInstances struct {
}

func (*awsAwsjson11_deserializeOpListContainerInstances) ID() string {
	return "OperationDeserializer"
}

func (m *awsAwsjson11_deserializeOpListContainerInstances) 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, awsAwsjson11_deserializeOpErrorListContainerInstances(response, &metadata)
	}
	output := &ListContainerInstancesOutput{}
	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 = awsAwsjson11_deserializeOpDocumentListContainerInstancesOutput(&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 awsAwsjson11_deserializeOpErrorListContainerInstances(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("ClientException", errorCode):
			return awsAwsjson11_deserializeErrorClientException(response, errorBody)
		
		case strings.EqualFold("ClusterNotFoundException", errorCode):
			return awsAwsjson11_deserializeErrorClusterNotFoundException(response, errorBody)
		
		case strings.EqualFold("InvalidParameterException", errorCode):
			return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
		
		case strings.EqualFold("ServerException", errorCode):
			return awsAwsjson11_deserializeErrorServerException(response, errorBody)
		
		default:
			genericError := &smithy.GenericAPIError{
				Code: errorCode,
				Message: errorMessage,
			}
			return genericError
		
	}
}

type awsAwsjson11_deserializeOpListServices struct {
}

func (*awsAwsjson11_deserializeOpListServices) ID() string {
	return "OperationDeserializer"
}

func (m *awsAwsjson11_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, awsAwsjson11_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 = awsAwsjson11_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 awsAwsjson11_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("ClientException", errorCode):
			return awsAwsjson11_deserializeErrorClientException(response, errorBody)
		
		case strings.EqualFold("ClusterNotFoundException", errorCode):
			return awsAwsjson11_deserializeErrorClusterNotFoundException(response, errorBody)
		
		case strings.EqualFold("InvalidParameterException", errorCode):
			return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
		
		case strings.EqualFold("ServerException", errorCode):
			return awsAwsjson11_deserializeErrorServerException(response, errorBody)
		
		default:
			genericError := &smithy.GenericAPIError{
				Code: errorCode,
				Message: errorMessage,
			}
			return genericError
		
	}
}

type awsAwsjson11_deserializeOpListServicesByNamespace struct {
}

func (*awsAwsjson11_deserializeOpListServicesByNamespace) ID() string {
	return "OperationDeserializer"
}

func (m *awsAwsjson11_deserializeOpListServicesByNamespace) 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, awsAwsjson11_deserializeOpErrorListServicesByNamespace(response, &metadata)
	}
	output := &ListServicesByNamespaceOutput{}
	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 = awsAwsjson11_deserializeOpDocumentListServicesByNamespaceOutput(&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 awsAwsjson11_deserializeOpErrorListServicesByNamespace(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("ClientException", errorCode):
			return awsAwsjson11_deserializeErrorClientException(response, errorBody)
		
		case strings.EqualFold("InvalidParameterException", errorCode):
			return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
		
		case strings.EqualFold("NamespaceNotFoundException", errorCode):
			return awsAwsjson11_deserializeErrorNamespaceNotFoundException(response, errorBody)
		
		case strings.EqualFold("ServerException", errorCode):
			return awsAwsjson11_deserializeErrorServerException(response, errorBody)
		
		default:
			genericError := &smithy.GenericAPIError{
				Code: errorCode,
				Message: errorMessage,
			}
			return genericError
		
	}
}

type awsAwsjson11_deserializeOpListTagsForResource struct {
}

func (*awsAwsjson11_deserializeOpListTagsForResource) ID() string {
	return "OperationDeserializer"
}

func (m *awsAwsjson11_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, awsAwsjson11_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 = awsAwsjson11_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 awsAwsjson11_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("ClientException", errorCode):
			return awsAwsjson11_deserializeErrorClientException(response, errorBody)
		
		case strings.EqualFold("ClusterNotFoundException", errorCode):
			return awsAwsjson11_deserializeErrorClusterNotFoundException(response, errorBody)
		
		case strings.EqualFold("InvalidParameterException", errorCode):
			return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
		
		case strings.EqualFold("ServerException", errorCode):
			return awsAwsjson11_deserializeErrorServerException(response, errorBody)
		
		default:
			genericError := &smithy.GenericAPIError{
				Code: errorCode,
				Message: errorMessage,
			}
			return genericError
		
	}
}

type awsAwsjson11_deserializeOpListTaskDefinitionFamilies struct {
}

func (*awsAwsjson11_deserializeOpListTaskDefinitionFamilies) ID() string {
	return "OperationDeserializer"
}

func (m *awsAwsjson11_deserializeOpListTaskDefinitionFamilies) 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, awsAwsjson11_deserializeOpErrorListTaskDefinitionFamilies(response, &metadata)
	}
	output := &ListTaskDefinitionFamiliesOutput{}
	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 = awsAwsjson11_deserializeOpDocumentListTaskDefinitionFamiliesOutput(&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 awsAwsjson11_deserializeOpErrorListTaskDefinitionFamilies(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("ClientException", errorCode):
			return awsAwsjson11_deserializeErrorClientException(response, errorBody)
		
		case strings.EqualFold("InvalidParameterException", errorCode):
			return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
		
		case strings.EqualFold("ServerException", errorCode):
			return awsAwsjson11_deserializeErrorServerException(response, errorBody)
		
		default:
			genericError := &smithy.GenericAPIError{
				Code: errorCode,
				Message: errorMessage,
			}
			return genericError
		
	}
}

type awsAwsjson11_deserializeOpListTaskDefinitions struct {
}

func (*awsAwsjson11_deserializeOpListTaskDefinitions) ID() string {
	return "OperationDeserializer"
}

func (m *awsAwsjson11_deserializeOpListTaskDefinitions) 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, awsAwsjson11_deserializeOpErrorListTaskDefinitions(response, &metadata)
	}
	output := &ListTaskDefinitionsOutput{}
	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 = awsAwsjson11_deserializeOpDocumentListTaskDefinitionsOutput(&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 awsAwsjson11_deserializeOpErrorListTaskDefinitions(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("ClientException", errorCode):
			return awsAwsjson11_deserializeErrorClientException(response, errorBody)
		
		case strings.EqualFold("InvalidParameterException", errorCode):
			return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
		
		case strings.EqualFold("ServerException", errorCode):
			return awsAwsjson11_deserializeErrorServerException(response, errorBody)
		
		default:
			genericError := &smithy.GenericAPIError{
				Code: errorCode,
				Message: errorMessage,
			}
			return genericError
		
	}
}

type awsAwsjson11_deserializeOpListTasks struct {
}

func (*awsAwsjson11_deserializeOpListTasks) ID() string {
	return "OperationDeserializer"
}

func (m *awsAwsjson11_deserializeOpListTasks) 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, awsAwsjson11_deserializeOpErrorListTasks(response, &metadata)
	}
	output := &ListTasksOutput{}
	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 = awsAwsjson11_deserializeOpDocumentListTasksOutput(&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 awsAwsjson11_deserializeOpErrorListTasks(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("ClientException", errorCode):
			return awsAwsjson11_deserializeErrorClientException(response, errorBody)
		
		case strings.EqualFold("ClusterNotFoundException", errorCode):
			return awsAwsjson11_deserializeErrorClusterNotFoundException(response, errorBody)
		
		case strings.EqualFold("InvalidParameterException", errorCode):
			return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
		
		case strings.EqualFold("ServerException", errorCode):
			return awsAwsjson11_deserializeErrorServerException(response, errorBody)
		
		case strings.EqualFold("ServiceNotFoundException", errorCode):
			return awsAwsjson11_deserializeErrorServiceNotFoundException(response, errorBody)
		
		default:
			genericError := &smithy.GenericAPIError{
				Code: errorCode,
				Message: errorMessage,
			}
			return genericError
		
	}
}

type awsAwsjson11_deserializeOpPutAccountSetting struct {
}

func (*awsAwsjson11_deserializeOpPutAccountSetting) ID() string {
	return "OperationDeserializer"
}

func (m *awsAwsjson11_deserializeOpPutAccountSetting) 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, awsAwsjson11_deserializeOpErrorPutAccountSetting(response, &metadata)
	}
	output := &PutAccountSettingOutput{}
	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 = awsAwsjson11_deserializeOpDocumentPutAccountSettingOutput(&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 awsAwsjson11_deserializeOpErrorPutAccountSetting(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("ClientException", errorCode):
			return awsAwsjson11_deserializeErrorClientException(response, errorBody)
		
		case strings.EqualFold("InvalidParameterException", errorCode):
			return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
		
		case strings.EqualFold("ServerException", errorCode):
			return awsAwsjson11_deserializeErrorServerException(response, errorBody)
		
		default:
			genericError := &smithy.GenericAPIError{
				Code: errorCode,
				Message: errorMessage,
			}
			return genericError
		
	}
}

type awsAwsjson11_deserializeOpPutAccountSettingDefault struct {
}

func (*awsAwsjson11_deserializeOpPutAccountSettingDefault) ID() string {
	return "OperationDeserializer"
}

func (m *awsAwsjson11_deserializeOpPutAccountSettingDefault) 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, awsAwsjson11_deserializeOpErrorPutAccountSettingDefault(response, &metadata)
	}
	output := &PutAccountSettingDefaultOutput{}
	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 = awsAwsjson11_deserializeOpDocumentPutAccountSettingDefaultOutput(&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 awsAwsjson11_deserializeOpErrorPutAccountSettingDefault(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("ClientException", errorCode):
			return awsAwsjson11_deserializeErrorClientException(response, errorBody)
		
		case strings.EqualFold("InvalidParameterException", errorCode):
			return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
		
		case strings.EqualFold("ServerException", errorCode):
			return awsAwsjson11_deserializeErrorServerException(response, errorBody)
		
		default:
			genericError := &smithy.GenericAPIError{
				Code: errorCode,
				Message: errorMessage,
			}
			return genericError
		
	}
}

type awsAwsjson11_deserializeOpPutAttributes struct {
}

func (*awsAwsjson11_deserializeOpPutAttributes) ID() string {
	return "OperationDeserializer"
}

func (m *awsAwsjson11_deserializeOpPutAttributes) 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, awsAwsjson11_deserializeOpErrorPutAttributes(response, &metadata)
	}
	output := &PutAttributesOutput{}
	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 = awsAwsjson11_deserializeOpDocumentPutAttributesOutput(&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 awsAwsjson11_deserializeOpErrorPutAttributes(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("AttributeLimitExceededException", errorCode):
			return awsAwsjson11_deserializeErrorAttributeLimitExceededException(response, errorBody)
		
		case strings.EqualFold("ClusterNotFoundException", errorCode):
			return awsAwsjson11_deserializeErrorClusterNotFoundException(response, errorBody)
		
		case strings.EqualFold("InvalidParameterException", errorCode):
			return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
		
		case strings.EqualFold("TargetNotFoundException", errorCode):
			return awsAwsjson11_deserializeErrorTargetNotFoundException(response, errorBody)
		
		default:
			genericError := &smithy.GenericAPIError{
				Code: errorCode,
				Message: errorMessage,
			}
			return genericError
		
	}
}

type awsAwsjson11_deserializeOpPutClusterCapacityProviders struct {
}

func (*awsAwsjson11_deserializeOpPutClusterCapacityProviders) ID() string {
	return "OperationDeserializer"
}

func (m *awsAwsjson11_deserializeOpPutClusterCapacityProviders) 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, awsAwsjson11_deserializeOpErrorPutClusterCapacityProviders(response, &metadata)
	}
	output := &PutClusterCapacityProvidersOutput{}
	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 = awsAwsjson11_deserializeOpDocumentPutClusterCapacityProvidersOutput(&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 awsAwsjson11_deserializeOpErrorPutClusterCapacityProviders(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("ClientException", errorCode):
			return awsAwsjson11_deserializeErrorClientException(response, errorBody)
		
		case strings.EqualFold("ClusterNotFoundException", errorCode):
			return awsAwsjson11_deserializeErrorClusterNotFoundException(response, errorBody)
		
		case strings.EqualFold("InvalidParameterException", errorCode):
			return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
		
		case strings.EqualFold("ResourceInUseException", errorCode):
			return awsAwsjson11_deserializeErrorResourceInUseException(response, errorBody)
		
		case strings.EqualFold("ServerException", errorCode):
			return awsAwsjson11_deserializeErrorServerException(response, errorBody)
		
		case strings.EqualFold("UpdateInProgressException", errorCode):
			return awsAwsjson11_deserializeErrorUpdateInProgressException(response, errorBody)
		
		default:
			genericError := &smithy.GenericAPIError{
				Code: errorCode,
				Message: errorMessage,
			}
			return genericError
		
	}
}

type awsAwsjson11_deserializeOpRegisterContainerInstance struct {
}

func (*awsAwsjson11_deserializeOpRegisterContainerInstance) ID() string {
	return "OperationDeserializer"
}

func (m *awsAwsjson11_deserializeOpRegisterContainerInstance) 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, awsAwsjson11_deserializeOpErrorRegisterContainerInstance(response, &metadata)
	}
	output := &RegisterContainerInstanceOutput{}
	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 = awsAwsjson11_deserializeOpDocumentRegisterContainerInstanceOutput(&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 awsAwsjson11_deserializeOpErrorRegisterContainerInstance(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("ClientException", errorCode):
			return awsAwsjson11_deserializeErrorClientException(response, errorBody)
		
		case strings.EqualFold("InvalidParameterException", errorCode):
			return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
		
		case strings.EqualFold("ServerException", errorCode):
			return awsAwsjson11_deserializeErrorServerException(response, errorBody)
		
		default:
			genericError := &smithy.GenericAPIError{
				Code: errorCode,
				Message: errorMessage,
			}
			return genericError
		
	}
}

type awsAwsjson11_deserializeOpRegisterTaskDefinition struct {
}

func (*awsAwsjson11_deserializeOpRegisterTaskDefinition) ID() string {
	return "OperationDeserializer"
}

func (m *awsAwsjson11_deserializeOpRegisterTaskDefinition) 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, awsAwsjson11_deserializeOpErrorRegisterTaskDefinition(response, &metadata)
	}
	output := &RegisterTaskDefinitionOutput{}
	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 = awsAwsjson11_deserializeOpDocumentRegisterTaskDefinitionOutput(&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 awsAwsjson11_deserializeOpErrorRegisterTaskDefinition(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("ClientException", errorCode):
			return awsAwsjson11_deserializeErrorClientException(response, errorBody)
		
		case strings.EqualFold("InvalidParameterException", errorCode):
			return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
		
		case strings.EqualFold("ServerException", errorCode):
			return awsAwsjson11_deserializeErrorServerException(response, errorBody)
		
		default:
			genericError := &smithy.GenericAPIError{
				Code: errorCode,
				Message: errorMessage,
			}
			return genericError
		
	}
}

type awsAwsjson11_deserializeOpRunTask struct {
}

func (*awsAwsjson11_deserializeOpRunTask) ID() string {
	return "OperationDeserializer"
}

func (m *awsAwsjson11_deserializeOpRunTask) 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, awsAwsjson11_deserializeOpErrorRunTask(response, &metadata)
	}
	output := &RunTaskOutput{}
	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 = awsAwsjson11_deserializeOpDocumentRunTaskOutput(&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 awsAwsjson11_deserializeOpErrorRunTask(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("AccessDeniedException", errorCode):
			return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
		
		case strings.EqualFold("BlockedException", errorCode):
			return awsAwsjson11_deserializeErrorBlockedException(response, errorBody)
		
		case strings.EqualFold("ClientException", errorCode):
			return awsAwsjson11_deserializeErrorClientException(response, errorBody)
		
		case strings.EqualFold("ClusterNotFoundException", errorCode):
			return awsAwsjson11_deserializeErrorClusterNotFoundException(response, errorBody)
		
		case strings.EqualFold("ConflictException", errorCode):
			return awsAwsjson11_deserializeErrorConflictException(response, errorBody)
		
		case strings.EqualFold("InvalidParameterException", errorCode):
			return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
		
		case strings.EqualFold("PlatformTaskDefinitionIncompatibilityException", errorCode):
			return awsAwsjson11_deserializeErrorPlatformTaskDefinitionIncompatibilityException(response, errorBody)
		
		case strings.EqualFold("PlatformUnknownException", errorCode):
			return awsAwsjson11_deserializeErrorPlatformUnknownException(response, errorBody)
		
		case strings.EqualFold("ServerException", errorCode):
			return awsAwsjson11_deserializeErrorServerException(response, errorBody)
		
		case strings.EqualFold("UnsupportedFeatureException", errorCode):
			return awsAwsjson11_deserializeErrorUnsupportedFeatureException(response, errorBody)
		
		default:
			genericError := &smithy.GenericAPIError{
				Code: errorCode,
				Message: errorMessage,
			}
			return genericError
		
	}
}

type awsAwsjson11_deserializeOpStartTask struct {
}

func (*awsAwsjson11_deserializeOpStartTask) ID() string {
	return "OperationDeserializer"
}

func (m *awsAwsjson11_deserializeOpStartTask) 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, awsAwsjson11_deserializeOpErrorStartTask(response, &metadata)
	}
	output := &StartTaskOutput{}
	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 = awsAwsjson11_deserializeOpDocumentStartTaskOutput(&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 awsAwsjson11_deserializeOpErrorStartTask(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("ClientException", errorCode):
			return awsAwsjson11_deserializeErrorClientException(response, errorBody)
		
		case strings.EqualFold("ClusterNotFoundException", errorCode):
			return awsAwsjson11_deserializeErrorClusterNotFoundException(response, errorBody)
		
		case strings.EqualFold("InvalidParameterException", errorCode):
			return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
		
		case strings.EqualFold("ServerException", errorCode):
			return awsAwsjson11_deserializeErrorServerException(response, errorBody)
		
		case strings.EqualFold("UnsupportedFeatureException", errorCode):
			return awsAwsjson11_deserializeErrorUnsupportedFeatureException(response, errorBody)
		
		default:
			genericError := &smithy.GenericAPIError{
				Code: errorCode,
				Message: errorMessage,
			}
			return genericError
		
	}
}

type awsAwsjson11_deserializeOpStopTask struct {
}

func (*awsAwsjson11_deserializeOpStopTask) ID() string {
	return "OperationDeserializer"
}

func (m *awsAwsjson11_deserializeOpStopTask) 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, awsAwsjson11_deserializeOpErrorStopTask(response, &metadata)
	}
	output := &StopTaskOutput{}
	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 = awsAwsjson11_deserializeOpDocumentStopTaskOutput(&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 awsAwsjson11_deserializeOpErrorStopTask(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("ClientException", errorCode):
			return awsAwsjson11_deserializeErrorClientException(response, errorBody)
		
		case strings.EqualFold("ClusterNotFoundException", errorCode):
			return awsAwsjson11_deserializeErrorClusterNotFoundException(response, errorBody)
		
		case strings.EqualFold("InvalidParameterException", errorCode):
			return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
		
		case strings.EqualFold("ServerException", errorCode):
			return awsAwsjson11_deserializeErrorServerException(response, errorBody)
		
		default:
			genericError := &smithy.GenericAPIError{
				Code: errorCode,
				Message: errorMessage,
			}
			return genericError
		
	}
}

type awsAwsjson11_deserializeOpSubmitAttachmentStateChanges struct {
}

func (*awsAwsjson11_deserializeOpSubmitAttachmentStateChanges) ID() string {
	return "OperationDeserializer"
}

func (m *awsAwsjson11_deserializeOpSubmitAttachmentStateChanges) 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, awsAwsjson11_deserializeOpErrorSubmitAttachmentStateChanges(response, &metadata)
	}
	output := &SubmitAttachmentStateChangesOutput{}
	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 = awsAwsjson11_deserializeOpDocumentSubmitAttachmentStateChangesOutput(&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 awsAwsjson11_deserializeOpErrorSubmitAttachmentStateChanges(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("AccessDeniedException", errorCode):
			return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
		
		case strings.EqualFold("ClientException", errorCode):
			return awsAwsjson11_deserializeErrorClientException(response, errorBody)
		
		case strings.EqualFold("InvalidParameterException", errorCode):
			return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
		
		case strings.EqualFold("ServerException", errorCode):
			return awsAwsjson11_deserializeErrorServerException(response, errorBody)
		
		default:
			genericError := &smithy.GenericAPIError{
				Code: errorCode,
				Message: errorMessage,
			}
			return genericError
		
	}
}

type awsAwsjson11_deserializeOpSubmitContainerStateChange struct {
}

func (*awsAwsjson11_deserializeOpSubmitContainerStateChange) ID() string {
	return "OperationDeserializer"
}

func (m *awsAwsjson11_deserializeOpSubmitContainerStateChange) 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, awsAwsjson11_deserializeOpErrorSubmitContainerStateChange(response, &metadata)
	}
	output := &SubmitContainerStateChangeOutput{}
	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 = awsAwsjson11_deserializeOpDocumentSubmitContainerStateChangeOutput(&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 awsAwsjson11_deserializeOpErrorSubmitContainerStateChange(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("AccessDeniedException", errorCode):
			return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
		
		case strings.EqualFold("ClientException", errorCode):
			return awsAwsjson11_deserializeErrorClientException(response, errorBody)
		
		case strings.EqualFold("ServerException", errorCode):
			return awsAwsjson11_deserializeErrorServerException(response, errorBody)
		
		default:
			genericError := &smithy.GenericAPIError{
				Code: errorCode,
				Message: errorMessage,
			}
			return genericError
		
	}
}

type awsAwsjson11_deserializeOpSubmitTaskStateChange struct {
}

func (*awsAwsjson11_deserializeOpSubmitTaskStateChange) ID() string {
	return "OperationDeserializer"
}

func (m *awsAwsjson11_deserializeOpSubmitTaskStateChange) 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, awsAwsjson11_deserializeOpErrorSubmitTaskStateChange(response, &metadata)
	}
	output := &SubmitTaskStateChangeOutput{}
	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 = awsAwsjson11_deserializeOpDocumentSubmitTaskStateChangeOutput(&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 awsAwsjson11_deserializeOpErrorSubmitTaskStateChange(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("AccessDeniedException", errorCode):
			return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
		
		case strings.EqualFold("ClientException", errorCode):
			return awsAwsjson11_deserializeErrorClientException(response, errorBody)
		
		case strings.EqualFold("InvalidParameterException", errorCode):
			return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
		
		case strings.EqualFold("ServerException", errorCode):
			return awsAwsjson11_deserializeErrorServerException(response, errorBody)
		
		default:
			genericError := &smithy.GenericAPIError{
				Code: errorCode,
				Message: errorMessage,
			}
			return genericError
		
	}
}

type awsAwsjson11_deserializeOpTagResource struct {
}

func (*awsAwsjson11_deserializeOpTagResource) ID() string {
	return "OperationDeserializer"
}

func (m *awsAwsjson11_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, awsAwsjson11_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 = awsAwsjson11_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 awsAwsjson11_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("ClientException", errorCode):
			return awsAwsjson11_deserializeErrorClientException(response, errorBody)
		
		case strings.EqualFold("ClusterNotFoundException", errorCode):
			return awsAwsjson11_deserializeErrorClusterNotFoundException(response, errorBody)
		
		case strings.EqualFold("InvalidParameterException", errorCode):
			return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
		
		case strings.EqualFold("ResourceNotFoundException", errorCode):
			return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
		
		case strings.EqualFold("ServerException", errorCode):
			return awsAwsjson11_deserializeErrorServerException(response, errorBody)
		
		default:
			genericError := &smithy.GenericAPIError{
				Code: errorCode,
				Message: errorMessage,
			}
			return genericError
		
	}
}

type awsAwsjson11_deserializeOpUntagResource struct {
}

func (*awsAwsjson11_deserializeOpUntagResource) ID() string {
	return "OperationDeserializer"
}

func (m *awsAwsjson11_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, awsAwsjson11_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 = awsAwsjson11_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 awsAwsjson11_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("ClientException", errorCode):
			return awsAwsjson11_deserializeErrorClientException(response, errorBody)
		
		case strings.EqualFold("ClusterNotFoundException", errorCode):
			return awsAwsjson11_deserializeErrorClusterNotFoundException(response, errorBody)
		
		case strings.EqualFold("InvalidParameterException", errorCode):
			return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
		
		case strings.EqualFold("ResourceNotFoundException", errorCode):
			return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
		
		case strings.EqualFold("ServerException", errorCode):
			return awsAwsjson11_deserializeErrorServerException(response, errorBody)
		
		default:
			genericError := &smithy.GenericAPIError{
				Code: errorCode,
				Message: errorMessage,
			}
			return genericError
		
	}
}

type awsAwsjson11_deserializeOpUpdateCapacityProvider struct {
}

func (*awsAwsjson11_deserializeOpUpdateCapacityProvider) ID() string {
	return "OperationDeserializer"
}

func (m *awsAwsjson11_deserializeOpUpdateCapacityProvider) 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, awsAwsjson11_deserializeOpErrorUpdateCapacityProvider(response, &metadata)
	}
	output := &UpdateCapacityProviderOutput{}
	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 = awsAwsjson11_deserializeOpDocumentUpdateCapacityProviderOutput(&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 awsAwsjson11_deserializeOpErrorUpdateCapacityProvider(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("ClientException", errorCode):
			return awsAwsjson11_deserializeErrorClientException(response, errorBody)
		
		case strings.EqualFold("InvalidParameterException", errorCode):
			return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
		
		case strings.EqualFold("ServerException", errorCode):
			return awsAwsjson11_deserializeErrorServerException(response, errorBody)
		
		default:
			genericError := &smithy.GenericAPIError{
				Code: errorCode,
				Message: errorMessage,
			}
			return genericError
		
	}
}

type awsAwsjson11_deserializeOpUpdateCluster struct {
}

func (*awsAwsjson11_deserializeOpUpdateCluster) ID() string {
	return "OperationDeserializer"
}

func (m *awsAwsjson11_deserializeOpUpdateCluster) 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, awsAwsjson11_deserializeOpErrorUpdateCluster(response, &metadata)
	}
	output := &UpdateClusterOutput{}
	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 = awsAwsjson11_deserializeOpDocumentUpdateClusterOutput(&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 awsAwsjson11_deserializeOpErrorUpdateCluster(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("ClientException", errorCode):
			return awsAwsjson11_deserializeErrorClientException(response, errorBody)
		
		case strings.EqualFold("ClusterNotFoundException", errorCode):
			return awsAwsjson11_deserializeErrorClusterNotFoundException(response, errorBody)
		
		case strings.EqualFold("InvalidParameterException", errorCode):
			return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
		
		case strings.EqualFold("NamespaceNotFoundException", errorCode):
			return awsAwsjson11_deserializeErrorNamespaceNotFoundException(response, errorBody)
		
		case strings.EqualFold("ServerException", errorCode):
			return awsAwsjson11_deserializeErrorServerException(response, errorBody)
		
		default:
			genericError := &smithy.GenericAPIError{
				Code: errorCode,
				Message: errorMessage,
			}
			return genericError
		
	}
}

type awsAwsjson11_deserializeOpUpdateClusterSettings struct {
}

func (*awsAwsjson11_deserializeOpUpdateClusterSettings) ID() string {
	return "OperationDeserializer"
}

func (m *awsAwsjson11_deserializeOpUpdateClusterSettings) 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, awsAwsjson11_deserializeOpErrorUpdateClusterSettings(response, &metadata)
	}
	output := &UpdateClusterSettingsOutput{}
	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 = awsAwsjson11_deserializeOpDocumentUpdateClusterSettingsOutput(&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 awsAwsjson11_deserializeOpErrorUpdateClusterSettings(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("ClientException", errorCode):
			return awsAwsjson11_deserializeErrorClientException(response, errorBody)
		
		case strings.EqualFold("ClusterNotFoundException", errorCode):
			return awsAwsjson11_deserializeErrorClusterNotFoundException(response, errorBody)
		
		case strings.EqualFold("InvalidParameterException", errorCode):
			return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
		
		case strings.EqualFold("ServerException", errorCode):
			return awsAwsjson11_deserializeErrorServerException(response, errorBody)
		
		default:
			genericError := &smithy.GenericAPIError{
				Code: errorCode,
				Message: errorMessage,
			}
			return genericError
		
	}
}

type awsAwsjson11_deserializeOpUpdateContainerAgent struct {
}

func (*awsAwsjson11_deserializeOpUpdateContainerAgent) ID() string {
	return "OperationDeserializer"
}

func (m *awsAwsjson11_deserializeOpUpdateContainerAgent) 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, awsAwsjson11_deserializeOpErrorUpdateContainerAgent(response, &metadata)
	}
	output := &UpdateContainerAgentOutput{}
	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 = awsAwsjson11_deserializeOpDocumentUpdateContainerAgentOutput(&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 awsAwsjson11_deserializeOpErrorUpdateContainerAgent(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("ClientException", errorCode):
			return awsAwsjson11_deserializeErrorClientException(response, errorBody)
		
		case strings.EqualFold("ClusterNotFoundException", errorCode):
			return awsAwsjson11_deserializeErrorClusterNotFoundException(response, errorBody)
		
		case strings.EqualFold("InvalidParameterException", errorCode):
			return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
		
		case strings.EqualFold("MissingVersionException", errorCode):
			return awsAwsjson11_deserializeErrorMissingVersionException(response, errorBody)
		
		case strings.EqualFold("NoUpdateAvailableException", errorCode):
			return awsAwsjson11_deserializeErrorNoUpdateAvailableException(response, errorBody)
		
		case strings.EqualFold("ServerException", errorCode):
			return awsAwsjson11_deserializeErrorServerException(response, errorBody)
		
		case strings.EqualFold("UpdateInProgressException", errorCode):
			return awsAwsjson11_deserializeErrorUpdateInProgressException(response, errorBody)
		
		default:
			genericError := &smithy.GenericAPIError{
				Code: errorCode,
				Message: errorMessage,
			}
			return genericError
		
	}
}

type awsAwsjson11_deserializeOpUpdateContainerInstancesState struct {
}

func (*awsAwsjson11_deserializeOpUpdateContainerInstancesState) ID() string {
	return "OperationDeserializer"
}

func (m *awsAwsjson11_deserializeOpUpdateContainerInstancesState) 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, awsAwsjson11_deserializeOpErrorUpdateContainerInstancesState(response, &metadata)
	}
	output := &UpdateContainerInstancesStateOutput{}
	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 = awsAwsjson11_deserializeOpDocumentUpdateContainerInstancesStateOutput(&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 awsAwsjson11_deserializeOpErrorUpdateContainerInstancesState(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("ClientException", errorCode):
			return awsAwsjson11_deserializeErrorClientException(response, errorBody)
		
		case strings.EqualFold("ClusterNotFoundException", errorCode):
			return awsAwsjson11_deserializeErrorClusterNotFoundException(response, errorBody)
		
		case strings.EqualFold("InvalidParameterException", errorCode):
			return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
		
		case strings.EqualFold("ServerException", errorCode):
			return awsAwsjson11_deserializeErrorServerException(response, errorBody)
		
		default:
			genericError := &smithy.GenericAPIError{
				Code: errorCode,
				Message: errorMessage,
			}
			return genericError
		
	}
}

type awsAwsjson11_deserializeOpUpdateService struct {
}

func (*awsAwsjson11_deserializeOpUpdateService) ID() string {
	return "OperationDeserializer"
}

func (m *awsAwsjson11_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, awsAwsjson11_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 = awsAwsjson11_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 awsAwsjson11_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("AccessDeniedException", errorCode):
			return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
		
		case strings.EqualFold("ClientException", errorCode):
			return awsAwsjson11_deserializeErrorClientException(response, errorBody)
		
		case strings.EqualFold("ClusterNotFoundException", errorCode):
			return awsAwsjson11_deserializeErrorClusterNotFoundException(response, errorBody)
		
		case strings.EqualFold("InvalidParameterException", errorCode):
			return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
		
		case strings.EqualFold("NamespaceNotFoundException", errorCode):
			return awsAwsjson11_deserializeErrorNamespaceNotFoundException(response, errorBody)
		
		case strings.EqualFold("PlatformTaskDefinitionIncompatibilityException", errorCode):
			return awsAwsjson11_deserializeErrorPlatformTaskDefinitionIncompatibilityException(response, errorBody)
		
		case strings.EqualFold("PlatformUnknownException", errorCode):
			return awsAwsjson11_deserializeErrorPlatformUnknownException(response, errorBody)
		
		case strings.EqualFold("ServerException", errorCode):
			return awsAwsjson11_deserializeErrorServerException(response, errorBody)
		
		case strings.EqualFold("ServiceNotActiveException", errorCode):
			return awsAwsjson11_deserializeErrorServiceNotActiveException(response, errorBody)
		
		case strings.EqualFold("ServiceNotFoundException", errorCode):
			return awsAwsjson11_deserializeErrorServiceNotFoundException(response, errorBody)
		
		case strings.EqualFold("UnsupportedFeatureException", errorCode):
			return awsAwsjson11_deserializeErrorUnsupportedFeatureException(response, errorBody)
		
		default:
			genericError := &smithy.GenericAPIError{
				Code: errorCode,
				Message: errorMessage,
			}
			return genericError
		
	}
}

type awsAwsjson11_deserializeOpUpdateServicePrimaryTaskSet struct {
}

func (*awsAwsjson11_deserializeOpUpdateServicePrimaryTaskSet) ID() string {
	return "OperationDeserializer"
}

func (m *awsAwsjson11_deserializeOpUpdateServicePrimaryTaskSet) 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, awsAwsjson11_deserializeOpErrorUpdateServicePrimaryTaskSet(response, &metadata)
	}
	output := &UpdateServicePrimaryTaskSetOutput{}
	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 = awsAwsjson11_deserializeOpDocumentUpdateServicePrimaryTaskSetOutput(&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 awsAwsjson11_deserializeOpErrorUpdateServicePrimaryTaskSet(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("AccessDeniedException", errorCode):
			return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
		
		case strings.EqualFold("ClientException", errorCode):
			return awsAwsjson11_deserializeErrorClientException(response, errorBody)
		
		case strings.EqualFold("ClusterNotFoundException", errorCode):
			return awsAwsjson11_deserializeErrorClusterNotFoundException(response, errorBody)
		
		case strings.EqualFold("InvalidParameterException", errorCode):
			return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
		
		case strings.EqualFold("ServerException", errorCode):
			return awsAwsjson11_deserializeErrorServerException(response, errorBody)
		
		case strings.EqualFold("ServiceNotActiveException", errorCode):
			return awsAwsjson11_deserializeErrorServiceNotActiveException(response, errorBody)
		
		case strings.EqualFold("ServiceNotFoundException", errorCode):
			return awsAwsjson11_deserializeErrorServiceNotFoundException(response, errorBody)
		
		case strings.EqualFold("TaskSetNotFoundException", errorCode):
			return awsAwsjson11_deserializeErrorTaskSetNotFoundException(response, errorBody)
		
		case strings.EqualFold("UnsupportedFeatureException", errorCode):
			return awsAwsjson11_deserializeErrorUnsupportedFeatureException(response, errorBody)
		
		default:
			genericError := &smithy.GenericAPIError{
				Code: errorCode,
				Message: errorMessage,
			}
			return genericError
		
	}
}

type awsAwsjson11_deserializeOpUpdateTaskProtection struct {
}

func (*awsAwsjson11_deserializeOpUpdateTaskProtection) ID() string {
	return "OperationDeserializer"
}

func (m *awsAwsjson11_deserializeOpUpdateTaskProtection) 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, awsAwsjson11_deserializeOpErrorUpdateTaskProtection(response, &metadata)
	}
	output := &UpdateTaskProtectionOutput{}
	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 = awsAwsjson11_deserializeOpDocumentUpdateTaskProtectionOutput(&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 awsAwsjson11_deserializeOpErrorUpdateTaskProtection(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("AccessDeniedException", errorCode):
			return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
		
		case strings.EqualFold("ClientException", errorCode):
			return awsAwsjson11_deserializeErrorClientException(response, errorBody)
		
		case strings.EqualFold("ClusterNotFoundException", errorCode):
			return awsAwsjson11_deserializeErrorClusterNotFoundException(response, errorBody)
		
		case strings.EqualFold("InvalidParameterException", errorCode):
			return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
		
		case strings.EqualFold("ResourceNotFoundException", errorCode):
			return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
		
		case strings.EqualFold("ServerException", errorCode):
			return awsAwsjson11_deserializeErrorServerException(response, errorBody)
		
		case strings.EqualFold("UnsupportedFeatureException", errorCode):
			return awsAwsjson11_deserializeErrorUnsupportedFeatureException(response, errorBody)
		
		default:
			genericError := &smithy.GenericAPIError{
				Code: errorCode,
				Message: errorMessage,
			}
			return genericError
		
	}
}

type awsAwsjson11_deserializeOpUpdateTaskSet struct {
}

func (*awsAwsjson11_deserializeOpUpdateTaskSet) ID() string {
	return "OperationDeserializer"
}

func (m *awsAwsjson11_deserializeOpUpdateTaskSet) 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, awsAwsjson11_deserializeOpErrorUpdateTaskSet(response, &metadata)
	}
	output := &UpdateTaskSetOutput{}
	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 = awsAwsjson11_deserializeOpDocumentUpdateTaskSetOutput(&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 awsAwsjson11_deserializeOpErrorUpdateTaskSet(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("AccessDeniedException", errorCode):
			return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
		
		case strings.EqualFold("ClientException", errorCode):
			return awsAwsjson11_deserializeErrorClientException(response, errorBody)
		
		case strings.EqualFold("ClusterNotFoundException", errorCode):
			return awsAwsjson11_deserializeErrorClusterNotFoundException(response, errorBody)
		
		case strings.EqualFold("InvalidParameterException", errorCode):
			return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
		
		case strings.EqualFold("ServerException", errorCode):
			return awsAwsjson11_deserializeErrorServerException(response, errorBody)
		
		case strings.EqualFold("ServiceNotActiveException", errorCode):
			return awsAwsjson11_deserializeErrorServiceNotActiveException(response, errorBody)
		
		case strings.EqualFold("ServiceNotFoundException", errorCode):
			return awsAwsjson11_deserializeErrorServiceNotFoundException(response, errorBody)
		
		case strings.EqualFold("TaskSetNotFoundException", errorCode):
			return awsAwsjson11_deserializeErrorTaskSetNotFoundException(response, errorBody)
		
		case strings.EqualFold("UnsupportedFeatureException", errorCode):
			return awsAwsjson11_deserializeErrorUnsupportedFeatureException(response, errorBody)
		
		default:
			genericError := &smithy.GenericAPIError{
				Code: errorCode,
				Message: errorMessage,
			}
			return genericError
		
	}
}

func awsAwsjson11_deserializeErrorAccessDeniedException(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.AccessDeniedException{}
	err := awsAwsjson11_deserializeDocumentAccessDeniedException(&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 awsAwsjson11_deserializeErrorAttributeLimitExceededException(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.AttributeLimitExceededException{}
	err := awsAwsjson11_deserializeDocumentAttributeLimitExceededException(&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 awsAwsjson11_deserializeErrorBlockedException(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.BlockedException{}
	err := awsAwsjson11_deserializeDocumentBlockedException(&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 awsAwsjson11_deserializeErrorClientException(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.ClientException{}
	err := awsAwsjson11_deserializeDocumentClientException(&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 awsAwsjson11_deserializeErrorClusterContainsContainerInstancesException(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.ClusterContainsContainerInstancesException{}
	err := awsAwsjson11_deserializeDocumentClusterContainsContainerInstancesException(&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 awsAwsjson11_deserializeErrorClusterContainsServicesException(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.ClusterContainsServicesException{}
	err := awsAwsjson11_deserializeDocumentClusterContainsServicesException(&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 awsAwsjson11_deserializeErrorClusterContainsTasksException(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.ClusterContainsTasksException{}
	err := awsAwsjson11_deserializeDocumentClusterContainsTasksException(&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 awsAwsjson11_deserializeErrorClusterNotFoundException(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.ClusterNotFoundException{}
	err := awsAwsjson11_deserializeDocumentClusterNotFoundException(&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 awsAwsjson11_deserializeErrorConflictException(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.ConflictException{}
	err := awsAwsjson11_deserializeDocumentConflictException(&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 awsAwsjson11_deserializeErrorInvalidParameterException(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.InvalidParameterException{}
	err := awsAwsjson11_deserializeDocumentInvalidParameterException(&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 awsAwsjson11_deserializeErrorLimitExceededException(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.LimitExceededException{}
	err := awsAwsjson11_deserializeDocumentLimitExceededException(&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 awsAwsjson11_deserializeErrorMissingVersionException(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.MissingVersionException{}
	err := awsAwsjson11_deserializeDocumentMissingVersionException(&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 awsAwsjson11_deserializeErrorNamespaceNotFoundException(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.NamespaceNotFoundException{}
	err := awsAwsjson11_deserializeDocumentNamespaceNotFoundException(&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 awsAwsjson11_deserializeErrorNoUpdateAvailableException(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.NoUpdateAvailableException{}
	err := awsAwsjson11_deserializeDocumentNoUpdateAvailableException(&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 awsAwsjson11_deserializeErrorPlatformTaskDefinitionIncompatibilityException(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.PlatformTaskDefinitionIncompatibilityException{}
	err := awsAwsjson11_deserializeDocumentPlatformTaskDefinitionIncompatibilityException(&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 awsAwsjson11_deserializeErrorPlatformUnknownException(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.PlatformUnknownException{}
	err := awsAwsjson11_deserializeDocumentPlatformUnknownException(&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 awsAwsjson11_deserializeErrorResourceInUseException(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.ResourceInUseException{}
	err := awsAwsjson11_deserializeDocumentResourceInUseException(&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 awsAwsjson11_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 := awsAwsjson11_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 awsAwsjson11_deserializeErrorServerException(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.ServerException{}
	err := awsAwsjson11_deserializeDocumentServerException(&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 awsAwsjson11_deserializeErrorServiceNotActiveException(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.ServiceNotActiveException{}
	err := awsAwsjson11_deserializeDocumentServiceNotActiveException(&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 awsAwsjson11_deserializeErrorServiceNotFoundException(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.ServiceNotFoundException{}
	err := awsAwsjson11_deserializeDocumentServiceNotFoundException(&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 awsAwsjson11_deserializeErrorTargetNotConnectedException(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.TargetNotConnectedException{}
	err := awsAwsjson11_deserializeDocumentTargetNotConnectedException(&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 awsAwsjson11_deserializeErrorTargetNotFoundException(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.TargetNotFoundException{}
	err := awsAwsjson11_deserializeDocumentTargetNotFoundException(&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 awsAwsjson11_deserializeErrorTaskSetNotFoundException(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.TaskSetNotFoundException{}
	err := awsAwsjson11_deserializeDocumentTaskSetNotFoundException(&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 awsAwsjson11_deserializeErrorUnsupportedFeatureException(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.UnsupportedFeatureException{}
	err := awsAwsjson11_deserializeDocumentUnsupportedFeatureException(&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 awsAwsjson11_deserializeErrorUpdateInProgressException(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.UpdateInProgressException{}
	err := awsAwsjson11_deserializeDocumentUpdateInProgressException(&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 awsAwsjson11_deserializeDocumentAccessDeniedException(v **types.AccessDeniedException, 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.AccessDeniedException
	if *v == nil {
		sv = &types.AccessDeniedException{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "message":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.Message = ptr.String(jtv)
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeDocumentAttachment(v **types.Attachment, 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.Attachment
	if *v == nil {
		sv = &types.Attachment{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "details":
				if err := awsAwsjson11_deserializeDocumentAttachmentDetails(&sv.Details, value); err != nil {
					return err
				}
			
			case "id":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.Id = ptr.String(jtv)
				}
			
			case "status":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.Status = ptr.String(jtv)
				}
			
			case "type":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.Type = ptr.String(jtv)
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeDocumentAttachmentDetails(v *[]types.KeyValuePair, 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.KeyValuePair
	if *v == nil {
		cv = []types.KeyValuePair{}
		} else {
			cv = *v
		}
	
	for _, value := range shape {
		var col types.KeyValuePair
		destAddr := &col
		if err := awsAwsjson11_deserializeDocumentKeyValuePair(&destAddr, value); err != nil {
			return err
		}
		col = *destAddr
		cv = append(cv, col)
		
	}
	*v = cv
	return nil
}

func awsAwsjson11_deserializeDocumentAttachments(v *[]types.Attachment, 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.Attachment
	if *v == nil {
		cv = []types.Attachment{}
		} else {
			cv = *v
		}
	
	for _, value := range shape {
		var col types.Attachment
		destAddr := &col
		if err := awsAwsjson11_deserializeDocumentAttachment(&destAddr, value); err != nil {
			return err
		}
		col = *destAddr
		cv = append(cv, col)
		
	}
	*v = cv
	return nil
}

func awsAwsjson11_deserializeDocumentAttribute(v **types.Attribute, 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.Attribute
	if *v == nil {
		sv = &types.Attribute{}
		} 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 "targetId":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.TargetId = ptr.String(jtv)
				}
			
			case "targetType":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected TargetType to be of type string, got %T instead", value)
					}
					sv.TargetType = types.TargetType(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 awsAwsjson11_deserializeDocumentAttributeLimitExceededException(v **types.AttributeLimitExceededException, 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.AttributeLimitExceededException
	if *v == nil {
		sv = &types.AttributeLimitExceededException{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "message":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.Message = ptr.String(jtv)
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeDocumentAttributes(v *[]types.Attribute, 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.Attribute
	if *v == nil {
		cv = []types.Attribute{}
		} else {
			cv = *v
		}
	
	for _, value := range shape {
		var col types.Attribute
		destAddr := &col
		if err := awsAwsjson11_deserializeDocumentAttribute(&destAddr, value); err != nil {
			return err
		}
		col = *destAddr
		cv = append(cv, col)
		
	}
	*v = cv
	return nil
}

func awsAwsjson11_deserializeDocumentAutoScalingGroupProvider(v **types.AutoScalingGroupProvider, 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.AutoScalingGroupProvider
	if *v == nil {
		sv = &types.AutoScalingGroupProvider{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "autoScalingGroupArn":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.AutoScalingGroupArn = ptr.String(jtv)
				}
			
			case "managedDraining":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected ManagedDraining to be of type string, got %T instead", value)
					}
					sv.ManagedDraining = types.ManagedDraining(jtv)
				}
			
			case "managedScaling":
				if err := awsAwsjson11_deserializeDocumentManagedScaling(&sv.ManagedScaling, value); err != nil {
					return err
				}
			
			case "managedTerminationProtection":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected ManagedTerminationProtection to be of type string, got %T instead", value)
					}
					sv.ManagedTerminationProtection = types.ManagedTerminationProtection(jtv)
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeDocumentAwsVpcConfiguration(v **types.AwsVpcConfiguration, 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.AwsVpcConfiguration
	if *v == nil {
		sv = &types.AwsVpcConfiguration{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "assignPublicIp":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected AssignPublicIp to be of type string, got %T instead", value)
					}
					sv.AssignPublicIp = types.AssignPublicIp(jtv)
				}
			
			case "securityGroups":
				if err := awsAwsjson11_deserializeDocumentStringList(&sv.SecurityGroups, value); err != nil {
					return err
				}
			
			case "subnets":
				if err := awsAwsjson11_deserializeDocumentStringList(&sv.Subnets, value); err != nil {
					return err
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeDocumentBlockedException(v **types.BlockedException, 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.BlockedException
	if *v == nil {
		sv = &types.BlockedException{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "message":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.Message = ptr.String(jtv)
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeDocumentCapacityProvider(v **types.CapacityProvider, 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.CapacityProvider
	if *v == nil {
		sv = &types.CapacityProvider{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "autoScalingGroupProvider":
				if err := awsAwsjson11_deserializeDocumentAutoScalingGroupProvider(&sv.AutoScalingGroupProvider, value); err != nil {
					return err
				}
			
			case "capacityProviderArn":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.CapacityProviderArn = ptr.String(jtv)
				}
			
			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 CapacityProviderStatus to be of type string, got %T instead", value)
					}
					sv.Status = types.CapacityProviderStatus(jtv)
				}
			
			case "tags":
				if err := awsAwsjson11_deserializeDocumentTags(&sv.Tags, value); err != nil {
					return err
				}
			
			case "updateStatus":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected CapacityProviderUpdateStatus to be of type string, got %T instead", value)
					}
					sv.UpdateStatus = types.CapacityProviderUpdateStatus(jtv)
				}
			
			case "updateStatusReason":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.UpdateStatusReason = ptr.String(jtv)
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeDocumentCapacityProviders(v *[]types.CapacityProvider, 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.CapacityProvider
	if *v == nil {
		cv = []types.CapacityProvider{}
		} else {
			cv = *v
		}
	
	for _, value := range shape {
		var col types.CapacityProvider
		destAddr := &col
		if err := awsAwsjson11_deserializeDocumentCapacityProvider(&destAddr, value); err != nil {
			return err
		}
		col = *destAddr
		cv = append(cv, col)
		
	}
	*v = cv
	return nil
}

func awsAwsjson11_deserializeDocumentCapacityProviderStrategy(v *[]types.CapacityProviderStrategyItem, 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.CapacityProviderStrategyItem
	if *v == nil {
		cv = []types.CapacityProviderStrategyItem{}
		} else {
			cv = *v
		}
	
	for _, value := range shape {
		var col types.CapacityProviderStrategyItem
		destAddr := &col
		if err := awsAwsjson11_deserializeDocumentCapacityProviderStrategyItem(&destAddr, value); err != nil {
			return err
		}
		col = *destAddr
		cv = append(cv, col)
		
	}
	*v = cv
	return nil
}

func awsAwsjson11_deserializeDocumentCapacityProviderStrategyItem(v **types.CapacityProviderStrategyItem, 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.CapacityProviderStrategyItem
	if *v == nil {
		sv = &types.CapacityProviderStrategyItem{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "base":
				if value != nil {
					jtv, ok := value.(json.Number)
					if !ok {
						return fmt.Errorf("expected CapacityProviderStrategyItemBase to be json.Number, got %T instead", value)
					}
					i64, err := jtv.Int64()
					if err != nil { return err }
					sv.Base = int32(i64)
				}
			
			case "capacityProvider":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.CapacityProvider = ptr.String(jtv)
				}
			
			case "weight":
				if value != nil {
					jtv, ok := value.(json.Number)
					if !ok {
						return fmt.Errorf("expected CapacityProviderStrategyItemWeight to be json.Number, got %T instead", value)
					}
					i64, err := jtv.Int64()
					if err != nil { return err }
					sv.Weight = int32(i64)
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeDocumentClientException(v **types.ClientException, 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.ClientException
	if *v == nil {
		sv = &types.ClientException{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "message":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.Message = ptr.String(jtv)
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeDocumentCluster(v **types.Cluster, 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.Cluster
	if *v == nil {
		sv = &types.Cluster{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "activeServicesCount":
				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.ActiveServicesCount = int32(i64)
				}
			
			case "attachments":
				if err := awsAwsjson11_deserializeDocumentAttachments(&sv.Attachments, value); err != nil {
					return err
				}
			
			case "attachmentsStatus":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.AttachmentsStatus = ptr.String(jtv)
				}
			
			case "capacityProviders":
				if err := awsAwsjson11_deserializeDocumentStringList(&sv.CapacityProviders, value); err != nil {
					return err
				}
			
			case "clusterArn":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.ClusterArn = ptr.String(jtv)
				}
			
			case "clusterName":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.ClusterName = ptr.String(jtv)
				}
			
			case "configuration":
				if err := awsAwsjson11_deserializeDocumentClusterConfiguration(&sv.Configuration, value); err != nil {
					return err
				}
			
			case "defaultCapacityProviderStrategy":
				if err := awsAwsjson11_deserializeDocumentCapacityProviderStrategy(&sv.DefaultCapacityProviderStrategy, value); err != nil {
					return err
				}
			
			case "pendingTasksCount":
				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.PendingTasksCount = int32(i64)
				}
			
			case "registeredContainerInstancesCount":
				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.RegisteredContainerInstancesCount = int32(i64)
				}
			
			case "runningTasksCount":
				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.RunningTasksCount = int32(i64)
				}
			
			case "serviceConnectDefaults":
				if err := awsAwsjson11_deserializeDocumentClusterServiceConnectDefaults(&sv.ServiceConnectDefaults, value); err != nil {
					return err
				}
			
			case "settings":
				if err := awsAwsjson11_deserializeDocumentClusterSettings(&sv.Settings, value); err != nil {
					return err
				}
			
			case "statistics":
				if err := awsAwsjson11_deserializeDocumentStatistics(&sv.Statistics, value); err != nil {
					return err
				}
			
			case "status":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.Status = ptr.String(jtv)
				}
			
			case "tags":
				if err := awsAwsjson11_deserializeDocumentTags(&sv.Tags, value); err != nil {
					return err
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeDocumentClusterConfiguration(v **types.ClusterConfiguration, 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.ClusterConfiguration
	if *v == nil {
		sv = &types.ClusterConfiguration{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "executeCommandConfiguration":
				if err := awsAwsjson11_deserializeDocumentExecuteCommandConfiguration(&sv.ExecuteCommandConfiguration, value); err != nil {
					return err
				}
			
			case "managedStorageConfiguration":
				if err := awsAwsjson11_deserializeDocumentManagedStorageConfiguration(&sv.ManagedStorageConfiguration, value); err != nil {
					return err
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeDocumentClusterContainsContainerInstancesException(v **types.ClusterContainsContainerInstancesException, 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.ClusterContainsContainerInstancesException
	if *v == nil {
		sv = &types.ClusterContainsContainerInstancesException{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "message":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.Message = ptr.String(jtv)
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeDocumentClusterContainsServicesException(v **types.ClusterContainsServicesException, 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.ClusterContainsServicesException
	if *v == nil {
		sv = &types.ClusterContainsServicesException{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "message":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.Message = ptr.String(jtv)
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeDocumentClusterContainsTasksException(v **types.ClusterContainsTasksException, 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.ClusterContainsTasksException
	if *v == nil {
		sv = &types.ClusterContainsTasksException{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "message":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.Message = ptr.String(jtv)
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeDocumentClusterNotFoundException(v **types.ClusterNotFoundException, 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.ClusterNotFoundException
	if *v == nil {
		sv = &types.ClusterNotFoundException{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "message":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.Message = ptr.String(jtv)
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeDocumentClusters(v *[]types.Cluster, 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.Cluster
	if *v == nil {
		cv = []types.Cluster{}
		} else {
			cv = *v
		}
	
	for _, value := range shape {
		var col types.Cluster
		destAddr := &col
		if err := awsAwsjson11_deserializeDocumentCluster(&destAddr, value); err != nil {
			return err
		}
		col = *destAddr
		cv = append(cv, col)
		
	}
	*v = cv
	return nil
}

func awsAwsjson11_deserializeDocumentClusterServiceConnectDefaults(v **types.ClusterServiceConnectDefaults, 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.ClusterServiceConnectDefaults
	if *v == nil {
		sv = &types.ClusterServiceConnectDefaults{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "namespace":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.Namespace = ptr.String(jtv)
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeDocumentClusterSetting(v **types.ClusterSetting, 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.ClusterSetting
	if *v == nil {
		sv = &types.ClusterSetting{}
		} 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 ClusterSettingName to be of type string, got %T instead", value)
					}
					sv.Name = types.ClusterSettingName(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 awsAwsjson11_deserializeDocumentClusterSettings(v *[]types.ClusterSetting, 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.ClusterSetting
	if *v == nil {
		cv = []types.ClusterSetting{}
		} else {
			cv = *v
		}
	
	for _, value := range shape {
		var col types.ClusterSetting
		destAddr := &col
		if err := awsAwsjson11_deserializeDocumentClusterSetting(&destAddr, value); err != nil {
			return err
		}
		col = *destAddr
		cv = append(cv, col)
		
	}
	*v = cv
	return nil
}

func awsAwsjson11_deserializeDocumentCompatibilityList(v *[]types.Compatibility, 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.Compatibility
	if *v == nil {
		cv = []types.Compatibility{}
		} else {
			cv = *v
		}
	
	for _, value := range shape {
		var col types.Compatibility
		if value != nil {
			jtv, ok := value.(string)
			if !ok {
				return fmt.Errorf("expected Compatibility to be of type string, got %T instead", value)
			}
			col = types.Compatibility(jtv)
		}
		cv = append(cv, col)
		
	}
	*v = cv
	return nil
}

func awsAwsjson11_deserializeDocumentConflictException(v **types.ConflictException, 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.ConflictException
	if *v == nil {
		sv = &types.ConflictException{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "message":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.Message = ptr.String(jtv)
				}
			
			case "resourceIds":
				if err := awsAwsjson11_deserializeDocumentResourceIds(&sv.ResourceIds, value); err != nil {
					return err
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeDocumentContainer(v **types.Container, 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.Container
	if *v == nil {
		sv = &types.Container{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "containerArn":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.ContainerArn = ptr.String(jtv)
				}
			
			case "cpu":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.Cpu = ptr.String(jtv)
				}
			
			case "exitCode":
				if value != nil {
					jtv, ok := value.(json.Number)
					if !ok {
						return fmt.Errorf("expected BoxedInteger to be json.Number, got %T instead", value)
					}
					i64, err := jtv.Int64()
					if err != nil { return err }
					sv.ExitCode = ptr.Int32(int32(i64))
				}
			
			case "gpuIds":
				if err := awsAwsjson11_deserializeDocumentGpuIds(&sv.GpuIds, value); err != nil {
					return err
				}
			
			case "healthStatus":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected HealthStatus to be of type string, got %T instead", value)
					}
					sv.HealthStatus = types.HealthStatus(jtv)
				}
			
			case "image":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.Image = ptr.String(jtv)
				}
			
			case "imageDigest":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.ImageDigest = ptr.String(jtv)
				}
			
			case "lastStatus":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.LastStatus = ptr.String(jtv)
				}
			
			case "managedAgents":
				if err := awsAwsjson11_deserializeDocumentManagedAgents(&sv.ManagedAgents, value); err != nil {
					return err
				}
			
			case "memory":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.Memory = ptr.String(jtv)
				}
			
			case "memoryReservation":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.MemoryReservation = ptr.String(jtv)
				}
			
			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 "networkBindings":
				if err := awsAwsjson11_deserializeDocumentNetworkBindings(&sv.NetworkBindings, value); err != nil {
					return err
				}
			
			case "networkInterfaces":
				if err := awsAwsjson11_deserializeDocumentNetworkInterfaces(&sv.NetworkInterfaces, value); err != nil {
					return err
				}
			
			case "reason":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.Reason = ptr.String(jtv)
				}
			
			case "runtimeId":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.RuntimeId = ptr.String(jtv)
				}
			
			case "taskArn":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.TaskArn = ptr.String(jtv)
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeDocumentContainerDefinition(v **types.ContainerDefinition, 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.ContainerDefinition
	if *v == nil {
		sv = &types.ContainerDefinition{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "command":
				if err := awsAwsjson11_deserializeDocumentStringList(&sv.Command, value); err != nil {
					return err
				}
			
			case "cpu":
				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.Cpu = int32(i64)
				}
			
			case "credentialSpecs":
				if err := awsAwsjson11_deserializeDocumentStringList(&sv.CredentialSpecs, value); err != nil {
					return err
				}
			
			case "dependsOn":
				if err := awsAwsjson11_deserializeDocumentContainerDependencies(&sv.DependsOn, value); err != nil {
					return err
				}
			
			case "disableNetworking":
				if value != nil {
					jtv, ok := value.(bool)
					if !ok {
						return fmt.Errorf("expected BoxedBoolean to be of type *bool, got %T instead", value)
					}
					sv.DisableNetworking = ptr.Bool(jtv)
				}
			
			case "dnsSearchDomains":
				if err := awsAwsjson11_deserializeDocumentStringList(&sv.DnsSearchDomains, value); err != nil {
					return err
				}
			
			case "dnsServers":
				if err := awsAwsjson11_deserializeDocumentStringList(&sv.DnsServers, value); err != nil {
					return err
				}
			
			case "dockerLabels":
				if err := awsAwsjson11_deserializeDocumentDockerLabelsMap(&sv.DockerLabels, value); err != nil {
					return err
				}
			
			case "dockerSecurityOptions":
				if err := awsAwsjson11_deserializeDocumentStringList(&sv.DockerSecurityOptions, value); err != nil {
					return err
				}
			
			case "entryPoint":
				if err := awsAwsjson11_deserializeDocumentStringList(&sv.EntryPoint, value); err != nil {
					return err
				}
			
			case "environment":
				if err := awsAwsjson11_deserializeDocumentEnvironmentVariables(&sv.Environment, value); err != nil {
					return err
				}
			
			case "environmentFiles":
				if err := awsAwsjson11_deserializeDocumentEnvironmentFiles(&sv.EnvironmentFiles, value); err != nil {
					return err
				}
			
			case "essential":
				if value != nil {
					jtv, ok := value.(bool)
					if !ok {
						return fmt.Errorf("expected BoxedBoolean to be of type *bool, got %T instead", value)
					}
					sv.Essential = ptr.Bool(jtv)
				}
			
			case "extraHosts":
				if err := awsAwsjson11_deserializeDocumentHostEntryList(&sv.ExtraHosts, value); err != nil {
					return err
				}
			
			case "firelensConfiguration":
				if err := awsAwsjson11_deserializeDocumentFirelensConfiguration(&sv.FirelensConfiguration, value); err != nil {
					return err
				}
			
			case "healthCheck":
				if err := awsAwsjson11_deserializeDocumentHealthCheck(&sv.HealthCheck, value); err != nil {
					return err
				}
			
			case "hostname":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.Hostname = ptr.String(jtv)
				}
			
			case "image":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.Image = ptr.String(jtv)
				}
			
			case "interactive":
				if value != nil {
					jtv, ok := value.(bool)
					if !ok {
						return fmt.Errorf("expected BoxedBoolean to be of type *bool, got %T instead", value)
					}
					sv.Interactive = ptr.Bool(jtv)
				}
			
			case "links":
				if err := awsAwsjson11_deserializeDocumentStringList(&sv.Links, value); err != nil {
					return err
				}
			
			case "linuxParameters":
				if err := awsAwsjson11_deserializeDocumentLinuxParameters(&sv.LinuxParameters, value); err != nil {
					return err
				}
			
			case "logConfiguration":
				if err := awsAwsjson11_deserializeDocumentLogConfiguration(&sv.LogConfiguration, value); err != nil {
					return err
				}
			
			case "memory":
				if value != nil {
					jtv, ok := value.(json.Number)
					if !ok {
						return fmt.Errorf("expected BoxedInteger to be json.Number, got %T instead", value)
					}
					i64, err := jtv.Int64()
					if err != nil { return err }
					sv.Memory = ptr.Int32(int32(i64))
				}
			
			case "memoryReservation":
				if value != nil {
					jtv, ok := value.(json.Number)
					if !ok {
						return fmt.Errorf("expected BoxedInteger to be json.Number, got %T instead", value)
					}
					i64, err := jtv.Int64()
					if err != nil { return err }
					sv.MemoryReservation = ptr.Int32(int32(i64))
				}
			
			case "mountPoints":
				if err := awsAwsjson11_deserializeDocumentMountPointList(&sv.MountPoints, value); err != nil {
					return err
				}
			
			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 "portMappings":
				if err := awsAwsjson11_deserializeDocumentPortMappingList(&sv.PortMappings, value); err != nil {
					return err
				}
			
			case "privileged":
				if value != nil {
					jtv, ok := value.(bool)
					if !ok {
						return fmt.Errorf("expected BoxedBoolean to be of type *bool, got %T instead", value)
					}
					sv.Privileged = ptr.Bool(jtv)
				}
			
			case "pseudoTerminal":
				if value != nil {
					jtv, ok := value.(bool)
					if !ok {
						return fmt.Errorf("expected BoxedBoolean to be of type *bool, got %T instead", value)
					}
					sv.PseudoTerminal = ptr.Bool(jtv)
				}
			
			case "readonlyRootFilesystem":
				if value != nil {
					jtv, ok := value.(bool)
					if !ok {
						return fmt.Errorf("expected BoxedBoolean to be of type *bool, got %T instead", value)
					}
					sv.ReadonlyRootFilesystem = ptr.Bool(jtv)
				}
			
			case "repositoryCredentials":
				if err := awsAwsjson11_deserializeDocumentRepositoryCredentials(&sv.RepositoryCredentials, value); err != nil {
					return err
				}
			
			case "resourceRequirements":
				if err := awsAwsjson11_deserializeDocumentResourceRequirements(&sv.ResourceRequirements, value); err != nil {
					return err
				}
			
			case "restartPolicy":
				if err := awsAwsjson11_deserializeDocumentContainerRestartPolicy(&sv.RestartPolicy, value); err != nil {
					return err
				}
			
			case "secrets":
				if err := awsAwsjson11_deserializeDocumentSecretList(&sv.Secrets, value); err != nil {
					return err
				}
			
			case "startTimeout":
				if value != nil {
					jtv, ok := value.(json.Number)
					if !ok {
						return fmt.Errorf("expected BoxedInteger to be json.Number, got %T instead", value)
					}
					i64, err := jtv.Int64()
					if err != nil { return err }
					sv.StartTimeout = ptr.Int32(int32(i64))
				}
			
			case "stopTimeout":
				if value != nil {
					jtv, ok := value.(json.Number)
					if !ok {
						return fmt.Errorf("expected BoxedInteger to be json.Number, got %T instead", value)
					}
					i64, err := jtv.Int64()
					if err != nil { return err }
					sv.StopTimeout = ptr.Int32(int32(i64))
				}
			
			case "systemControls":
				if err := awsAwsjson11_deserializeDocumentSystemControls(&sv.SystemControls, value); err != nil {
					return err
				}
			
			case "ulimits":
				if err := awsAwsjson11_deserializeDocumentUlimitList(&sv.Ulimits, value); err != nil {
					return err
				}
			
			case "user":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.User = ptr.String(jtv)
				}
			
			case "volumesFrom":
				if err := awsAwsjson11_deserializeDocumentVolumeFromList(&sv.VolumesFrom, value); err != nil {
					return err
				}
			
			case "workingDirectory":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.WorkingDirectory = ptr.String(jtv)
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeDocumentContainerDefinitions(v *[]types.ContainerDefinition, 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.ContainerDefinition
	if *v == nil {
		cv = []types.ContainerDefinition{}
		} else {
			cv = *v
		}
	
	for _, value := range shape {
		var col types.ContainerDefinition
		destAddr := &col
		if err := awsAwsjson11_deserializeDocumentContainerDefinition(&destAddr, value); err != nil {
			return err
		}
		col = *destAddr
		cv = append(cv, col)
		
	}
	*v = cv
	return nil
}

func awsAwsjson11_deserializeDocumentContainerDependencies(v *[]types.ContainerDependency, 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.ContainerDependency
	if *v == nil {
		cv = []types.ContainerDependency{}
		} else {
			cv = *v
		}
	
	for _, value := range shape {
		var col types.ContainerDependency
		destAddr := &col
		if err := awsAwsjson11_deserializeDocumentContainerDependency(&destAddr, value); err != nil {
			return err
		}
		col = *destAddr
		cv = append(cv, col)
		
	}
	*v = cv
	return nil
}

func awsAwsjson11_deserializeDocumentContainerDependency(v **types.ContainerDependency, 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.ContainerDependency
	if *v == nil {
		sv = &types.ContainerDependency{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "condition":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected ContainerCondition to be of type string, got %T instead", value)
					}
					sv.Condition = types.ContainerCondition(jtv)
				}
			
			case "containerName":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.ContainerName = ptr.String(jtv)
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeDocumentContainerInstance(v **types.ContainerInstance, 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.ContainerInstance
	if *v == nil {
		sv = &types.ContainerInstance{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "agentConnected":
				if value != nil {
					jtv, ok := value.(bool)
					if !ok {
						return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value)
					}
					sv.AgentConnected = jtv
				}
			
			case "agentUpdateStatus":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected AgentUpdateStatus to be of type string, got %T instead", value)
					}
					sv.AgentUpdateStatus = types.AgentUpdateStatus(jtv)
				}
			
			case "attachments":
				if err := awsAwsjson11_deserializeDocumentAttachments(&sv.Attachments, value); err != nil {
					return err
				}
			
			case "attributes":
				if err := awsAwsjson11_deserializeDocumentAttributes(&sv.Attributes, value); err != nil {
					return err
				}
			
			case "capacityProviderName":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.CapacityProviderName = ptr.String(jtv)
				}
			
			case "containerInstanceArn":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.ContainerInstanceArn = ptr.String(jtv)
				}
			
			case "ec2InstanceId":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.Ec2InstanceId = ptr.String(jtv)
				}
			
			case "healthStatus":
				if err := awsAwsjson11_deserializeDocumentContainerInstanceHealthStatus(&sv.HealthStatus, value); err != nil {
					return err
				}
			
			case "pendingTasksCount":
				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.PendingTasksCount = int32(i64)
				}
			
			case "registeredAt":
				if value != nil {
					switch jtv := value.(type) {
						case json.Number:
							f64, err := jtv.Float64()
							if err != nil { return err }
							sv.RegisteredAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
						
						default:
							return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value)
						
					}
				}
			
			case "registeredResources":
				if err := awsAwsjson11_deserializeDocumentResources(&sv.RegisteredResources, value); err != nil {
					return err
				}
			
			case "remainingResources":
				if err := awsAwsjson11_deserializeDocumentResources(&sv.RemainingResources, value); err != nil {
					return err
				}
			
			case "runningTasksCount":
				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.RunningTasksCount = int32(i64)
				}
			
			case "status":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.Status = ptr.String(jtv)
				}
			
			case "statusReason":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.StatusReason = ptr.String(jtv)
				}
			
			case "tags":
				if err := awsAwsjson11_deserializeDocumentTags(&sv.Tags, value); err != nil {
					return err
				}
			
			case "version":
				if value != nil {
					jtv, ok := value.(json.Number)
					if !ok {
						return fmt.Errorf("expected Long to be json.Number, got %T instead", value)
					}
					i64, err := jtv.Int64()
					if err != nil { return err }
					sv.Version = i64
				}
			
			case "versionInfo":
				if err := awsAwsjson11_deserializeDocumentVersionInfo(&sv.VersionInfo, value); err != nil {
					return err
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeDocumentContainerInstanceHealthStatus(v **types.ContainerInstanceHealthStatus, 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.ContainerInstanceHealthStatus
	if *v == nil {
		sv = &types.ContainerInstanceHealthStatus{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "details":
				if err := awsAwsjson11_deserializeDocumentInstanceHealthCheckResultList(&sv.Details, value); err != nil {
					return err
				}
			
			case "overallStatus":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected InstanceHealthCheckState to be of type string, got %T instead", value)
					}
					sv.OverallStatus = types.InstanceHealthCheckState(jtv)
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeDocumentContainerInstances(v *[]types.ContainerInstance, 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.ContainerInstance
	if *v == nil {
		cv = []types.ContainerInstance{}
		} else {
			cv = *v
		}
	
	for _, value := range shape {
		var col types.ContainerInstance
		destAddr := &col
		if err := awsAwsjson11_deserializeDocumentContainerInstance(&destAddr, value); err != nil {
			return err
		}
		col = *destAddr
		cv = append(cv, col)
		
	}
	*v = cv
	return nil
}

func awsAwsjson11_deserializeDocumentContainerOverride(v **types.ContainerOverride, 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.ContainerOverride
	if *v == nil {
		sv = &types.ContainerOverride{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "command":
				if err := awsAwsjson11_deserializeDocumentStringList(&sv.Command, value); err != nil {
					return err
				}
			
			case "cpu":
				if value != nil {
					jtv, ok := value.(json.Number)
					if !ok {
						return fmt.Errorf("expected BoxedInteger to be json.Number, got %T instead", value)
					}
					i64, err := jtv.Int64()
					if err != nil { return err }
					sv.Cpu = ptr.Int32(int32(i64))
				}
			
			case "environment":
				if err := awsAwsjson11_deserializeDocumentEnvironmentVariables(&sv.Environment, value); err != nil {
					return err
				}
			
			case "environmentFiles":
				if err := awsAwsjson11_deserializeDocumentEnvironmentFiles(&sv.EnvironmentFiles, value); err != nil {
					return err
				}
			
			case "memory":
				if value != nil {
					jtv, ok := value.(json.Number)
					if !ok {
						return fmt.Errorf("expected BoxedInteger to be json.Number, got %T instead", value)
					}
					i64, err := jtv.Int64()
					if err != nil { return err }
					sv.Memory = ptr.Int32(int32(i64))
				}
			
			case "memoryReservation":
				if value != nil {
					jtv, ok := value.(json.Number)
					if !ok {
						return fmt.Errorf("expected BoxedInteger to be json.Number, got %T instead", value)
					}
					i64, err := jtv.Int64()
					if err != nil { return err }
					sv.MemoryReservation = ptr.Int32(int32(i64))
				}
			
			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 "resourceRequirements":
				if err := awsAwsjson11_deserializeDocumentResourceRequirements(&sv.ResourceRequirements, value); err != nil {
					return err
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeDocumentContainerOverrides(v *[]types.ContainerOverride, 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.ContainerOverride
	if *v == nil {
		cv = []types.ContainerOverride{}
		} else {
			cv = *v
		}
	
	for _, value := range shape {
		var col types.ContainerOverride
		destAddr := &col
		if err := awsAwsjson11_deserializeDocumentContainerOverride(&destAddr, value); err != nil {
			return err
		}
		col = *destAddr
		cv = append(cv, col)
		
	}
	*v = cv
	return nil
}

func awsAwsjson11_deserializeDocumentContainerRestartPolicy(v **types.ContainerRestartPolicy, 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.ContainerRestartPolicy
	if *v == nil {
		sv = &types.ContainerRestartPolicy{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "enabled":
				if value != nil {
					jtv, ok := value.(bool)
					if !ok {
						return fmt.Errorf("expected BoxedBoolean to be of type *bool, got %T instead", value)
					}
					sv.Enabled = ptr.Bool(jtv)
				}
			
			case "ignoredExitCodes":
				if err := awsAwsjson11_deserializeDocumentIntegerList(&sv.IgnoredExitCodes, value); err != nil {
					return err
				}
			
			case "restartAttemptPeriod":
				if value != nil {
					jtv, ok := value.(json.Number)
					if !ok {
						return fmt.Errorf("expected BoxedInteger to be json.Number, got %T instead", value)
					}
					i64, err := jtv.Int64()
					if err != nil { return err }
					sv.RestartAttemptPeriod = ptr.Int32(int32(i64))
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeDocumentContainers(v *[]types.Container, 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.Container
	if *v == nil {
		cv = []types.Container{}
		} else {
			cv = *v
		}
	
	for _, value := range shape {
		var col types.Container
		destAddr := &col
		if err := awsAwsjson11_deserializeDocumentContainer(&destAddr, value); err != nil {
			return err
		}
		col = *destAddr
		cv = append(cv, col)
		
	}
	*v = cv
	return nil
}

func awsAwsjson11_deserializeDocumentDeployment(v **types.Deployment, 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.Deployment
	if *v == nil {
		sv = &types.Deployment{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "capacityProviderStrategy":
				if err := awsAwsjson11_deserializeDocumentCapacityProviderStrategy(&sv.CapacityProviderStrategy, 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 "desiredCount":
				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.DesiredCount = int32(i64)
				}
			
			case "failedTasks":
				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.FailedTasks = int32(i64)
				}
			
			case "fargateEphemeralStorage":
				if err := awsAwsjson11_deserializeDocumentDeploymentEphemeralStorage(&sv.FargateEphemeralStorage, value); err != nil {
					return err
				}
			
			case "id":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.Id = ptr.String(jtv)
				}
			
			case "launchType":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected LaunchType to be of type string, got %T instead", value)
					}
					sv.LaunchType = types.LaunchType(jtv)
				}
			
			case "networkConfiguration":
				if err := awsAwsjson11_deserializeDocumentNetworkConfiguration(&sv.NetworkConfiguration, value); err != nil {
					return err
				}
			
			case "pendingCount":
				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.PendingCount = int32(i64)
				}
			
			case "platformFamily":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.PlatformFamily = ptr.String(jtv)
				}
			
			case "platformVersion":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.PlatformVersion = ptr.String(jtv)
				}
			
			case "rolloutState":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected DeploymentRolloutState to be of type string, got %T instead", value)
					}
					sv.RolloutState = types.DeploymentRolloutState(jtv)
				}
			
			case "rolloutStateReason":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.RolloutStateReason = ptr.String(jtv)
				}
			
			case "runningCount":
				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.RunningCount = int32(i64)
				}
			
			case "serviceConnectConfiguration":
				if err := awsAwsjson11_deserializeDocumentServiceConnectConfiguration(&sv.ServiceConnectConfiguration, value); err != nil {
					return err
				}
			
			case "serviceConnectResources":
				if err := awsAwsjson11_deserializeDocumentServiceConnectServiceResourceList(&sv.ServiceConnectResources, value); err != nil {
					return err
				}
			
			case "status":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.Status = ptr.String(jtv)
				}
			
			case "taskDefinition":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.TaskDefinition = ptr.String(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)
						
					}
				}
			
			case "volumeConfigurations":
				if err := awsAwsjson11_deserializeDocumentServiceVolumeConfigurations(&sv.VolumeConfigurations, value); err != nil {
					return err
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeDocumentDeploymentAlarms(v **types.DeploymentAlarms, 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.DeploymentAlarms
	if *v == nil {
		sv = &types.DeploymentAlarms{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "alarmNames":
				if err := awsAwsjson11_deserializeDocumentStringList(&sv.AlarmNames, value); err != nil {
					return err
				}
			
			case "enable":
				if value != nil {
					jtv, ok := value.(bool)
					if !ok {
						return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value)
					}
					sv.Enable = jtv
				}
			
			case "rollback":
				if value != nil {
					jtv, ok := value.(bool)
					if !ok {
						return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value)
					}
					sv.Rollback = jtv
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeDocumentDeploymentCircuitBreaker(v **types.DeploymentCircuitBreaker, 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.DeploymentCircuitBreaker
	if *v == nil {
		sv = &types.DeploymentCircuitBreaker{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "enable":
				if value != nil {
					jtv, ok := value.(bool)
					if !ok {
						return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value)
					}
					sv.Enable = jtv
				}
			
			case "rollback":
				if value != nil {
					jtv, ok := value.(bool)
					if !ok {
						return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value)
					}
					sv.Rollback = jtv
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeDocumentDeploymentConfiguration(v **types.DeploymentConfiguration, 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.DeploymentConfiguration
	if *v == nil {
		sv = &types.DeploymentConfiguration{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "alarms":
				if err := awsAwsjson11_deserializeDocumentDeploymentAlarms(&sv.Alarms, value); err != nil {
					return err
				}
			
			case "deploymentCircuitBreaker":
				if err := awsAwsjson11_deserializeDocumentDeploymentCircuitBreaker(&sv.DeploymentCircuitBreaker, value); err != nil {
					return err
				}
			
			case "maximumPercent":
				if value != nil {
					jtv, ok := value.(json.Number)
					if !ok {
						return fmt.Errorf("expected BoxedInteger to be json.Number, got %T instead", value)
					}
					i64, err := jtv.Int64()
					if err != nil { return err }
					sv.MaximumPercent = ptr.Int32(int32(i64))
				}
			
			case "minimumHealthyPercent":
				if value != nil {
					jtv, ok := value.(json.Number)
					if !ok {
						return fmt.Errorf("expected BoxedInteger to be json.Number, got %T instead", value)
					}
					i64, err := jtv.Int64()
					if err != nil { return err }
					sv.MinimumHealthyPercent = ptr.Int32(int32(i64))
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeDocumentDeploymentController(v **types.DeploymentController, 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.DeploymentController
	if *v == nil {
		sv = &types.DeploymentController{}
		} 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 DeploymentControllerType to be of type string, got %T instead", value)
					}
					sv.Type = types.DeploymentControllerType(jtv)
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeDocumentDeploymentEphemeralStorage(v **types.DeploymentEphemeralStorage, 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.DeploymentEphemeralStorage
	if *v == nil {
		sv = &types.DeploymentEphemeralStorage{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "kmsKeyId":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.KmsKeyId = ptr.String(jtv)
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeDocumentDeployments(v *[]types.Deployment, 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.Deployment
	if *v == nil {
		cv = []types.Deployment{}
		} else {
			cv = *v
		}
	
	for _, value := range shape {
		var col types.Deployment
		destAddr := &col
		if err := awsAwsjson11_deserializeDocumentDeployment(&destAddr, value); err != nil {
			return err
		}
		col = *destAddr
		cv = append(cv, col)
		
	}
	*v = cv
	return nil
}

func awsAwsjson11_deserializeDocumentDevice(v **types.Device, 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.Device
	if *v == nil {
		sv = &types.Device{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "containerPath":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.ContainerPath = ptr.String(jtv)
				}
			
			case "hostPath":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.HostPath = ptr.String(jtv)
				}
			
			case "permissions":
				if err := awsAwsjson11_deserializeDocumentDeviceCgroupPermissions(&sv.Permissions, value); err != nil {
					return err
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeDocumentDeviceCgroupPermissions(v *[]types.DeviceCgroupPermission, 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.DeviceCgroupPermission
	if *v == nil {
		cv = []types.DeviceCgroupPermission{}
		} else {
			cv = *v
		}
	
	for _, value := range shape {
		var col types.DeviceCgroupPermission
		if value != nil {
			jtv, ok := value.(string)
			if !ok {
				return fmt.Errorf("expected DeviceCgroupPermission to be of type string, got %T instead", value)
			}
			col = types.DeviceCgroupPermission(jtv)
		}
		cv = append(cv, col)
		
	}
	*v = cv
	return nil
}

func awsAwsjson11_deserializeDocumentDevicesList(v *[]types.Device, 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.Device
	if *v == nil {
		cv = []types.Device{}
		} else {
			cv = *v
		}
	
	for _, value := range shape {
		var col types.Device
		destAddr := &col
		if err := awsAwsjson11_deserializeDocumentDevice(&destAddr, value); err != nil {
			return err
		}
		col = *destAddr
		cv = append(cv, col)
		
	}
	*v = cv
	return nil
}

func awsAwsjson11_deserializeDocumentDockerLabelsMap(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 String to be of type string, got %T instead", value)
			}
			parsedVal = jtv
		}
		mv[key] = parsedVal
		
	}
	*v = mv
	return nil
}

func awsAwsjson11_deserializeDocumentDockerVolumeConfiguration(v **types.DockerVolumeConfiguration, 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.DockerVolumeConfiguration
	if *v == nil {
		sv = &types.DockerVolumeConfiguration{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "autoprovision":
				if value != nil {
					jtv, ok := value.(bool)
					if !ok {
						return fmt.Errorf("expected BoxedBoolean to be of type *bool, got %T instead", value)
					}
					sv.Autoprovision = ptr.Bool(jtv)
				}
			
			case "driver":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.Driver = ptr.String(jtv)
				}
			
			case "driverOpts":
				if err := awsAwsjson11_deserializeDocumentStringMap(&sv.DriverOpts, value); err != nil {
					return err
				}
			
			case "labels":
				if err := awsAwsjson11_deserializeDocumentStringMap(&sv.Labels, value); err != nil {
					return err
				}
			
			case "scope":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected Scope to be of type string, got %T instead", value)
					}
					sv.Scope = types.Scope(jtv)
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeDocumentEBSTagSpecification(v **types.EBSTagSpecification, 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.EBSTagSpecification
	if *v == nil {
		sv = &types.EBSTagSpecification{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "propagateTags":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected PropagateTags to be of type string, got %T instead", value)
					}
					sv.PropagateTags = types.PropagateTags(jtv)
				}
			
			case "resourceType":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected EBSResourceType to be of type string, got %T instead", value)
					}
					sv.ResourceType = types.EBSResourceType(jtv)
				}
			
			case "tags":
				if err := awsAwsjson11_deserializeDocumentTags(&sv.Tags, value); err != nil {
					return err
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeDocumentEBSTagSpecifications(v *[]types.EBSTagSpecification, 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.EBSTagSpecification
	if *v == nil {
		cv = []types.EBSTagSpecification{}
		} else {
			cv = *v
		}
	
	for _, value := range shape {
		var col types.EBSTagSpecification
		destAddr := &col
		if err := awsAwsjson11_deserializeDocumentEBSTagSpecification(&destAddr, value); err != nil {
			return err
		}
		col = *destAddr
		cv = append(cv, col)
		
	}
	*v = cv
	return nil
}

func awsAwsjson11_deserializeDocumentEFSAuthorizationConfig(v **types.EFSAuthorizationConfig, 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.EFSAuthorizationConfig
	if *v == nil {
		sv = &types.EFSAuthorizationConfig{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "accessPointId":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.AccessPointId = ptr.String(jtv)
				}
			
			case "iam":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected EFSAuthorizationConfigIAM to be of type string, got %T instead", value)
					}
					sv.Iam = types.EFSAuthorizationConfigIAM(jtv)
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeDocumentEFSVolumeConfiguration(v **types.EFSVolumeConfiguration, 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.EFSVolumeConfiguration
	if *v == nil {
		sv = &types.EFSVolumeConfiguration{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "authorizationConfig":
				if err := awsAwsjson11_deserializeDocumentEFSAuthorizationConfig(&sv.AuthorizationConfig, value); err != nil {
					return err
				}
			
			case "fileSystemId":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.FileSystemId = ptr.String(jtv)
				}
			
			case "rootDirectory":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.RootDirectory = ptr.String(jtv)
				}
			
			case "transitEncryption":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected EFSTransitEncryption to be of type string, got %T instead", value)
					}
					sv.TransitEncryption = types.EFSTransitEncryption(jtv)
				}
			
			case "transitEncryptionPort":
				if value != nil {
					jtv, ok := value.(json.Number)
					if !ok {
						return fmt.Errorf("expected BoxedInteger to be json.Number, got %T instead", value)
					}
					i64, err := jtv.Int64()
					if err != nil { return err }
					sv.TransitEncryptionPort = ptr.Int32(int32(i64))
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeDocumentEnvironmentFile(v **types.EnvironmentFile, 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.EnvironmentFile
	if *v == nil {
		sv = &types.EnvironmentFile{}
		} 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 EnvironmentFileType to be of type string, got %T instead", value)
					}
					sv.Type = types.EnvironmentFileType(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 awsAwsjson11_deserializeDocumentEnvironmentFiles(v *[]types.EnvironmentFile, 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.EnvironmentFile
	if *v == nil {
		cv = []types.EnvironmentFile{}
		} else {
			cv = *v
		}
	
	for _, value := range shape {
		var col types.EnvironmentFile
		destAddr := &col
		if err := awsAwsjson11_deserializeDocumentEnvironmentFile(&destAddr, value); err != nil {
			return err
		}
		col = *destAddr
		cv = append(cv, col)
		
	}
	*v = cv
	return nil
}

func awsAwsjson11_deserializeDocumentEnvironmentVariables(v *[]types.KeyValuePair, 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.KeyValuePair
	if *v == nil {
		cv = []types.KeyValuePair{}
		} else {
			cv = *v
		}
	
	for _, value := range shape {
		var col types.KeyValuePair
		destAddr := &col
		if err := awsAwsjson11_deserializeDocumentKeyValuePair(&destAddr, value); err != nil {
			return err
		}
		col = *destAddr
		cv = append(cv, col)
		
	}
	*v = cv
	return nil
}

func awsAwsjson11_deserializeDocumentEphemeralStorage(v **types.EphemeralStorage, 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.EphemeralStorage
	if *v == nil {
		sv = &types.EphemeralStorage{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "sizeInGiB":
				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.SizeInGiB = int32(i64)
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeDocumentExecuteCommandConfiguration(v **types.ExecuteCommandConfiguration, 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.ExecuteCommandConfiguration
	if *v == nil {
		sv = &types.ExecuteCommandConfiguration{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "kmsKeyId":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.KmsKeyId = ptr.String(jtv)
				}
			
			case "logConfiguration":
				if err := awsAwsjson11_deserializeDocumentExecuteCommandLogConfiguration(&sv.LogConfiguration, value); err != nil {
					return err
				}
			
			case "logging":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected ExecuteCommandLogging to be of type string, got %T instead", value)
					}
					sv.Logging = types.ExecuteCommandLogging(jtv)
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeDocumentExecuteCommandLogConfiguration(v **types.ExecuteCommandLogConfiguration, 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.ExecuteCommandLogConfiguration
	if *v == nil {
		sv = &types.ExecuteCommandLogConfiguration{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "cloudWatchEncryptionEnabled":
				if value != nil {
					jtv, ok := value.(bool)
					if !ok {
						return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value)
					}
					sv.CloudWatchEncryptionEnabled = jtv
				}
			
			case "cloudWatchLogGroupName":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.CloudWatchLogGroupName = ptr.String(jtv)
				}
			
			case "s3BucketName":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.S3BucketName = ptr.String(jtv)
				}
			
			case "s3EncryptionEnabled":
				if value != nil {
					jtv, ok := value.(bool)
					if !ok {
						return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value)
					}
					sv.S3EncryptionEnabled = jtv
				}
			
			case "s3KeyPrefix":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.S3KeyPrefix = ptr.String(jtv)
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeDocumentFailure(v **types.Failure, 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.Failure
	if *v == nil {
		sv = &types.Failure{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "arn":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.Arn = ptr.String(jtv)
				}
			
			case "detail":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.Detail = ptr.String(jtv)
				}
			
			case "reason":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.Reason = ptr.String(jtv)
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeDocumentFailures(v *[]types.Failure, 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.Failure
	if *v == nil {
		cv = []types.Failure{}
		} else {
			cv = *v
		}
	
	for _, value := range shape {
		var col types.Failure
		destAddr := &col
		if err := awsAwsjson11_deserializeDocumentFailure(&destAddr, value); err != nil {
			return err
		}
		col = *destAddr
		cv = append(cv, col)
		
	}
	*v = cv
	return nil
}

func awsAwsjson11_deserializeDocumentFirelensConfiguration(v **types.FirelensConfiguration, 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.FirelensConfiguration
	if *v == nil {
		sv = &types.FirelensConfiguration{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "options":
				if err := awsAwsjson11_deserializeDocumentFirelensConfigurationOptionsMap(&sv.Options, value); err != nil {
					return err
				}
			
			case "type":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected FirelensConfigurationType to be of type string, got %T instead", value)
					}
					sv.Type = types.FirelensConfigurationType(jtv)
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeDocumentFirelensConfigurationOptionsMap(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 String to be of type string, got %T instead", value)
			}
			parsedVal = jtv
		}
		mv[key] = parsedVal
		
	}
	*v = mv
	return nil
}

func awsAwsjson11_deserializeDocumentFSxWindowsFileServerAuthorizationConfig(v **types.FSxWindowsFileServerAuthorizationConfig, 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.FSxWindowsFileServerAuthorizationConfig
	if *v == nil {
		sv = &types.FSxWindowsFileServerAuthorizationConfig{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "credentialsParameter":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.CredentialsParameter = ptr.String(jtv)
				}
			
			case "domain":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.Domain = ptr.String(jtv)
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeDocumentFSxWindowsFileServerVolumeConfiguration(v **types.FSxWindowsFileServerVolumeConfiguration, 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.FSxWindowsFileServerVolumeConfiguration
	if *v == nil {
		sv = &types.FSxWindowsFileServerVolumeConfiguration{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "authorizationConfig":
				if err := awsAwsjson11_deserializeDocumentFSxWindowsFileServerAuthorizationConfig(&sv.AuthorizationConfig, value); err != nil {
					return err
				}
			
			case "fileSystemId":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.FileSystemId = ptr.String(jtv)
				}
			
			case "rootDirectory":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.RootDirectory = ptr.String(jtv)
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeDocumentGpuIds(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 awsAwsjson11_deserializeDocumentHealthCheck(v **types.HealthCheck, 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.HealthCheck
	if *v == nil {
		sv = &types.HealthCheck{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "command":
				if err := awsAwsjson11_deserializeDocumentStringList(&sv.Command, value); err != nil {
					return err
				}
			
			case "interval":
				if value != nil {
					jtv, ok := value.(json.Number)
					if !ok {
						return fmt.Errorf("expected BoxedInteger to be json.Number, got %T instead", value)
					}
					i64, err := jtv.Int64()
					if err != nil { return err }
					sv.Interval = ptr.Int32(int32(i64))
				}
			
			case "retries":
				if value != nil {
					jtv, ok := value.(json.Number)
					if !ok {
						return fmt.Errorf("expected BoxedInteger to be json.Number, got %T instead", value)
					}
					i64, err := jtv.Int64()
					if err != nil { return err }
					sv.Retries = ptr.Int32(int32(i64))
				}
			
			case "startPeriod":
				if value != nil {
					jtv, ok := value.(json.Number)
					if !ok {
						return fmt.Errorf("expected BoxedInteger to be json.Number, got %T instead", value)
					}
					i64, err := jtv.Int64()
					if err != nil { return err }
					sv.StartPeriod = ptr.Int32(int32(i64))
				}
			
			case "timeout":
				if value != nil {
					jtv, ok := value.(json.Number)
					if !ok {
						return fmt.Errorf("expected BoxedInteger to be json.Number, got %T instead", value)
					}
					i64, err := jtv.Int64()
					if err != nil { return err }
					sv.Timeout = ptr.Int32(int32(i64))
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeDocumentHostEntry(v **types.HostEntry, 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.HostEntry
	if *v == nil {
		sv = &types.HostEntry{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "hostname":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.Hostname = ptr.String(jtv)
				}
			
			case "ipAddress":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.IpAddress = ptr.String(jtv)
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeDocumentHostEntryList(v *[]types.HostEntry, 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.HostEntry
	if *v == nil {
		cv = []types.HostEntry{}
		} else {
			cv = *v
		}
	
	for _, value := range shape {
		var col types.HostEntry
		destAddr := &col
		if err := awsAwsjson11_deserializeDocumentHostEntry(&destAddr, value); err != nil {
			return err
		}
		col = *destAddr
		cv = append(cv, col)
		
	}
	*v = cv
	return nil
}

func awsAwsjson11_deserializeDocumentHostVolumeProperties(v **types.HostVolumeProperties, 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.HostVolumeProperties
	if *v == nil {
		sv = &types.HostVolumeProperties{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "sourcePath":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.SourcePath = ptr.String(jtv)
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeDocumentInferenceAccelerator(v **types.InferenceAccelerator, 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.InferenceAccelerator
	if *v == nil {
		sv = &types.InferenceAccelerator{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "deviceName":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.DeviceName = ptr.String(jtv)
				}
			
			case "deviceType":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.DeviceType = ptr.String(jtv)
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeDocumentInferenceAcceleratorOverride(v **types.InferenceAcceleratorOverride, 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.InferenceAcceleratorOverride
	if *v == nil {
		sv = &types.InferenceAcceleratorOverride{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "deviceName":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.DeviceName = ptr.String(jtv)
				}
			
			case "deviceType":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.DeviceType = ptr.String(jtv)
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeDocumentInferenceAcceleratorOverrides(v *[]types.InferenceAcceleratorOverride, 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.InferenceAcceleratorOverride
	if *v == nil {
		cv = []types.InferenceAcceleratorOverride{}
		} else {
			cv = *v
		}
	
	for _, value := range shape {
		var col types.InferenceAcceleratorOverride
		destAddr := &col
		if err := awsAwsjson11_deserializeDocumentInferenceAcceleratorOverride(&destAddr, value); err != nil {
			return err
		}
		col = *destAddr
		cv = append(cv, col)
		
	}
	*v = cv
	return nil
}

func awsAwsjson11_deserializeDocumentInferenceAccelerators(v *[]types.InferenceAccelerator, 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.InferenceAccelerator
	if *v == nil {
		cv = []types.InferenceAccelerator{}
		} else {
			cv = *v
		}
	
	for _, value := range shape {
		var col types.InferenceAccelerator
		destAddr := &col
		if err := awsAwsjson11_deserializeDocumentInferenceAccelerator(&destAddr, value); err != nil {
			return err
		}
		col = *destAddr
		cv = append(cv, col)
		
	}
	*v = cv
	return nil
}

func awsAwsjson11_deserializeDocumentInstanceHealthCheckResult(v **types.InstanceHealthCheckResult, 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.InstanceHealthCheckResult
	if *v == nil {
		sv = &types.InstanceHealthCheckResult{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "lastStatusChange":
				if value != nil {
					switch jtv := value.(type) {
						case json.Number:
							f64, err := jtv.Float64()
							if err != nil { return err }
							sv.LastStatusChange = ptr.Time(smithytime.ParseEpochSeconds(f64))
						
						default:
							return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value)
						
					}
				}
			
			case "lastUpdated":
				if value != nil {
					switch jtv := value.(type) {
						case json.Number:
							f64, err := jtv.Float64()
							if err != nil { return err }
							sv.LastUpdated = 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 InstanceHealthCheckState to be of type string, got %T instead", value)
					}
					sv.Status = types.InstanceHealthCheckState(jtv)
				}
			
			case "type":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected InstanceHealthCheckType to be of type string, got %T instead", value)
					}
					sv.Type = types.InstanceHealthCheckType(jtv)
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeDocumentInstanceHealthCheckResultList(v *[]types.InstanceHealthCheckResult, 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.InstanceHealthCheckResult
	if *v == nil {
		cv = []types.InstanceHealthCheckResult{}
		} else {
			cv = *v
		}
	
	for _, value := range shape {
		var col types.InstanceHealthCheckResult
		destAddr := &col
		if err := awsAwsjson11_deserializeDocumentInstanceHealthCheckResult(&destAddr, value); err != nil {
			return err
		}
		col = *destAddr
		cv = append(cv, col)
		
	}
	*v = cv
	return nil
}

func awsAwsjson11_deserializeDocumentIntegerList(v *[]int32, 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 []int32
	if *v == nil {
		cv = []int32{}
		} else {
			cv = *v
		}
	
	for _, value := range shape {
		var col int32
		if value != nil {
			jtv, ok := value.(json.Number)
			if !ok {
				return fmt.Errorf("expected BoxedInteger to be json.Number, got %T instead", value)
			}
			i64, err := jtv.Int64()
			if err != nil { return err }
			col = int32(i64)
		}
		cv = append(cv, col)
		
	}
	*v = cv
	return nil
}

func awsAwsjson11_deserializeDocumentInvalidParameterException(v **types.InvalidParameterException, 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.InvalidParameterException
	if *v == nil {
		sv = &types.InvalidParameterException{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "message":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.Message = ptr.String(jtv)
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeDocumentKernelCapabilities(v **types.KernelCapabilities, 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.KernelCapabilities
	if *v == nil {
		sv = &types.KernelCapabilities{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "add":
				if err := awsAwsjson11_deserializeDocumentStringList(&sv.Add, value); err != nil {
					return err
				}
			
			case "drop":
				if err := awsAwsjson11_deserializeDocumentStringList(&sv.Drop, value); err != nil {
					return err
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeDocumentKeyValuePair(v **types.KeyValuePair, 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.KeyValuePair
	if *v == nil {
		sv = &types.KeyValuePair{}
		} 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 "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 awsAwsjson11_deserializeDocumentLimitExceededException(v **types.LimitExceededException, 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.LimitExceededException
	if *v == nil {
		sv = &types.LimitExceededException{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "message":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.Message = ptr.String(jtv)
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeDocumentLinuxParameters(v **types.LinuxParameters, 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.LinuxParameters
	if *v == nil {
		sv = &types.LinuxParameters{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "capabilities":
				if err := awsAwsjson11_deserializeDocumentKernelCapabilities(&sv.Capabilities, value); err != nil {
					return err
				}
			
			case "devices":
				if err := awsAwsjson11_deserializeDocumentDevicesList(&sv.Devices, value); err != nil {
					return err
				}
			
			case "initProcessEnabled":
				if value != nil {
					jtv, ok := value.(bool)
					if !ok {
						return fmt.Errorf("expected BoxedBoolean to be of type *bool, got %T instead", value)
					}
					sv.InitProcessEnabled = ptr.Bool(jtv)
				}
			
			case "maxSwap":
				if value != nil {
					jtv, ok := value.(json.Number)
					if !ok {
						return fmt.Errorf("expected BoxedInteger to be json.Number, got %T instead", value)
					}
					i64, err := jtv.Int64()
					if err != nil { return err }
					sv.MaxSwap = ptr.Int32(int32(i64))
				}
			
			case "sharedMemorySize":
				if value != nil {
					jtv, ok := value.(json.Number)
					if !ok {
						return fmt.Errorf("expected BoxedInteger to be json.Number, got %T instead", value)
					}
					i64, err := jtv.Int64()
					if err != nil { return err }
					sv.SharedMemorySize = ptr.Int32(int32(i64))
				}
			
			case "swappiness":
				if value != nil {
					jtv, ok := value.(json.Number)
					if !ok {
						return fmt.Errorf("expected BoxedInteger to be json.Number, got %T instead", value)
					}
					i64, err := jtv.Int64()
					if err != nil { return err }
					sv.Swappiness = ptr.Int32(int32(i64))
				}
			
			case "tmpfs":
				if err := awsAwsjson11_deserializeDocumentTmpfsList(&sv.Tmpfs, value); err != nil {
					return err
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeDocumentLoadBalancer(v **types.LoadBalancer, 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.LoadBalancer
	if *v == nil {
		sv = &types.LoadBalancer{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "containerName":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.ContainerName = ptr.String(jtv)
				}
			
			case "containerPort":
				if value != nil {
					jtv, ok := value.(json.Number)
					if !ok {
						return fmt.Errorf("expected BoxedInteger to be json.Number, got %T instead", value)
					}
					i64, err := jtv.Int64()
					if err != nil { return err }
					sv.ContainerPort = ptr.Int32(int32(i64))
				}
			
			case "loadBalancerName":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.LoadBalancerName = ptr.String(jtv)
				}
			
			case "targetGroupArn":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.TargetGroupArn = ptr.String(jtv)
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeDocumentLoadBalancers(v *[]types.LoadBalancer, 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.LoadBalancer
	if *v == nil {
		cv = []types.LoadBalancer{}
		} else {
			cv = *v
		}
	
	for _, value := range shape {
		var col types.LoadBalancer
		destAddr := &col
		if err := awsAwsjson11_deserializeDocumentLoadBalancer(&destAddr, value); err != nil {
			return err
		}
		col = *destAddr
		cv = append(cv, col)
		
	}
	*v = cv
	return nil
}

func awsAwsjson11_deserializeDocumentLogConfiguration(v **types.LogConfiguration, 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.LogConfiguration
	if *v == nil {
		sv = &types.LogConfiguration{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "logDriver":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected LogDriver to be of type string, got %T instead", value)
					}
					sv.LogDriver = types.LogDriver(jtv)
				}
			
			case "options":
				if err := awsAwsjson11_deserializeDocumentLogConfigurationOptionsMap(&sv.Options, value); err != nil {
					return err
				}
			
			case "secretOptions":
				if err := awsAwsjson11_deserializeDocumentSecretList(&sv.SecretOptions, value); err != nil {
					return err
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeDocumentLogConfigurationOptionsMap(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 String to be of type string, got %T instead", value)
			}
			parsedVal = jtv
		}
		mv[key] = parsedVal
		
	}
	*v = mv
	return nil
}

func awsAwsjson11_deserializeDocumentManagedAgent(v **types.ManagedAgent, 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.ManagedAgent
	if *v == nil {
		sv = &types.ManagedAgent{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "lastStartedAt":
				if value != nil {
					switch jtv := value.(type) {
						case json.Number:
							f64, err := jtv.Float64()
							if err != nil { return err }
							sv.LastStartedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
						
						default:
							return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value)
						
					}
				}
			
			case "lastStatus":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.LastStatus = ptr.String(jtv)
				}
			
			case "name":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected ManagedAgentName to be of type string, got %T instead", value)
					}
					sv.Name = types.ManagedAgentName(jtv)
				}
			
			case "reason":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.Reason = ptr.String(jtv)
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeDocumentManagedAgents(v *[]types.ManagedAgent, 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.ManagedAgent
	if *v == nil {
		cv = []types.ManagedAgent{}
		} else {
			cv = *v
		}
	
	for _, value := range shape {
		var col types.ManagedAgent
		destAddr := &col
		if err := awsAwsjson11_deserializeDocumentManagedAgent(&destAddr, value); err != nil {
			return err
		}
		col = *destAddr
		cv = append(cv, col)
		
	}
	*v = cv
	return nil
}

func awsAwsjson11_deserializeDocumentManagedScaling(v **types.ManagedScaling, 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.ManagedScaling
	if *v == nil {
		sv = &types.ManagedScaling{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "instanceWarmupPeriod":
				if value != nil {
					jtv, ok := value.(json.Number)
					if !ok {
						return fmt.Errorf("expected ManagedScalingInstanceWarmupPeriod to be json.Number, got %T instead", value)
					}
					i64, err := jtv.Int64()
					if err != nil { return err }
					sv.InstanceWarmupPeriod = ptr.Int32(int32(i64))
				}
			
			case "maximumScalingStepSize":
				if value != nil {
					jtv, ok := value.(json.Number)
					if !ok {
						return fmt.Errorf("expected ManagedScalingStepSize to be json.Number, got %T instead", value)
					}
					i64, err := jtv.Int64()
					if err != nil { return err }
					sv.MaximumScalingStepSize = ptr.Int32(int32(i64))
				}
			
			case "minimumScalingStepSize":
				if value != nil {
					jtv, ok := value.(json.Number)
					if !ok {
						return fmt.Errorf("expected ManagedScalingStepSize to be json.Number, got %T instead", value)
					}
					i64, err := jtv.Int64()
					if err != nil { return err }
					sv.MinimumScalingStepSize = ptr.Int32(int32(i64))
				}
			
			case "status":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected ManagedScalingStatus to be of type string, got %T instead", value)
					}
					sv.Status = types.ManagedScalingStatus(jtv)
				}
			
			case "targetCapacity":
				if value != nil {
					jtv, ok := value.(json.Number)
					if !ok {
						return fmt.Errorf("expected ManagedScalingTargetCapacity to be json.Number, got %T instead", value)
					}
					i64, err := jtv.Int64()
					if err != nil { return err }
					sv.TargetCapacity = ptr.Int32(int32(i64))
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeDocumentManagedStorageConfiguration(v **types.ManagedStorageConfiguration, 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.ManagedStorageConfiguration
	if *v == nil {
		sv = &types.ManagedStorageConfiguration{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "fargateEphemeralStorageKmsKeyId":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.FargateEphemeralStorageKmsKeyId = ptr.String(jtv)
				}
			
			case "kmsKeyId":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.KmsKeyId = ptr.String(jtv)
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeDocumentMissingVersionException(v **types.MissingVersionException, 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.MissingVersionException
	if *v == nil {
		sv = &types.MissingVersionException{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "message":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.Message = ptr.String(jtv)
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeDocumentMountPoint(v **types.MountPoint, 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.MountPoint
	if *v == nil {
		sv = &types.MountPoint{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "containerPath":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.ContainerPath = ptr.String(jtv)
				}
			
			case "readOnly":
				if value != nil {
					jtv, ok := value.(bool)
					if !ok {
						return fmt.Errorf("expected BoxedBoolean to be of type *bool, got %T instead", value)
					}
					sv.ReadOnly = ptr.Bool(jtv)
				}
			
			case "sourceVolume":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.SourceVolume = ptr.String(jtv)
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeDocumentMountPointList(v *[]types.MountPoint, 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.MountPoint
	if *v == nil {
		cv = []types.MountPoint{}
		} else {
			cv = *v
		}
	
	for _, value := range shape {
		var col types.MountPoint
		destAddr := &col
		if err := awsAwsjson11_deserializeDocumentMountPoint(&destAddr, value); err != nil {
			return err
		}
		col = *destAddr
		cv = append(cv, col)
		
	}
	*v = cv
	return nil
}

func awsAwsjson11_deserializeDocumentNamespaceNotFoundException(v **types.NamespaceNotFoundException, 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.NamespaceNotFoundException
	if *v == nil {
		sv = &types.NamespaceNotFoundException{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "message":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.Message = ptr.String(jtv)
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeDocumentNetworkBinding(v **types.NetworkBinding, 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.NetworkBinding
	if *v == nil {
		sv = &types.NetworkBinding{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "bindIP":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.BindIP = ptr.String(jtv)
				}
			
			case "containerPort":
				if value != nil {
					jtv, ok := value.(json.Number)
					if !ok {
						return fmt.Errorf("expected BoxedInteger to be json.Number, got %T instead", value)
					}
					i64, err := jtv.Int64()
					if err != nil { return err }
					sv.ContainerPort = ptr.Int32(int32(i64))
				}
			
			case "containerPortRange":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.ContainerPortRange = ptr.String(jtv)
				}
			
			case "hostPort":
				if value != nil {
					jtv, ok := value.(json.Number)
					if !ok {
						return fmt.Errorf("expected BoxedInteger to be json.Number, got %T instead", value)
					}
					i64, err := jtv.Int64()
					if err != nil { return err }
					sv.HostPort = ptr.Int32(int32(i64))
				}
			
			case "hostPortRange":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.HostPortRange = ptr.String(jtv)
				}
			
			case "protocol":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected TransportProtocol to be of type string, got %T instead", value)
					}
					sv.Protocol = types.TransportProtocol(jtv)
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeDocumentNetworkBindings(v *[]types.NetworkBinding, 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.NetworkBinding
	if *v == nil {
		cv = []types.NetworkBinding{}
		} else {
			cv = *v
		}
	
	for _, value := range shape {
		var col types.NetworkBinding
		destAddr := &col
		if err := awsAwsjson11_deserializeDocumentNetworkBinding(&destAddr, value); err != nil {
			return err
		}
		col = *destAddr
		cv = append(cv, col)
		
	}
	*v = cv
	return nil
}

func awsAwsjson11_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 "awsvpcConfiguration":
				if err := awsAwsjson11_deserializeDocumentAwsVpcConfiguration(&sv.AwsvpcConfiguration, value); err != nil {
					return err
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeDocumentNetworkInterface(v **types.NetworkInterface, 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.NetworkInterface
	if *v == nil {
		sv = &types.NetworkInterface{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "attachmentId":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.AttachmentId = ptr.String(jtv)
				}
			
			case "ipv6Address":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.Ipv6Address = ptr.String(jtv)
				}
			
			case "privateIpv4Address":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.PrivateIpv4Address = ptr.String(jtv)
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeDocumentNetworkInterfaces(v *[]types.NetworkInterface, 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.NetworkInterface
	if *v == nil {
		cv = []types.NetworkInterface{}
		} else {
			cv = *v
		}
	
	for _, value := range shape {
		var col types.NetworkInterface
		destAddr := &col
		if err := awsAwsjson11_deserializeDocumentNetworkInterface(&destAddr, value); err != nil {
			return err
		}
		col = *destAddr
		cv = append(cv, col)
		
	}
	*v = cv
	return nil
}

func awsAwsjson11_deserializeDocumentNoUpdateAvailableException(v **types.NoUpdateAvailableException, 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.NoUpdateAvailableException
	if *v == nil {
		sv = &types.NoUpdateAvailableException{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "message":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.Message = ptr.String(jtv)
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeDocumentPlacementConstraint(v **types.PlacementConstraint, 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.PlacementConstraint
	if *v == nil {
		sv = &types.PlacementConstraint{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "expression":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.Expression = ptr.String(jtv)
				}
			
			case "type":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected PlacementConstraintType to be of type string, got %T instead", value)
					}
					sv.Type = types.PlacementConstraintType(jtv)
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeDocumentPlacementConstraints(v *[]types.PlacementConstraint, 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.PlacementConstraint
	if *v == nil {
		cv = []types.PlacementConstraint{}
		} else {
			cv = *v
		}
	
	for _, value := range shape {
		var col types.PlacementConstraint
		destAddr := &col
		if err := awsAwsjson11_deserializeDocumentPlacementConstraint(&destAddr, value); err != nil {
			return err
		}
		col = *destAddr
		cv = append(cv, col)
		
	}
	*v = cv
	return nil
}

func awsAwsjson11_deserializeDocumentPlacementStrategies(v *[]types.PlacementStrategy, 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.PlacementStrategy
	if *v == nil {
		cv = []types.PlacementStrategy{}
		} else {
			cv = *v
		}
	
	for _, value := range shape {
		var col types.PlacementStrategy
		destAddr := &col
		if err := awsAwsjson11_deserializeDocumentPlacementStrategy(&destAddr, value); err != nil {
			return err
		}
		col = *destAddr
		cv = append(cv, col)
		
	}
	*v = cv
	return nil
}

func awsAwsjson11_deserializeDocumentPlacementStrategy(v **types.PlacementStrategy, 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.PlacementStrategy
	if *v == nil {
		sv = &types.PlacementStrategy{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "field":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.Field = ptr.String(jtv)
				}
			
			case "type":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected PlacementStrategyType to be of type string, got %T instead", value)
					}
					sv.Type = types.PlacementStrategyType(jtv)
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeDocumentPlatformTaskDefinitionIncompatibilityException(v **types.PlatformTaskDefinitionIncompatibilityException, 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.PlatformTaskDefinitionIncompatibilityException
	if *v == nil {
		sv = &types.PlatformTaskDefinitionIncompatibilityException{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "message":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.Message = ptr.String(jtv)
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeDocumentPlatformUnknownException(v **types.PlatformUnknownException, 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.PlatformUnknownException
	if *v == nil {
		sv = &types.PlatformUnknownException{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "message":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.Message = ptr.String(jtv)
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeDocumentPortMapping(v **types.PortMapping, 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.PortMapping
	if *v == nil {
		sv = &types.PortMapping{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "appProtocol":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected ApplicationProtocol to be of type string, got %T instead", value)
					}
					sv.AppProtocol = types.ApplicationProtocol(jtv)
				}
			
			case "containerPort":
				if value != nil {
					jtv, ok := value.(json.Number)
					if !ok {
						return fmt.Errorf("expected BoxedInteger to be json.Number, got %T instead", value)
					}
					i64, err := jtv.Int64()
					if err != nil { return err }
					sv.ContainerPort = ptr.Int32(int32(i64))
				}
			
			case "containerPortRange":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.ContainerPortRange = ptr.String(jtv)
				}
			
			case "hostPort":
				if value != nil {
					jtv, ok := value.(json.Number)
					if !ok {
						return fmt.Errorf("expected BoxedInteger to be json.Number, got %T instead", value)
					}
					i64, err := jtv.Int64()
					if err != nil { return err }
					sv.HostPort = ptr.Int32(int32(i64))
				}
			
			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 "protocol":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected TransportProtocol to be of type string, got %T instead", value)
					}
					sv.Protocol = types.TransportProtocol(jtv)
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeDocumentPortMappingList(v *[]types.PortMapping, 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.PortMapping
	if *v == nil {
		cv = []types.PortMapping{}
		} else {
			cv = *v
		}
	
	for _, value := range shape {
		var col types.PortMapping
		destAddr := &col
		if err := awsAwsjson11_deserializeDocumentPortMapping(&destAddr, value); err != nil {
			return err
		}
		col = *destAddr
		cv = append(cv, col)
		
	}
	*v = cv
	return nil
}

func awsAwsjson11_deserializeDocumentProtectedTask(v **types.ProtectedTask, 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.ProtectedTask
	if *v == nil {
		sv = &types.ProtectedTask{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "expirationDate":
				if value != nil {
					switch jtv := value.(type) {
						case json.Number:
							f64, err := jtv.Float64()
							if err != nil { return err }
							sv.ExpirationDate = ptr.Time(smithytime.ParseEpochSeconds(f64))
						
						default:
							return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value)
						
					}
				}
			
			case "protectionEnabled":
				if value != nil {
					jtv, ok := value.(bool)
					if !ok {
						return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value)
					}
					sv.ProtectionEnabled = jtv
				}
			
			case "taskArn":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.TaskArn = ptr.String(jtv)
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeDocumentProtectedTasks(v *[]types.ProtectedTask, 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.ProtectedTask
	if *v == nil {
		cv = []types.ProtectedTask{}
		} else {
			cv = *v
		}
	
	for _, value := range shape {
		var col types.ProtectedTask
		destAddr := &col
		if err := awsAwsjson11_deserializeDocumentProtectedTask(&destAddr, value); err != nil {
			return err
		}
		col = *destAddr
		cv = append(cv, col)
		
	}
	*v = cv
	return nil
}

func awsAwsjson11_deserializeDocumentProxyConfiguration(v **types.ProxyConfiguration, 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.ProxyConfiguration
	if *v == nil {
		sv = &types.ProxyConfiguration{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "containerName":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.ContainerName = ptr.String(jtv)
				}
			
			case "properties":
				if err := awsAwsjson11_deserializeDocumentProxyConfigurationProperties(&sv.Properties, value); err != nil {
					return err
				}
			
			case "type":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected ProxyConfigurationType to be of type string, got %T instead", value)
					}
					sv.Type = types.ProxyConfigurationType(jtv)
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeDocumentProxyConfigurationProperties(v *[]types.KeyValuePair, 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.KeyValuePair
	if *v == nil {
		cv = []types.KeyValuePair{}
		} else {
			cv = *v
		}
	
	for _, value := range shape {
		var col types.KeyValuePair
		destAddr := &col
		if err := awsAwsjson11_deserializeDocumentKeyValuePair(&destAddr, value); err != nil {
			return err
		}
		col = *destAddr
		cv = append(cv, col)
		
	}
	*v = cv
	return nil
}

func awsAwsjson11_deserializeDocumentRepositoryCredentials(v **types.RepositoryCredentials, 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.RepositoryCredentials
	if *v == nil {
		sv = &types.RepositoryCredentials{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "credentialsParameter":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.CredentialsParameter = ptr.String(jtv)
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeDocumentRequiresAttributes(v *[]types.Attribute, 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.Attribute
	if *v == nil {
		cv = []types.Attribute{}
		} else {
			cv = *v
		}
	
	for _, value := range shape {
		var col types.Attribute
		destAddr := &col
		if err := awsAwsjson11_deserializeDocumentAttribute(&destAddr, value); err != nil {
			return err
		}
		col = *destAddr
		cv = append(cv, col)
		
	}
	*v = cv
	return nil
}

func awsAwsjson11_deserializeDocumentResource(v **types.Resource, 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.Resource
	if *v == nil {
		sv = &types.Resource{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "doubleValue":
				if value != nil {
					switch jtv := value.(type) {
						case json.Number:
							f64, err := jtv.Float64()
							if err != nil { return err }
							sv.DoubleValue = f64
						
						case string:
							var f64 float64
							switch {
								case strings.EqualFold(jtv, "NaN"):
									f64 = math.NaN()
								
								case strings.EqualFold(jtv, "Infinity"):
									f64 = math.Inf(1)
								
								case strings.EqualFold(jtv, "-Infinity"):
									f64 = math.Inf(-1)
								
								default:
									return fmt.Errorf("unknown JSON number value: %s", jtv)
								
							}
							sv.DoubleValue = f64
						
						default:
							return fmt.Errorf("expected Double to be a JSON Number, got %T instead", value)
						
					}
				}
			
			case "integerValue":
				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.IntegerValue = int32(i64)
				}
			
			case "longValue":
				if value != nil {
					jtv, ok := value.(json.Number)
					if !ok {
						return fmt.Errorf("expected Long to be json.Number, got %T instead", value)
					}
					i64, err := jtv.Int64()
					if err != nil { return err }
					sv.LongValue = i64
				}
			
			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 "stringSetValue":
				if err := awsAwsjson11_deserializeDocumentStringList(&sv.StringSetValue, value); err != nil {
					return err
				}
			
			case "type":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.Type = ptr.String(jtv)
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeDocumentResourceIds(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 awsAwsjson11_deserializeDocumentResourceInUseException(v **types.ResourceInUseException, 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.ResourceInUseException
	if *v == nil {
		sv = &types.ResourceInUseException{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "message":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.Message = ptr.String(jtv)
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_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":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.Message = ptr.String(jtv)
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeDocumentResourceRequirement(v **types.ResourceRequirement, 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.ResourceRequirement
	if *v == nil {
		sv = &types.ResourceRequirement{}
		} 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 ResourceType to be of type string, got %T instead", value)
					}
					sv.Type = types.ResourceType(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 awsAwsjson11_deserializeDocumentResourceRequirements(v *[]types.ResourceRequirement, 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.ResourceRequirement
	if *v == nil {
		cv = []types.ResourceRequirement{}
		} else {
			cv = *v
		}
	
	for _, value := range shape {
		var col types.ResourceRequirement
		destAddr := &col
		if err := awsAwsjson11_deserializeDocumentResourceRequirement(&destAddr, value); err != nil {
			return err
		}
		col = *destAddr
		cv = append(cv, col)
		
	}
	*v = cv
	return nil
}

func awsAwsjson11_deserializeDocumentResources(v *[]types.Resource, 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.Resource
	if *v == nil {
		cv = []types.Resource{}
		} else {
			cv = *v
		}
	
	for _, value := range shape {
		var col types.Resource
		destAddr := &col
		if err := awsAwsjson11_deserializeDocumentResource(&destAddr, value); err != nil {
			return err
		}
		col = *destAddr
		cv = append(cv, col)
		
	}
	*v = cv
	return nil
}

func awsAwsjson11_deserializeDocumentRuntimePlatform(v **types.RuntimePlatform, 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.RuntimePlatform
	if *v == nil {
		sv = &types.RuntimePlatform{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "cpuArchitecture":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected CPUArchitecture to be of type string, got %T instead", value)
					}
					sv.CpuArchitecture = types.CPUArchitecture(jtv)
				}
			
			case "operatingSystemFamily":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected OSFamily to be of type string, got %T instead", value)
					}
					sv.OperatingSystemFamily = types.OSFamily(jtv)
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeDocumentScale(v **types.Scale, 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.Scale
	if *v == nil {
		sv = &types.Scale{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "unit":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected ScaleUnit to be of type string, got %T instead", value)
					}
					sv.Unit = types.ScaleUnit(jtv)
				}
			
			case "value":
				if value != nil {
					switch jtv := value.(type) {
						case json.Number:
							f64, err := jtv.Float64()
							if err != nil { return err }
							sv.Value = f64
						
						case string:
							var f64 float64
							switch {
								case strings.EqualFold(jtv, "NaN"):
									f64 = math.NaN()
								
								case strings.EqualFold(jtv, "Infinity"):
									f64 = math.Inf(1)
								
								case strings.EqualFold(jtv, "-Infinity"):
									f64 = math.Inf(-1)
								
								default:
									return fmt.Errorf("unknown JSON number value: %s", jtv)
								
							}
							sv.Value = f64
						
						default:
							return fmt.Errorf("expected Double to be a JSON Number, got %T instead", value)
						
					}
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeDocumentSecret(v **types.Secret, 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.Secret
	if *v == nil {
		sv = &types.Secret{}
		} 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 "valueFrom":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.ValueFrom = ptr.String(jtv)
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeDocumentSecretList(v *[]types.Secret, 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.Secret
	if *v == nil {
		cv = []types.Secret{}
		} else {
			cv = *v
		}
	
	for _, value := range shape {
		var col types.Secret
		destAddr := &col
		if err := awsAwsjson11_deserializeDocumentSecret(&destAddr, value); err != nil {
			return err
		}
		col = *destAddr
		cv = append(cv, col)
		
	}
	*v = cv
	return nil
}

func awsAwsjson11_deserializeDocumentServerException(v **types.ServerException, 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.ServerException
	if *v == nil {
		sv = &types.ServerException{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "message":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.Message = ptr.String(jtv)
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_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 "capacityProviderStrategy":
				if err := awsAwsjson11_deserializeDocumentCapacityProviderStrategy(&sv.CapacityProviderStrategy, value); err != nil {
					return err
				}
			
			case "clusterArn":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.ClusterArn = 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 "createdBy":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.CreatedBy = ptr.String(jtv)
				}
			
			case "deploymentConfiguration":
				if err := awsAwsjson11_deserializeDocumentDeploymentConfiguration(&sv.DeploymentConfiguration, value); err != nil {
					return err
				}
			
			case "deploymentController":
				if err := awsAwsjson11_deserializeDocumentDeploymentController(&sv.DeploymentController, value); err != nil {
					return err
				}
			
			case "deployments":
				if err := awsAwsjson11_deserializeDocumentDeployments(&sv.Deployments, value); err != nil {
					return err
				}
			
			case "desiredCount":
				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.DesiredCount = int32(i64)
				}
			
			case "enableECSManagedTags":
				if value != nil {
					jtv, ok := value.(bool)
					if !ok {
						return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value)
					}
					sv.EnableECSManagedTags = jtv
				}
			
			case "enableExecuteCommand":
				if value != nil {
					jtv, ok := value.(bool)
					if !ok {
						return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value)
					}
					sv.EnableExecuteCommand = jtv
				}
			
			case "events":
				if err := awsAwsjson11_deserializeDocumentServiceEvents(&sv.Events, value); err != nil {
					return err
				}
			
			case "healthCheckGracePeriodSeconds":
				if value != nil {
					jtv, ok := value.(json.Number)
					if !ok {
						return fmt.Errorf("expected BoxedInteger to be json.Number, got %T instead", value)
					}
					i64, err := jtv.Int64()
					if err != nil { return err }
					sv.HealthCheckGracePeriodSeconds = ptr.Int32(int32(i64))
				}
			
			case "launchType":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected LaunchType to be of type string, got %T instead", value)
					}
					sv.LaunchType = types.LaunchType(jtv)
				}
			
			case "loadBalancers":
				if err := awsAwsjson11_deserializeDocumentLoadBalancers(&sv.LoadBalancers, value); err != nil {
					return err
				}
			
			case "networkConfiguration":
				if err := awsAwsjson11_deserializeDocumentNetworkConfiguration(&sv.NetworkConfiguration, value); err != nil {
					return err
				}
			
			case "pendingCount":
				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.PendingCount = int32(i64)
				}
			
			case "placementConstraints":
				if err := awsAwsjson11_deserializeDocumentPlacementConstraints(&sv.PlacementConstraints, value); err != nil {
					return err
				}
			
			case "placementStrategy":
				if err := awsAwsjson11_deserializeDocumentPlacementStrategies(&sv.PlacementStrategy, value); err != nil {
					return err
				}
			
			case "platformFamily":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.PlatformFamily = ptr.String(jtv)
				}
			
			case "platformVersion":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.PlatformVersion = ptr.String(jtv)
				}
			
			case "propagateTags":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected PropagateTags to be of type string, got %T instead", value)
					}
					sv.PropagateTags = types.PropagateTags(jtv)
				}
			
			case "roleArn":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.RoleArn = ptr.String(jtv)
				}
			
			case "runningCount":
				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.RunningCount = int32(i64)
				}
			
			case "schedulingStrategy":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected SchedulingStrategy to be of type string, got %T instead", value)
					}
					sv.SchedulingStrategy = types.SchedulingStrategy(jtv)
				}
			
			case "serviceArn":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.ServiceArn = ptr.String(jtv)
				}
			
			case "serviceName":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.ServiceName = ptr.String(jtv)
				}
			
			case "serviceRegistries":
				if err := awsAwsjson11_deserializeDocumentServiceRegistries(&sv.ServiceRegistries, value); err != nil {
					return err
				}
			
			case "status":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.Status = ptr.String(jtv)
				}
			
			case "tags":
				if err := awsAwsjson11_deserializeDocumentTags(&sv.Tags, value); err != nil {
					return err
				}
			
			case "taskDefinition":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.TaskDefinition = ptr.String(jtv)
				}
			
			case "taskSets":
				if err := awsAwsjson11_deserializeDocumentTaskSets(&sv.TaskSets, value); err != nil {
					return err
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeDocumentServiceConnectClientAlias(v **types.ServiceConnectClientAlias, 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.ServiceConnectClientAlias
	if *v == nil {
		sv = &types.ServiceConnectClientAlias{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "dnsName":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.DnsName = ptr.String(jtv)
				}
			
			case "port":
				if value != nil {
					jtv, ok := value.(json.Number)
					if !ok {
						return fmt.Errorf("expected PortNumber to be json.Number, got %T instead", value)
					}
					i64, err := jtv.Int64()
					if err != nil { return err }
					sv.Port = ptr.Int32(int32(i64))
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeDocumentServiceConnectClientAliasList(v *[]types.ServiceConnectClientAlias, 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.ServiceConnectClientAlias
	if *v == nil {
		cv = []types.ServiceConnectClientAlias{}
		} else {
			cv = *v
		}
	
	for _, value := range shape {
		var col types.ServiceConnectClientAlias
		destAddr := &col
		if err := awsAwsjson11_deserializeDocumentServiceConnectClientAlias(&destAddr, value); err != nil {
			return err
		}
		col = *destAddr
		cv = append(cv, col)
		
	}
	*v = cv
	return nil
}

func awsAwsjson11_deserializeDocumentServiceConnectConfiguration(v **types.ServiceConnectConfiguration, 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.ServiceConnectConfiguration
	if *v == nil {
		sv = &types.ServiceConnectConfiguration{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "enabled":
				if value != nil {
					jtv, ok := value.(bool)
					if !ok {
						return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value)
					}
					sv.Enabled = jtv
				}
			
			case "logConfiguration":
				if err := awsAwsjson11_deserializeDocumentLogConfiguration(&sv.LogConfiguration, value); err != nil {
					return err
				}
			
			case "namespace":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.Namespace = ptr.String(jtv)
				}
			
			case "services":
				if err := awsAwsjson11_deserializeDocumentServiceConnectServiceList(&sv.Services, value); err != nil {
					return err
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeDocumentServiceConnectService(v **types.ServiceConnectService, 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.ServiceConnectService
	if *v == nil {
		sv = &types.ServiceConnectService{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "clientAliases":
				if err := awsAwsjson11_deserializeDocumentServiceConnectClientAliasList(&sv.ClientAliases, value); err != nil {
					return err
				}
			
			case "discoveryName":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.DiscoveryName = ptr.String(jtv)
				}
			
			case "ingressPortOverride":
				if value != nil {
					jtv, ok := value.(json.Number)
					if !ok {
						return fmt.Errorf("expected PortNumber to be json.Number, got %T instead", value)
					}
					i64, err := jtv.Int64()
					if err != nil { return err }
					sv.IngressPortOverride = ptr.Int32(int32(i64))
				}
			
			case "portName":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.PortName = ptr.String(jtv)
				}
			
			case "timeout":
				if err := awsAwsjson11_deserializeDocumentTimeoutConfiguration(&sv.Timeout, value); err != nil {
					return err
				}
			
			case "tls":
				if err := awsAwsjson11_deserializeDocumentServiceConnectTlsConfiguration(&sv.Tls, value); err != nil {
					return err
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeDocumentServiceConnectServiceList(v *[]types.ServiceConnectService, 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.ServiceConnectService
	if *v == nil {
		cv = []types.ServiceConnectService{}
		} else {
			cv = *v
		}
	
	for _, value := range shape {
		var col types.ServiceConnectService
		destAddr := &col
		if err := awsAwsjson11_deserializeDocumentServiceConnectService(&destAddr, value); err != nil {
			return err
		}
		col = *destAddr
		cv = append(cv, col)
		
	}
	*v = cv
	return nil
}

func awsAwsjson11_deserializeDocumentServiceConnectServiceResource(v **types.ServiceConnectServiceResource, 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.ServiceConnectServiceResource
	if *v == nil {
		sv = &types.ServiceConnectServiceResource{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "discoveryArn":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.DiscoveryArn = ptr.String(jtv)
				}
			
			case "discoveryName":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.DiscoveryName = ptr.String(jtv)
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeDocumentServiceConnectServiceResourceList(v *[]types.ServiceConnectServiceResource, 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.ServiceConnectServiceResource
	if *v == nil {
		cv = []types.ServiceConnectServiceResource{}
		} else {
			cv = *v
		}
	
	for _, value := range shape {
		var col types.ServiceConnectServiceResource
		destAddr := &col
		if err := awsAwsjson11_deserializeDocumentServiceConnectServiceResource(&destAddr, value); err != nil {
			return err
		}
		col = *destAddr
		cv = append(cv, col)
		
	}
	*v = cv
	return nil
}

func awsAwsjson11_deserializeDocumentServiceConnectTlsCertificateAuthority(v **types.ServiceConnectTlsCertificateAuthority, 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.ServiceConnectTlsCertificateAuthority
	if *v == nil {
		sv = &types.ServiceConnectTlsCertificateAuthority{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "awsPcaAuthorityArn":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.AwsPcaAuthorityArn = ptr.String(jtv)
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeDocumentServiceConnectTlsConfiguration(v **types.ServiceConnectTlsConfiguration, 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.ServiceConnectTlsConfiguration
	if *v == nil {
		sv = &types.ServiceConnectTlsConfiguration{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "issuerCertificateAuthority":
				if err := awsAwsjson11_deserializeDocumentServiceConnectTlsCertificateAuthority(&sv.IssuerCertificateAuthority, value); err != nil {
					return err
				}
			
			case "kmsKey":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.KmsKey = ptr.String(jtv)
				}
			
			case "roleArn":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.RoleArn = ptr.String(jtv)
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeDocumentServiceEvent(v **types.ServiceEvent, 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.ServiceEvent
	if *v == nil {
		sv = &types.ServiceEvent{}
		} 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 "id":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.Id = ptr.String(jtv)
				}
			
			case "message":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.Message = ptr.String(jtv)
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeDocumentServiceEvents(v *[]types.ServiceEvent, 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.ServiceEvent
	if *v == nil {
		cv = []types.ServiceEvent{}
		} else {
			cv = *v
		}
	
	for _, value := range shape {
		var col types.ServiceEvent
		destAddr := &col
		if err := awsAwsjson11_deserializeDocumentServiceEvent(&destAddr, value); err != nil {
			return err
		}
		col = *destAddr
		cv = append(cv, col)
		
	}
	*v = cv
	return nil
}

func awsAwsjson11_deserializeDocumentServiceManagedEBSVolumeConfiguration(v **types.ServiceManagedEBSVolumeConfiguration, 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.ServiceManagedEBSVolumeConfiguration
	if *v == nil {
		sv = &types.ServiceManagedEBSVolumeConfiguration{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "encrypted":
				if value != nil {
					jtv, ok := value.(bool)
					if !ok {
						return fmt.Errorf("expected BoxedBoolean to be of type *bool, got %T instead", value)
					}
					sv.Encrypted = ptr.Bool(jtv)
				}
			
			case "filesystemType":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected TaskFilesystemType to be of type string, got %T instead", value)
					}
					sv.FilesystemType = types.TaskFilesystemType(jtv)
				}
			
			case "iops":
				if value != nil {
					jtv, ok := value.(json.Number)
					if !ok {
						return fmt.Errorf("expected BoxedInteger to be json.Number, got %T instead", value)
					}
					i64, err := jtv.Int64()
					if err != nil { return err }
					sv.Iops = ptr.Int32(int32(i64))
				}
			
			case "kmsKeyId":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected EBSKMSKeyId to be of type string, got %T instead", value)
					}
					sv.KmsKeyId = ptr.String(jtv)
				}
			
			case "roleArn":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected IAMRoleArn to be of type string, got %T instead", value)
					}
					sv.RoleArn = ptr.String(jtv)
				}
			
			case "sizeInGiB":
				if value != nil {
					jtv, ok := value.(json.Number)
					if !ok {
						return fmt.Errorf("expected BoxedInteger to be json.Number, got %T instead", value)
					}
					i64, err := jtv.Int64()
					if err != nil { return err }
					sv.SizeInGiB = ptr.Int32(int32(i64))
				}
			
			case "snapshotId":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected EBSSnapshotId to be of type string, got %T instead", value)
					}
					sv.SnapshotId = ptr.String(jtv)
				}
			
			case "tagSpecifications":
				if err := awsAwsjson11_deserializeDocumentEBSTagSpecifications(&sv.TagSpecifications, value); err != nil {
					return err
				}
			
			case "throughput":
				if value != nil {
					jtv, ok := value.(json.Number)
					if !ok {
						return fmt.Errorf("expected BoxedInteger to be json.Number, got %T instead", value)
					}
					i64, err := jtv.Int64()
					if err != nil { return err }
					sv.Throughput = ptr.Int32(int32(i64))
				}
			
			case "volumeType":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected EBSVolumeType to be of type string, got %T instead", value)
					}
					sv.VolumeType = ptr.String(jtv)
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeDocumentServiceNotActiveException(v **types.ServiceNotActiveException, 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.ServiceNotActiveException
	if *v == nil {
		sv = &types.ServiceNotActiveException{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "message":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.Message = ptr.String(jtv)
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeDocumentServiceNotFoundException(v **types.ServiceNotFoundException, 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.ServiceNotFoundException
	if *v == nil {
		sv = &types.ServiceNotFoundException{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "message":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.Message = ptr.String(jtv)
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeDocumentServiceRegistries(v *[]types.ServiceRegistry, 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.ServiceRegistry
	if *v == nil {
		cv = []types.ServiceRegistry{}
		} else {
			cv = *v
		}
	
	for _, value := range shape {
		var col types.ServiceRegistry
		destAddr := &col
		if err := awsAwsjson11_deserializeDocumentServiceRegistry(&destAddr, value); err != nil {
			return err
		}
		col = *destAddr
		cv = append(cv, col)
		
	}
	*v = cv
	return nil
}

func awsAwsjson11_deserializeDocumentServiceRegistry(v **types.ServiceRegistry, 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.ServiceRegistry
	if *v == nil {
		sv = &types.ServiceRegistry{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "containerName":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.ContainerName = ptr.String(jtv)
				}
			
			case "containerPort":
				if value != nil {
					jtv, ok := value.(json.Number)
					if !ok {
						return fmt.Errorf("expected BoxedInteger to be json.Number, got %T instead", value)
					}
					i64, err := jtv.Int64()
					if err != nil { return err }
					sv.ContainerPort = ptr.Int32(int32(i64))
				}
			
			case "port":
				if value != nil {
					jtv, ok := value.(json.Number)
					if !ok {
						return fmt.Errorf("expected BoxedInteger to be json.Number, got %T instead", value)
					}
					i64, err := jtv.Int64()
					if err != nil { return err }
					sv.Port = ptr.Int32(int32(i64))
				}
			
			case "registryArn":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.RegistryArn = ptr.String(jtv)
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeDocumentServices(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.([]interface{})
	if !ok {
		return fmt.Errorf("unexpected JSON type %v", value)
	}
	
	var cv []types.Service
	if *v == nil {
		cv = []types.Service{}
		} else {
			cv = *v
		}
	
	for _, value := range shape {
		var col types.Service
		destAddr := &col
		if err := awsAwsjson11_deserializeDocumentService(&destAddr, value); err != nil {
			return err
		}
		col = *destAddr
		cv = append(cv, col)
		
	}
	*v = cv
	return nil
}

func awsAwsjson11_deserializeDocumentServiceVolumeConfiguration(v **types.ServiceVolumeConfiguration, 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.ServiceVolumeConfiguration
	if *v == nil {
		sv = &types.ServiceVolumeConfiguration{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "managedEBSVolume":
				if err := awsAwsjson11_deserializeDocumentServiceManagedEBSVolumeConfiguration(&sv.ManagedEBSVolume, value); err != nil {
					return err
				}
			
			case "name":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected ECSVolumeName to be of type string, got %T instead", value)
					}
					sv.Name = ptr.String(jtv)
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeDocumentServiceVolumeConfigurations(v *[]types.ServiceVolumeConfiguration, 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.ServiceVolumeConfiguration
	if *v == nil {
		cv = []types.ServiceVolumeConfiguration{}
		} else {
			cv = *v
		}
	
	for _, value := range shape {
		var col types.ServiceVolumeConfiguration
		destAddr := &col
		if err := awsAwsjson11_deserializeDocumentServiceVolumeConfiguration(&destAddr, value); err != nil {
			return err
		}
		col = *destAddr
		cv = append(cv, col)
		
	}
	*v = cv
	return nil
}

func awsAwsjson11_deserializeDocumentSession(v **types.Session, 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.Session
	if *v == nil {
		sv = &types.Session{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "sessionId":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.SessionId = ptr.String(jtv)
				}
			
			case "streamUrl":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.StreamUrl = ptr.String(jtv)
				}
			
			case "tokenValue":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected SensitiveString to be of type string, got %T instead", value)
					}
					sv.TokenValue = ptr.String(jtv)
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeDocumentSetting(v **types.Setting, 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.Setting
	if *v == nil {
		sv = &types.Setting{}
		} 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 SettingName to be of type string, got %T instead", value)
					}
					sv.Name = types.SettingName(jtv)
				}
			
			case "principalArn":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.PrincipalArn = ptr.String(jtv)
				}
			
			case "type":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected SettingType to be of type string, got %T instead", value)
					}
					sv.Type = types.SettingType(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 awsAwsjson11_deserializeDocumentSettings(v *[]types.Setting, 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.Setting
	if *v == nil {
		cv = []types.Setting{}
		} else {
			cv = *v
		}
	
	for _, value := range shape {
		var col types.Setting
		destAddr := &col
		if err := awsAwsjson11_deserializeDocumentSetting(&destAddr, value); err != nil {
			return err
		}
		col = *destAddr
		cv = append(cv, col)
		
	}
	*v = cv
	return nil
}

func awsAwsjson11_deserializeDocumentStatistics(v *[]types.KeyValuePair, 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.KeyValuePair
	if *v == nil {
		cv = []types.KeyValuePair{}
		} else {
			cv = *v
		}
	
	for _, value := range shape {
		var col types.KeyValuePair
		destAddr := &col
		if err := awsAwsjson11_deserializeDocumentKeyValuePair(&destAddr, value); err != nil {
			return err
		}
		col = *destAddr
		cv = append(cv, col)
		
	}
	*v = cv
	return nil
}

func awsAwsjson11_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 awsAwsjson11_deserializeDocumentStringMap(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 String to be of type string, got %T instead", value)
			}
			parsedVal = jtv
		}
		mv[key] = parsedVal
		
	}
	*v = mv
	return nil
}

func awsAwsjson11_deserializeDocumentSystemControl(v **types.SystemControl, 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.SystemControl
	if *v == nil {
		sv = &types.SystemControl{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "namespace":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.Namespace = 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 awsAwsjson11_deserializeDocumentSystemControls(v *[]types.SystemControl, 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.SystemControl
	if *v == nil {
		cv = []types.SystemControl{}
		} else {
			cv = *v
		}
	
	for _, value := range shape {
		var col types.SystemControl
		destAddr := &col
		if err := awsAwsjson11_deserializeDocumentSystemControl(&destAddr, value); err != nil {
			return err
		}
		col = *destAddr
		cv = append(cv, col)
		
	}
	*v = cv
	return nil
}

func awsAwsjson11_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 awsAwsjson11_deserializeDocumentTags(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 := awsAwsjson11_deserializeDocumentTag(&destAddr, value); err != nil {
			return err
		}
		col = *destAddr
		cv = append(cv, col)
		
	}
	*v = cv
	return nil
}

func awsAwsjson11_deserializeDocumentTargetNotConnectedException(v **types.TargetNotConnectedException, 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.TargetNotConnectedException
	if *v == nil {
		sv = &types.TargetNotConnectedException{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "message":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.Message = ptr.String(jtv)
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeDocumentTargetNotFoundException(v **types.TargetNotFoundException, 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.TargetNotFoundException
	if *v == nil {
		sv = &types.TargetNotFoundException{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "message":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.Message = ptr.String(jtv)
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeDocumentTask(v **types.Task, 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.Task
	if *v == nil {
		sv = &types.Task{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "attachments":
				if err := awsAwsjson11_deserializeDocumentAttachments(&sv.Attachments, value); err != nil {
					return err
				}
			
			case "attributes":
				if err := awsAwsjson11_deserializeDocumentAttributes(&sv.Attributes, value); err != nil {
					return err
				}
			
			case "availabilityZone":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.AvailabilityZone = ptr.String(jtv)
				}
			
			case "capacityProviderName":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.CapacityProviderName = ptr.String(jtv)
				}
			
			case "clusterArn":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.ClusterArn = ptr.String(jtv)
				}
			
			case "connectivity":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected Connectivity to be of type string, got %T instead", value)
					}
					sv.Connectivity = types.Connectivity(jtv)
				}
			
			case "connectivityAt":
				if value != nil {
					switch jtv := value.(type) {
						case json.Number:
							f64, err := jtv.Float64()
							if err != nil { return err }
							sv.ConnectivityAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
						
						default:
							return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value)
						
					}
				}
			
			case "containerInstanceArn":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.ContainerInstanceArn = ptr.String(jtv)
				}
			
			case "containers":
				if err := awsAwsjson11_deserializeDocumentContainers(&sv.Containers, value); err != nil {
					return err
				}
			
			case "cpu":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.Cpu = 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 "desiredStatus":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.DesiredStatus = ptr.String(jtv)
				}
			
			case "enableExecuteCommand":
				if value != nil {
					jtv, ok := value.(bool)
					if !ok {
						return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value)
					}
					sv.EnableExecuteCommand = jtv
				}
			
			case "ephemeralStorage":
				if err := awsAwsjson11_deserializeDocumentEphemeralStorage(&sv.EphemeralStorage, value); err != nil {
					return err
				}
			
			case "executionStoppedAt":
				if value != nil {
					switch jtv := value.(type) {
						case json.Number:
							f64, err := jtv.Float64()
							if err != nil { return err }
							sv.ExecutionStoppedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
						
						default:
							return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value)
						
					}
				}
			
			case "fargateEphemeralStorage":
				if err := awsAwsjson11_deserializeDocumentTaskEphemeralStorage(&sv.FargateEphemeralStorage, value); err != nil {
					return err
				}
			
			case "group":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.Group = ptr.String(jtv)
				}
			
			case "healthStatus":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected HealthStatus to be of type string, got %T instead", value)
					}
					sv.HealthStatus = types.HealthStatus(jtv)
				}
			
			case "inferenceAccelerators":
				if err := awsAwsjson11_deserializeDocumentInferenceAccelerators(&sv.InferenceAccelerators, value); err != nil {
					return err
				}
			
			case "lastStatus":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.LastStatus = ptr.String(jtv)
				}
			
			case "launchType":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected LaunchType to be of type string, got %T instead", value)
					}
					sv.LaunchType = types.LaunchType(jtv)
				}
			
			case "memory":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.Memory = ptr.String(jtv)
				}
			
			case "overrides":
				if err := awsAwsjson11_deserializeDocumentTaskOverride(&sv.Overrides, value); err != nil {
					return err
				}
			
			case "platformFamily":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.PlatformFamily = ptr.String(jtv)
				}
			
			case "platformVersion":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.PlatformVersion = ptr.String(jtv)
				}
			
			case "pullStartedAt":
				if value != nil {
					switch jtv := value.(type) {
						case json.Number:
							f64, err := jtv.Float64()
							if err != nil { return err }
							sv.PullStartedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
						
						default:
							return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value)
						
					}
				}
			
			case "pullStoppedAt":
				if value != nil {
					switch jtv := value.(type) {
						case json.Number:
							f64, err := jtv.Float64()
							if err != nil { return err }
							sv.PullStoppedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
						
						default:
							return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value)
						
					}
				}
			
			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 "startedBy":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.StartedBy = ptr.String(jtv)
				}
			
			case "stopCode":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected TaskStopCode to be of type string, got %T instead", value)
					}
					sv.StopCode = types.TaskStopCode(jtv)
				}
			
			case "stoppedAt":
				if value != nil {
					switch jtv := value.(type) {
						case json.Number:
							f64, err := jtv.Float64()
							if err != nil { return err }
							sv.StoppedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
						
						default:
							return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value)
						
					}
				}
			
			case "stoppedReason":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.StoppedReason = ptr.String(jtv)
				}
			
			case "stoppingAt":
				if value != nil {
					switch jtv := value.(type) {
						case json.Number:
							f64, err := jtv.Float64()
							if err != nil { return err }
							sv.StoppingAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
						
						default:
							return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value)
						
					}
				}
			
			case "tags":
				if err := awsAwsjson11_deserializeDocumentTags(&sv.Tags, value); err != nil {
					return err
				}
			
			case "taskArn":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.TaskArn = ptr.String(jtv)
				}
			
			case "taskDefinitionArn":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.TaskDefinitionArn = ptr.String(jtv)
				}
			
			case "version":
				if value != nil {
					jtv, ok := value.(json.Number)
					if !ok {
						return fmt.Errorf("expected Long to be json.Number, got %T instead", value)
					}
					i64, err := jtv.Int64()
					if err != nil { return err }
					sv.Version = i64
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeDocumentTaskDefinition(v **types.TaskDefinition, 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.TaskDefinition
	if *v == nil {
		sv = &types.TaskDefinition{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "compatibilities":
				if err := awsAwsjson11_deserializeDocumentCompatibilityList(&sv.Compatibilities, value); err != nil {
					return err
				}
			
			case "containerDefinitions":
				if err := awsAwsjson11_deserializeDocumentContainerDefinitions(&sv.ContainerDefinitions, value); err != nil {
					return err
				}
			
			case "cpu":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.Cpu = ptr.String(jtv)
				}
			
			case "deregisteredAt":
				if value != nil {
					switch jtv := value.(type) {
						case json.Number:
							f64, err := jtv.Float64()
							if err != nil { return err }
							sv.DeregisteredAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
						
						default:
							return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value)
						
					}
				}
			
			case "ephemeralStorage":
				if err := awsAwsjson11_deserializeDocumentEphemeralStorage(&sv.EphemeralStorage, value); err != nil {
					return err
				}
			
			case "executionRoleArn":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.ExecutionRoleArn = ptr.String(jtv)
				}
			
			case "family":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.Family = ptr.String(jtv)
				}
			
			case "inferenceAccelerators":
				if err := awsAwsjson11_deserializeDocumentInferenceAccelerators(&sv.InferenceAccelerators, value); err != nil {
					return err
				}
			
			case "ipcMode":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected IpcMode to be of type string, got %T instead", value)
					}
					sv.IpcMode = types.IpcMode(jtv)
				}
			
			case "memory":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.Memory = ptr.String(jtv)
				}
			
			case "networkMode":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected NetworkMode to be of type string, got %T instead", value)
					}
					sv.NetworkMode = types.NetworkMode(jtv)
				}
			
			case "pidMode":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected PidMode to be of type string, got %T instead", value)
					}
					sv.PidMode = types.PidMode(jtv)
				}
			
			case "placementConstraints":
				if err := awsAwsjson11_deserializeDocumentTaskDefinitionPlacementConstraints(&sv.PlacementConstraints, value); err != nil {
					return err
				}
			
			case "proxyConfiguration":
				if err := awsAwsjson11_deserializeDocumentProxyConfiguration(&sv.ProxyConfiguration, value); err != nil {
					return err
				}
			
			case "registeredAt":
				if value != nil {
					switch jtv := value.(type) {
						case json.Number:
							f64, err := jtv.Float64()
							if err != nil { return err }
							sv.RegisteredAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
						
						default:
							return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value)
						
					}
				}
			
			case "registeredBy":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.RegisteredBy = ptr.String(jtv)
				}
			
			case "requiresAttributes":
				if err := awsAwsjson11_deserializeDocumentRequiresAttributes(&sv.RequiresAttributes, value); err != nil {
					return err
				}
			
			case "requiresCompatibilities":
				if err := awsAwsjson11_deserializeDocumentCompatibilityList(&sv.RequiresCompatibilities, value); err != nil {
					return err
				}
			
			case "revision":
				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.Revision = int32(i64)
				}
			
			case "runtimePlatform":
				if err := awsAwsjson11_deserializeDocumentRuntimePlatform(&sv.RuntimePlatform, value); err != nil {
					return err
				}
			
			case "status":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected TaskDefinitionStatus to be of type string, got %T instead", value)
					}
					sv.Status = types.TaskDefinitionStatus(jtv)
				}
			
			case "taskDefinitionArn":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.TaskDefinitionArn = ptr.String(jtv)
				}
			
			case "taskRoleArn":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.TaskRoleArn = ptr.String(jtv)
				}
			
			case "volumes":
				if err := awsAwsjson11_deserializeDocumentVolumeList(&sv.Volumes, value); err != nil {
					return err
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeDocumentTaskDefinitionList(v *[]types.TaskDefinition, 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.TaskDefinition
	if *v == nil {
		cv = []types.TaskDefinition{}
		} else {
			cv = *v
		}
	
	for _, value := range shape {
		var col types.TaskDefinition
		destAddr := &col
		if err := awsAwsjson11_deserializeDocumentTaskDefinition(&destAddr, value); err != nil {
			return err
		}
		col = *destAddr
		cv = append(cv, col)
		
	}
	*v = cv
	return nil
}

func awsAwsjson11_deserializeDocumentTaskDefinitionPlacementConstraint(v **types.TaskDefinitionPlacementConstraint, 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.TaskDefinitionPlacementConstraint
	if *v == nil {
		sv = &types.TaskDefinitionPlacementConstraint{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "expression":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.Expression = ptr.String(jtv)
				}
			
			case "type":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected TaskDefinitionPlacementConstraintType to be of type string, got %T instead", value)
					}
					sv.Type = types.TaskDefinitionPlacementConstraintType(jtv)
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeDocumentTaskDefinitionPlacementConstraints(v *[]types.TaskDefinitionPlacementConstraint, 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.TaskDefinitionPlacementConstraint
	if *v == nil {
		cv = []types.TaskDefinitionPlacementConstraint{}
		} else {
			cv = *v
		}
	
	for _, value := range shape {
		var col types.TaskDefinitionPlacementConstraint
		destAddr := &col
		if err := awsAwsjson11_deserializeDocumentTaskDefinitionPlacementConstraint(&destAddr, value); err != nil {
			return err
		}
		col = *destAddr
		cv = append(cv, col)
		
	}
	*v = cv
	return nil
}

func awsAwsjson11_deserializeDocumentTaskEphemeralStorage(v **types.TaskEphemeralStorage, 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.TaskEphemeralStorage
	if *v == nil {
		sv = &types.TaskEphemeralStorage{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "kmsKeyId":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.KmsKeyId = ptr.String(jtv)
				}
			
			case "sizeInGiB":
				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.SizeInGiB = int32(i64)
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeDocumentTaskOverride(v **types.TaskOverride, 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.TaskOverride
	if *v == nil {
		sv = &types.TaskOverride{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "containerOverrides":
				if err := awsAwsjson11_deserializeDocumentContainerOverrides(&sv.ContainerOverrides, value); err != nil {
					return err
				}
			
			case "cpu":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.Cpu = ptr.String(jtv)
				}
			
			case "ephemeralStorage":
				if err := awsAwsjson11_deserializeDocumentEphemeralStorage(&sv.EphemeralStorage, value); err != nil {
					return err
				}
			
			case "executionRoleArn":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.ExecutionRoleArn = ptr.String(jtv)
				}
			
			case "inferenceAcceleratorOverrides":
				if err := awsAwsjson11_deserializeDocumentInferenceAcceleratorOverrides(&sv.InferenceAcceleratorOverrides, value); err != nil {
					return err
				}
			
			case "memory":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.Memory = ptr.String(jtv)
				}
			
			case "taskRoleArn":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.TaskRoleArn = ptr.String(jtv)
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeDocumentTasks(v *[]types.Task, 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.Task
	if *v == nil {
		cv = []types.Task{}
		} else {
			cv = *v
		}
	
	for _, value := range shape {
		var col types.Task
		destAddr := &col
		if err := awsAwsjson11_deserializeDocumentTask(&destAddr, value); err != nil {
			return err
		}
		col = *destAddr
		cv = append(cv, col)
		
	}
	*v = cv
	return nil
}

func awsAwsjson11_deserializeDocumentTaskSet(v **types.TaskSet, 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.TaskSet
	if *v == nil {
		sv = &types.TaskSet{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "capacityProviderStrategy":
				if err := awsAwsjson11_deserializeDocumentCapacityProviderStrategy(&sv.CapacityProviderStrategy, value); err != nil {
					return err
				}
			
			case "clusterArn":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.ClusterArn = ptr.String(jtv)
				}
			
			case "computedDesiredCount":
				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.ComputedDesiredCount = 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 "externalId":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.ExternalId = ptr.String(jtv)
				}
			
			case "fargateEphemeralStorage":
				if err := awsAwsjson11_deserializeDocumentDeploymentEphemeralStorage(&sv.FargateEphemeralStorage, value); err != nil {
					return err
				}
			
			case "id":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.Id = ptr.String(jtv)
				}
			
			case "launchType":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected LaunchType to be of type string, got %T instead", value)
					}
					sv.LaunchType = types.LaunchType(jtv)
				}
			
			case "loadBalancers":
				if err := awsAwsjson11_deserializeDocumentLoadBalancers(&sv.LoadBalancers, value); err != nil {
					return err
				}
			
			case "networkConfiguration":
				if err := awsAwsjson11_deserializeDocumentNetworkConfiguration(&sv.NetworkConfiguration, value); err != nil {
					return err
				}
			
			case "pendingCount":
				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.PendingCount = int32(i64)
				}
			
			case "platformFamily":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.PlatformFamily = ptr.String(jtv)
				}
			
			case "platformVersion":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.PlatformVersion = ptr.String(jtv)
				}
			
			case "runningCount":
				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.RunningCount = int32(i64)
				}
			
			case "scale":
				if err := awsAwsjson11_deserializeDocumentScale(&sv.Scale, value); err != nil {
					return err
				}
			
			case "serviceArn":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.ServiceArn = ptr.String(jtv)
				}
			
			case "serviceRegistries":
				if err := awsAwsjson11_deserializeDocumentServiceRegistries(&sv.ServiceRegistries, value); err != nil {
					return err
				}
			
			case "stabilityStatus":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected StabilityStatus to be of type string, got %T instead", value)
					}
					sv.StabilityStatus = types.StabilityStatus(jtv)
				}
			
			case "stabilityStatusAt":
				if value != nil {
					switch jtv := value.(type) {
						case json.Number:
							f64, err := jtv.Float64()
							if err != nil { return err }
							sv.StabilityStatusAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
						
						default:
							return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value)
						
					}
				}
			
			case "startedBy":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.StartedBy = ptr.String(jtv)
				}
			
			case "status":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.Status = ptr.String(jtv)
				}
			
			case "tags":
				if err := awsAwsjson11_deserializeDocumentTags(&sv.Tags, value); err != nil {
					return err
				}
			
			case "taskDefinition":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.TaskDefinition = ptr.String(jtv)
				}
			
			case "taskSetArn":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.TaskSetArn = ptr.String(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 awsAwsjson11_deserializeDocumentTaskSetNotFoundException(v **types.TaskSetNotFoundException, 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.TaskSetNotFoundException
	if *v == nil {
		sv = &types.TaskSetNotFoundException{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "message":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.Message = ptr.String(jtv)
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeDocumentTaskSets(v *[]types.TaskSet, 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.TaskSet
	if *v == nil {
		cv = []types.TaskSet{}
		} else {
			cv = *v
		}
	
	for _, value := range shape {
		var col types.TaskSet
		destAddr := &col
		if err := awsAwsjson11_deserializeDocumentTaskSet(&destAddr, value); err != nil {
			return err
		}
		col = *destAddr
		cv = append(cv, col)
		
	}
	*v = cv
	return nil
}

func awsAwsjson11_deserializeDocumentTimeoutConfiguration(v **types.TimeoutConfiguration, 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.TimeoutConfiguration
	if *v == nil {
		sv = &types.TimeoutConfiguration{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "idleTimeoutSeconds":
				if value != nil {
					jtv, ok := value.(json.Number)
					if !ok {
						return fmt.Errorf("expected Duration to be json.Number, got %T instead", value)
					}
					i64, err := jtv.Int64()
					if err != nil { return err }
					sv.IdleTimeoutSeconds = ptr.Int32(int32(i64))
				}
			
			case "perRequestTimeoutSeconds":
				if value != nil {
					jtv, ok := value.(json.Number)
					if !ok {
						return fmt.Errorf("expected Duration to be json.Number, got %T instead", value)
					}
					i64, err := jtv.Int64()
					if err != nil { return err }
					sv.PerRequestTimeoutSeconds = ptr.Int32(int32(i64))
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeDocumentTmpfs(v **types.Tmpfs, 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.Tmpfs
	if *v == nil {
		sv = &types.Tmpfs{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "containerPath":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.ContainerPath = ptr.String(jtv)
				}
			
			case "mountOptions":
				if err := awsAwsjson11_deserializeDocumentStringList(&sv.MountOptions, value); err != nil {
					return err
				}
			
			case "size":
				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.Size = int32(i64)
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeDocumentTmpfsList(v *[]types.Tmpfs, 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.Tmpfs
	if *v == nil {
		cv = []types.Tmpfs{}
		} else {
			cv = *v
		}
	
	for _, value := range shape {
		var col types.Tmpfs
		destAddr := &col
		if err := awsAwsjson11_deserializeDocumentTmpfs(&destAddr, value); err != nil {
			return err
		}
		col = *destAddr
		cv = append(cv, col)
		
	}
	*v = cv
	return nil
}

func awsAwsjson11_deserializeDocumentUlimit(v **types.Ulimit, 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.Ulimit
	if *v == nil {
		sv = &types.Ulimit{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "hardLimit":
				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.HardLimit = int32(i64)
				}
			
			case "name":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected UlimitName to be of type string, got %T instead", value)
					}
					sv.Name = types.UlimitName(jtv)
				}
			
			case "softLimit":
				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.SoftLimit = int32(i64)
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeDocumentUlimitList(v *[]types.Ulimit, 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.Ulimit
	if *v == nil {
		cv = []types.Ulimit{}
		} else {
			cv = *v
		}
	
	for _, value := range shape {
		var col types.Ulimit
		destAddr := &col
		if err := awsAwsjson11_deserializeDocumentUlimit(&destAddr, value); err != nil {
			return err
		}
		col = *destAddr
		cv = append(cv, col)
		
	}
	*v = cv
	return nil
}

func awsAwsjson11_deserializeDocumentUnsupportedFeatureException(v **types.UnsupportedFeatureException, 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.UnsupportedFeatureException
	if *v == nil {
		sv = &types.UnsupportedFeatureException{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "message":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.Message = ptr.String(jtv)
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeDocumentUpdateInProgressException(v **types.UpdateInProgressException, 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.UpdateInProgressException
	if *v == nil {
		sv = &types.UpdateInProgressException{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "message":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.Message = ptr.String(jtv)
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeDocumentVersionInfo(v **types.VersionInfo, 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.VersionInfo
	if *v == nil {
		sv = &types.VersionInfo{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "agentHash":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.AgentHash = ptr.String(jtv)
				}
			
			case "agentVersion":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.AgentVersion = ptr.String(jtv)
				}
			
			case "dockerVersion":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.DockerVersion = ptr.String(jtv)
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeDocumentVolume(v **types.Volume, 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.Volume
	if *v == nil {
		sv = &types.Volume{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "configuredAtLaunch":
				if value != nil {
					jtv, ok := value.(bool)
					if !ok {
						return fmt.Errorf("expected BoxedBoolean to be of type *bool, got %T instead", value)
					}
					sv.ConfiguredAtLaunch = ptr.Bool(jtv)
				}
			
			case "dockerVolumeConfiguration":
				if err := awsAwsjson11_deserializeDocumentDockerVolumeConfiguration(&sv.DockerVolumeConfiguration, value); err != nil {
					return err
				}
			
			case "efsVolumeConfiguration":
				if err := awsAwsjson11_deserializeDocumentEFSVolumeConfiguration(&sv.EfsVolumeConfiguration, value); err != nil {
					return err
				}
			
			case "fsxWindowsFileServerVolumeConfiguration":
				if err := awsAwsjson11_deserializeDocumentFSxWindowsFileServerVolumeConfiguration(&sv.FsxWindowsFileServerVolumeConfiguration, value); err != nil {
					return err
				}
			
			case "host":
				if err := awsAwsjson11_deserializeDocumentHostVolumeProperties(&sv.Host, value); err != nil {
					return err
				}
			
			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)
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeDocumentVolumeFrom(v **types.VolumeFrom, 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.VolumeFrom
	if *v == nil {
		sv = &types.VolumeFrom{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "readOnly":
				if value != nil {
					jtv, ok := value.(bool)
					if !ok {
						return fmt.Errorf("expected BoxedBoolean to be of type *bool, got %T instead", value)
					}
					sv.ReadOnly = ptr.Bool(jtv)
				}
			
			case "sourceContainer":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.SourceContainer = ptr.String(jtv)
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeDocumentVolumeFromList(v *[]types.VolumeFrom, 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.VolumeFrom
	if *v == nil {
		cv = []types.VolumeFrom{}
		} else {
			cv = *v
		}
	
	for _, value := range shape {
		var col types.VolumeFrom
		destAddr := &col
		if err := awsAwsjson11_deserializeDocumentVolumeFrom(&destAddr, value); err != nil {
			return err
		}
		col = *destAddr
		cv = append(cv, col)
		
	}
	*v = cv
	return nil
}

func awsAwsjson11_deserializeDocumentVolumeList(v *[]types.Volume, 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.Volume
	if *v == nil {
		cv = []types.Volume{}
		} else {
			cv = *v
		}
	
	for _, value := range shape {
		var col types.Volume
		destAddr := &col
		if err := awsAwsjson11_deserializeDocumentVolume(&destAddr, value); err != nil {
			return err
		}
		col = *destAddr
		cv = append(cv, col)
		
	}
	*v = cv
	return nil
}

func awsAwsjson11_deserializeOpDocumentCreateCapacityProviderOutput(v **CreateCapacityProviderOutput, 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 *CreateCapacityProviderOutput
	if *v == nil {
		sv = &CreateCapacityProviderOutput{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "capacityProvider":
				if err := awsAwsjson11_deserializeDocumentCapacityProvider(&sv.CapacityProvider, value); err != nil {
					return err
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeOpDocumentCreateClusterOutput(v **CreateClusterOutput, 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 *CreateClusterOutput
	if *v == nil {
		sv = &CreateClusterOutput{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "cluster":
				if err := awsAwsjson11_deserializeDocumentCluster(&sv.Cluster, value); err != nil {
					return err
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_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 "service":
				if err := awsAwsjson11_deserializeDocumentService(&sv.Service, value); err != nil {
					return err
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeOpDocumentCreateTaskSetOutput(v **CreateTaskSetOutput, 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 *CreateTaskSetOutput
	if *v == nil {
		sv = &CreateTaskSetOutput{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "taskSet":
				if err := awsAwsjson11_deserializeDocumentTaskSet(&sv.TaskSet, value); err != nil {
					return err
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeOpDocumentDeleteAccountSettingOutput(v **DeleteAccountSettingOutput, 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 *DeleteAccountSettingOutput
	if *v == nil {
		sv = &DeleteAccountSettingOutput{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "setting":
				if err := awsAwsjson11_deserializeDocumentSetting(&sv.Setting, value); err != nil {
					return err
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeOpDocumentDeleteAttributesOutput(v **DeleteAttributesOutput, 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 *DeleteAttributesOutput
	if *v == nil {
		sv = &DeleteAttributesOutput{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "attributes":
				if err := awsAwsjson11_deserializeDocumentAttributes(&sv.Attributes, value); err != nil {
					return err
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeOpDocumentDeleteCapacityProviderOutput(v **DeleteCapacityProviderOutput, 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 *DeleteCapacityProviderOutput
	if *v == nil {
		sv = &DeleteCapacityProviderOutput{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "capacityProvider":
				if err := awsAwsjson11_deserializeDocumentCapacityProvider(&sv.CapacityProvider, value); err != nil {
					return err
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeOpDocumentDeleteClusterOutput(v **DeleteClusterOutput, 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 *DeleteClusterOutput
	if *v == nil {
		sv = &DeleteClusterOutput{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "cluster":
				if err := awsAwsjson11_deserializeDocumentCluster(&sv.Cluster, value); err != nil {
					return err
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_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 "service":
				if err := awsAwsjson11_deserializeDocumentService(&sv.Service, value); err != nil {
					return err
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeOpDocumentDeleteTaskDefinitionsOutput(v **DeleteTaskDefinitionsOutput, 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 *DeleteTaskDefinitionsOutput
	if *v == nil {
		sv = &DeleteTaskDefinitionsOutput{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "failures":
				if err := awsAwsjson11_deserializeDocumentFailures(&sv.Failures, value); err != nil {
					return err
				}
			
			case "taskDefinitions":
				if err := awsAwsjson11_deserializeDocumentTaskDefinitionList(&sv.TaskDefinitions, value); err != nil {
					return err
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeOpDocumentDeleteTaskSetOutput(v **DeleteTaskSetOutput, 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 *DeleteTaskSetOutput
	if *v == nil {
		sv = &DeleteTaskSetOutput{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "taskSet":
				if err := awsAwsjson11_deserializeDocumentTaskSet(&sv.TaskSet, value); err != nil {
					return err
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeOpDocumentDeregisterContainerInstanceOutput(v **DeregisterContainerInstanceOutput, 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 *DeregisterContainerInstanceOutput
	if *v == nil {
		sv = &DeregisterContainerInstanceOutput{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "containerInstance":
				if err := awsAwsjson11_deserializeDocumentContainerInstance(&sv.ContainerInstance, value); err != nil {
					return err
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeOpDocumentDeregisterTaskDefinitionOutput(v **DeregisterTaskDefinitionOutput, 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 *DeregisterTaskDefinitionOutput
	if *v == nil {
		sv = &DeregisterTaskDefinitionOutput{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "taskDefinition":
				if err := awsAwsjson11_deserializeDocumentTaskDefinition(&sv.TaskDefinition, value); err != nil {
					return err
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeOpDocumentDescribeCapacityProvidersOutput(v **DescribeCapacityProvidersOutput, 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 *DescribeCapacityProvidersOutput
	if *v == nil {
		sv = &DescribeCapacityProvidersOutput{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "capacityProviders":
				if err := awsAwsjson11_deserializeDocumentCapacityProviders(&sv.CapacityProviders, value); err != nil {
					return err
				}
			
			case "failures":
				if err := awsAwsjson11_deserializeDocumentFailures(&sv.Failures, value); err != nil {
					return err
				}
			
			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)
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeOpDocumentDescribeClustersOutput(v **DescribeClustersOutput, 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 *DescribeClustersOutput
	if *v == nil {
		sv = &DescribeClustersOutput{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "clusters":
				if err := awsAwsjson11_deserializeDocumentClusters(&sv.Clusters, value); err != nil {
					return err
				}
			
			case "failures":
				if err := awsAwsjson11_deserializeDocumentFailures(&sv.Failures, value); err != nil {
					return err
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeOpDocumentDescribeContainerInstancesOutput(v **DescribeContainerInstancesOutput, 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 *DescribeContainerInstancesOutput
	if *v == nil {
		sv = &DescribeContainerInstancesOutput{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "containerInstances":
				if err := awsAwsjson11_deserializeDocumentContainerInstances(&sv.ContainerInstances, value); err != nil {
					return err
				}
			
			case "failures":
				if err := awsAwsjson11_deserializeDocumentFailures(&sv.Failures, value); err != nil {
					return err
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeOpDocumentDescribeServicesOutput(v **DescribeServicesOutput, 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 *DescribeServicesOutput
	if *v == nil {
		sv = &DescribeServicesOutput{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "failures":
				if err := awsAwsjson11_deserializeDocumentFailures(&sv.Failures, value); err != nil {
					return err
				}
			
			case "services":
				if err := awsAwsjson11_deserializeDocumentServices(&sv.Services, value); err != nil {
					return err
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeOpDocumentDescribeTaskDefinitionOutput(v **DescribeTaskDefinitionOutput, 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 *DescribeTaskDefinitionOutput
	if *v == nil {
		sv = &DescribeTaskDefinitionOutput{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "tags":
				if err := awsAwsjson11_deserializeDocumentTags(&sv.Tags, value); err != nil {
					return err
				}
			
			case "taskDefinition":
				if err := awsAwsjson11_deserializeDocumentTaskDefinition(&sv.TaskDefinition, value); err != nil {
					return err
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeOpDocumentDescribeTaskSetsOutput(v **DescribeTaskSetsOutput, 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 *DescribeTaskSetsOutput
	if *v == nil {
		sv = &DescribeTaskSetsOutput{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "failures":
				if err := awsAwsjson11_deserializeDocumentFailures(&sv.Failures, value); err != nil {
					return err
				}
			
			case "taskSets":
				if err := awsAwsjson11_deserializeDocumentTaskSets(&sv.TaskSets, value); err != nil {
					return err
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeOpDocumentDescribeTasksOutput(v **DescribeTasksOutput, 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 *DescribeTasksOutput
	if *v == nil {
		sv = &DescribeTasksOutput{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "failures":
				if err := awsAwsjson11_deserializeDocumentFailures(&sv.Failures, value); err != nil {
					return err
				}
			
			case "tasks":
				if err := awsAwsjson11_deserializeDocumentTasks(&sv.Tasks, value); err != nil {
					return err
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeOpDocumentDiscoverPollEndpointOutput(v **DiscoverPollEndpointOutput, 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 *DiscoverPollEndpointOutput
	if *v == nil {
		sv = &DiscoverPollEndpointOutput{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "endpoint":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.Endpoint = ptr.String(jtv)
				}
			
			case "serviceConnectEndpoint":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.ServiceConnectEndpoint = ptr.String(jtv)
				}
			
			case "systemLogsEndpoint":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.SystemLogsEndpoint = ptr.String(jtv)
				}
			
			case "telemetryEndpoint":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.TelemetryEndpoint = ptr.String(jtv)
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeOpDocumentExecuteCommandOutput(v **ExecuteCommandOutput, 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 *ExecuteCommandOutput
	if *v == nil {
		sv = &ExecuteCommandOutput{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "clusterArn":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.ClusterArn = ptr.String(jtv)
				}
			
			case "containerArn":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.ContainerArn = ptr.String(jtv)
				}
			
			case "containerName":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.ContainerName = ptr.String(jtv)
				}
			
			case "interactive":
				if value != nil {
					jtv, ok := value.(bool)
					if !ok {
						return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value)
					}
					sv.Interactive = jtv
				}
			
			case "session":
				if err := awsAwsjson11_deserializeDocumentSession(&sv.Session, value); err != nil {
					return err
				}
			
			case "taskArn":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.TaskArn = ptr.String(jtv)
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeOpDocumentGetTaskProtectionOutput(v **GetTaskProtectionOutput, 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 *GetTaskProtectionOutput
	if *v == nil {
		sv = &GetTaskProtectionOutput{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "failures":
				if err := awsAwsjson11_deserializeDocumentFailures(&sv.Failures, value); err != nil {
					return err
				}
			
			case "protectedTasks":
				if err := awsAwsjson11_deserializeDocumentProtectedTasks(&sv.ProtectedTasks, value); err != nil {
					return err
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeOpDocumentListAccountSettingsOutput(v **ListAccountSettingsOutput, 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 *ListAccountSettingsOutput
	if *v == nil {
		sv = &ListAccountSettingsOutput{}
		} 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 "settings":
				if err := awsAwsjson11_deserializeDocumentSettings(&sv.Settings, value); err != nil {
					return err
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeOpDocumentListAttributesOutput(v **ListAttributesOutput, 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 *ListAttributesOutput
	if *v == nil {
		sv = &ListAttributesOutput{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "attributes":
				if err := awsAwsjson11_deserializeDocumentAttributes(&sv.Attributes, value); err != nil {
					return err
				}
			
			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)
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeOpDocumentListClustersOutput(v **ListClustersOutput, 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 *ListClustersOutput
	if *v == nil {
		sv = &ListClustersOutput{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "clusterArns":
				if err := awsAwsjson11_deserializeDocumentStringList(&sv.ClusterArns, value); err != nil {
					return err
				}
			
			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)
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeOpDocumentListContainerInstancesOutput(v **ListContainerInstancesOutput, 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 *ListContainerInstancesOutput
	if *v == nil {
		sv = &ListContainerInstancesOutput{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "containerInstanceArns":
				if err := awsAwsjson11_deserializeDocumentStringList(&sv.ContainerInstanceArns, value); err != nil {
					return err
				}
			
			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)
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeOpDocumentListServicesByNamespaceOutput(v **ListServicesByNamespaceOutput, 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 *ListServicesByNamespaceOutput
	if *v == nil {
		sv = &ListServicesByNamespaceOutput{}
		} 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 "serviceArns":
				if err := awsAwsjson11_deserializeDocumentStringList(&sv.ServiceArns, value); err != nil {
					return err
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_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 "serviceArns":
				if err := awsAwsjson11_deserializeDocumentStringList(&sv.ServiceArns, value); err != nil {
					return err
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_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 := awsAwsjson11_deserializeDocumentTags(&sv.Tags, value); err != nil {
					return err
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeOpDocumentListTaskDefinitionFamiliesOutput(v **ListTaskDefinitionFamiliesOutput, 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 *ListTaskDefinitionFamiliesOutput
	if *v == nil {
		sv = &ListTaskDefinitionFamiliesOutput{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "families":
				if err := awsAwsjson11_deserializeDocumentStringList(&sv.Families, value); err != nil {
					return err
				}
			
			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)
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeOpDocumentListTaskDefinitionsOutput(v **ListTaskDefinitionsOutput, 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 *ListTaskDefinitionsOutput
	if *v == nil {
		sv = &ListTaskDefinitionsOutput{}
		} 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 "taskDefinitionArns":
				if err := awsAwsjson11_deserializeDocumentStringList(&sv.TaskDefinitionArns, value); err != nil {
					return err
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeOpDocumentListTasksOutput(v **ListTasksOutput, 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 *ListTasksOutput
	if *v == nil {
		sv = &ListTasksOutput{}
		} 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 "taskArns":
				if err := awsAwsjson11_deserializeDocumentStringList(&sv.TaskArns, value); err != nil {
					return err
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeOpDocumentPutAccountSettingDefaultOutput(v **PutAccountSettingDefaultOutput, 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 *PutAccountSettingDefaultOutput
	if *v == nil {
		sv = &PutAccountSettingDefaultOutput{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "setting":
				if err := awsAwsjson11_deserializeDocumentSetting(&sv.Setting, value); err != nil {
					return err
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeOpDocumentPutAccountSettingOutput(v **PutAccountSettingOutput, 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 *PutAccountSettingOutput
	if *v == nil {
		sv = &PutAccountSettingOutput{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "setting":
				if err := awsAwsjson11_deserializeDocumentSetting(&sv.Setting, value); err != nil {
					return err
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeOpDocumentPutAttributesOutput(v **PutAttributesOutput, 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 *PutAttributesOutput
	if *v == nil {
		sv = &PutAttributesOutput{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "attributes":
				if err := awsAwsjson11_deserializeDocumentAttributes(&sv.Attributes, value); err != nil {
					return err
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeOpDocumentPutClusterCapacityProvidersOutput(v **PutClusterCapacityProvidersOutput, 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 *PutClusterCapacityProvidersOutput
	if *v == nil {
		sv = &PutClusterCapacityProvidersOutput{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "cluster":
				if err := awsAwsjson11_deserializeDocumentCluster(&sv.Cluster, value); err != nil {
					return err
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeOpDocumentRegisterContainerInstanceOutput(v **RegisterContainerInstanceOutput, 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 *RegisterContainerInstanceOutput
	if *v == nil {
		sv = &RegisterContainerInstanceOutput{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "containerInstance":
				if err := awsAwsjson11_deserializeDocumentContainerInstance(&sv.ContainerInstance, value); err != nil {
					return err
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeOpDocumentRegisterTaskDefinitionOutput(v **RegisterTaskDefinitionOutput, 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 *RegisterTaskDefinitionOutput
	if *v == nil {
		sv = &RegisterTaskDefinitionOutput{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "tags":
				if err := awsAwsjson11_deserializeDocumentTags(&sv.Tags, value); err != nil {
					return err
				}
			
			case "taskDefinition":
				if err := awsAwsjson11_deserializeDocumentTaskDefinition(&sv.TaskDefinition, value); err != nil {
					return err
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeOpDocumentRunTaskOutput(v **RunTaskOutput, 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 *RunTaskOutput
	if *v == nil {
		sv = &RunTaskOutput{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "failures":
				if err := awsAwsjson11_deserializeDocumentFailures(&sv.Failures, value); err != nil {
					return err
				}
			
			case "tasks":
				if err := awsAwsjson11_deserializeDocumentTasks(&sv.Tasks, value); err != nil {
					return err
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeOpDocumentStartTaskOutput(v **StartTaskOutput, 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 *StartTaskOutput
	if *v == nil {
		sv = &StartTaskOutput{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "failures":
				if err := awsAwsjson11_deserializeDocumentFailures(&sv.Failures, value); err != nil {
					return err
				}
			
			case "tasks":
				if err := awsAwsjson11_deserializeDocumentTasks(&sv.Tasks, value); err != nil {
					return err
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeOpDocumentStopTaskOutput(v **StopTaskOutput, 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 *StopTaskOutput
	if *v == nil {
		sv = &StopTaskOutput{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "task":
				if err := awsAwsjson11_deserializeDocumentTask(&sv.Task, value); err != nil {
					return err
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeOpDocumentSubmitAttachmentStateChangesOutput(v **SubmitAttachmentStateChangesOutput, 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 *SubmitAttachmentStateChangesOutput
	if *v == nil {
		sv = &SubmitAttachmentStateChangesOutput{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "acknowledgment":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.Acknowledgment = ptr.String(jtv)
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeOpDocumentSubmitContainerStateChangeOutput(v **SubmitContainerStateChangeOutput, 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 *SubmitContainerStateChangeOutput
	if *v == nil {
		sv = &SubmitContainerStateChangeOutput{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "acknowledgment":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.Acknowledgment = ptr.String(jtv)
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeOpDocumentSubmitTaskStateChangeOutput(v **SubmitTaskStateChangeOutput, 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 *SubmitTaskStateChangeOutput
	if *v == nil {
		sv = &SubmitTaskStateChangeOutput{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "acknowledgment":
				if value != nil {
					jtv, ok := value.(string)
					if !ok {
						return fmt.Errorf("expected String to be of type string, got %T instead", value)
					}
					sv.Acknowledgment = ptr.String(jtv)
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_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 awsAwsjson11_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 awsAwsjson11_deserializeOpDocumentUpdateCapacityProviderOutput(v **UpdateCapacityProviderOutput, 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 *UpdateCapacityProviderOutput
	if *v == nil {
		sv = &UpdateCapacityProviderOutput{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "capacityProvider":
				if err := awsAwsjson11_deserializeDocumentCapacityProvider(&sv.CapacityProvider, value); err != nil {
					return err
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeOpDocumentUpdateClusterOutput(v **UpdateClusterOutput, 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 *UpdateClusterOutput
	if *v == nil {
		sv = &UpdateClusterOutput{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "cluster":
				if err := awsAwsjson11_deserializeDocumentCluster(&sv.Cluster, value); err != nil {
					return err
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeOpDocumentUpdateClusterSettingsOutput(v **UpdateClusterSettingsOutput, 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 *UpdateClusterSettingsOutput
	if *v == nil {
		sv = &UpdateClusterSettingsOutput{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "cluster":
				if err := awsAwsjson11_deserializeDocumentCluster(&sv.Cluster, value); err != nil {
					return err
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeOpDocumentUpdateContainerAgentOutput(v **UpdateContainerAgentOutput, 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 *UpdateContainerAgentOutput
	if *v == nil {
		sv = &UpdateContainerAgentOutput{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "containerInstance":
				if err := awsAwsjson11_deserializeDocumentContainerInstance(&sv.ContainerInstance, value); err != nil {
					return err
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeOpDocumentUpdateContainerInstancesStateOutput(v **UpdateContainerInstancesStateOutput, 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 *UpdateContainerInstancesStateOutput
	if *v == nil {
		sv = &UpdateContainerInstancesStateOutput{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "containerInstances":
				if err := awsAwsjson11_deserializeDocumentContainerInstances(&sv.ContainerInstances, value); err != nil {
					return err
				}
			
			case "failures":
				if err := awsAwsjson11_deserializeDocumentFailures(&sv.Failures, value); err != nil {
					return err
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_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 "service":
				if err := awsAwsjson11_deserializeDocumentService(&sv.Service, value); err != nil {
					return err
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeOpDocumentUpdateServicePrimaryTaskSetOutput(v **UpdateServicePrimaryTaskSetOutput, 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 *UpdateServicePrimaryTaskSetOutput
	if *v == nil {
		sv = &UpdateServicePrimaryTaskSetOutput{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "taskSet":
				if err := awsAwsjson11_deserializeDocumentTaskSet(&sv.TaskSet, value); err != nil {
					return err
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeOpDocumentUpdateTaskProtectionOutput(v **UpdateTaskProtectionOutput, 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 *UpdateTaskProtectionOutput
	if *v == nil {
		sv = &UpdateTaskProtectionOutput{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "failures":
				if err := awsAwsjson11_deserializeDocumentFailures(&sv.Failures, value); err != nil {
					return err
				}
			
			case "protectedTasks":
				if err := awsAwsjson11_deserializeDocumentProtectedTasks(&sv.ProtectedTasks, value); err != nil {
					return err
				}
			
			default:
				_, _ = key, value
			
		}
	}
	*v = sv
	return nil
}

func awsAwsjson11_deserializeOpDocumentUpdateTaskSetOutput(v **UpdateTaskSetOutput, 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 *UpdateTaskSetOutput
	if *v == nil {
		sv = &UpdateTaskSetOutput{}
		} else {
			sv = *v
		}
	
	for key, value := range shape {
		switch key {
			case "taskSet":
				if err := awsAwsjson11_deserializeDocumentTaskSet(&sv.TaskSet, 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
}
