From 1c455e29efcc1bf6681db35faf3455bc3171da81 Mon Sep 17 00:00:00 2001 From: AWS SDK for Go v2 automation user Date: Thu, 6 Apr 2023 18:14:01 +0000 Subject: [PATCH] Regenerated Clients --- .../3b04d0b7fcea41f09e31d573e492f977.json | 8 + .../64b97882dd4e4332bd86a4ef4a954397.json | 8 + .../94fa8965ad954d4f82f7c7c83d2c7037.json | 8 + .../c52e29cb0bc14958b66aa365b5b1e365.json | 8 + .../cloudformation/api_op_DescribeStacks.go | 24 + service/glue/internal/endpoints/endpoints.go | 6 + service/greengrassv2/types/enums.go | 2 + service/greengrassv2/types/types.go | 34 +- .../internal/endpoints/endpoints.go | 9 + .../internal/endpoints/endpoints.go | 9 + service/polly/internal/endpoints/endpoints.go | 3 + service/proton/api_op_CreateComponent.go | 40 + .../proton/api_op_CreateServiceInstance.go | 189 ++ .../proton/api_op_CreateServiceSyncConfig.go | 141 + .../proton/api_op_DeleteServiceSyncConfig.go | 122 + service/proton/api_op_GetResourcesSummary.go | 4 +- service/proton/api_op_GetServiceInstance.go | 2 +- .../api_op_GetServiceInstanceSyncStatus.go | 132 + .../api_op_GetServiceSyncBlockerSummary.go | 127 + service/proton/api_op_GetServiceSyncConfig.go | 121 + service/proton/api_op_UpdateComponent.go | 40 + .../proton/api_op_UpdateServiceInstance.go | 40 + .../proton/api_op_UpdateServiceSyncBlocker.go | 137 + .../proton/api_op_UpdateServiceSyncConfig.go | 141 + service/proton/deserializers.go | 2824 +++++++++++++---- service/proton/generated.json | 8 + service/proton/serializers.go | 724 ++++- service/proton/types/enums.go | 38 + service/proton/types/types.go | 134 +- service/proton/validators.go | 353 +++ service/rds/api_op_CreateDBInstance.go | 29 +- .../rds/api_op_CreateDBInstanceReadReplica.go | 30 +- service/rds/api_op_CreateGlobalCluster.go | 3 +- .../rds/api_op_DeleteCustomDBEngineVersion.go | 3 +- service/rds/api_op_DescribeDBClusters.go | 15 +- .../rds/api_op_ModifyCustomDBEngineVersion.go | 3 +- service/rds/api_op_ModifyDBCluster.go | 13 +- .../sagemaker/internal/endpoints/endpoints.go | 3 + 38 files changed, 4876 insertions(+), 659 deletions(-) create mode 100644 .changelog/3b04d0b7fcea41f09e31d573e492f977.json create mode 100644 .changelog/64b97882dd4e4332bd86a4ef4a954397.json create mode 100644 .changelog/94fa8965ad954d4f82f7c7c83d2c7037.json create mode 100644 .changelog/c52e29cb0bc14958b66aa365b5b1e365.json create mode 100644 service/proton/api_op_CreateServiceInstance.go create mode 100644 service/proton/api_op_CreateServiceSyncConfig.go create mode 100644 service/proton/api_op_DeleteServiceSyncConfig.go create mode 100644 service/proton/api_op_GetServiceInstanceSyncStatus.go create mode 100644 service/proton/api_op_GetServiceSyncBlockerSummary.go create mode 100644 service/proton/api_op_GetServiceSyncConfig.go create mode 100644 service/proton/api_op_UpdateServiceSyncBlocker.go create mode 100644 service/proton/api_op_UpdateServiceSyncConfig.go diff --git a/.changelog/3b04d0b7fcea41f09e31d573e492f977.json b/.changelog/3b04d0b7fcea41f09e31d573e492f977.json new file mode 100644 index 00000000000..9875c449b91 --- /dev/null +++ b/.changelog/3b04d0b7fcea41f09e31d573e492f977.json @@ -0,0 +1,8 @@ +{ + "id": "3b04d0b7-fcea-41f0-9e31-d573e492f977", + "type": "feature", + "description": "This release adds support for the AWS Proton service sync feature. Service sync enables managing an AWS Proton service (creating and updating instances) and all of it's corresponding service instances from a Git repository.", + "modules": [ + "service/proton" + ] +} \ No newline at end of file diff --git a/.changelog/64b97882dd4e4332bd86a4ef4a954397.json b/.changelog/64b97882dd4e4332bd86a4ef4a954397.json new file mode 100644 index 00000000000..9bbfbc2ff0a --- /dev/null +++ b/.changelog/64b97882dd4e4332bd86a4ef4a954397.json @@ -0,0 +1,8 @@ +{ + "id": "64b97882-dd4e-4332-bd86-a4ef4a954397", + "type": "feature", + "description": "Including UPDATE_COMPLETE as a failed status for DeleteStack waiter.", + "modules": [ + "service/cloudformation" + ] +} \ No newline at end of file diff --git a/.changelog/94fa8965ad954d4f82f7c7c83d2c7037.json b/.changelog/94fa8965ad954d4f82f7c7c83d2c7037.json new file mode 100644 index 00000000000..f0e98b4ca62 --- /dev/null +++ b/.changelog/94fa8965ad954d4f82f7c7c83d2c7037.json @@ -0,0 +1,8 @@ +{ + "id": "94fa8965-ad95-4d4f-82f7-c7c83d2c7037", + "type": "documentation", + "description": "Adds and updates the SDK examples", + "modules": [ + "service/rds" + ] +} \ No newline at end of file diff --git a/.changelog/c52e29cb0bc14958b66aa365b5b1e365.json b/.changelog/c52e29cb0bc14958b66aa365b5b1e365.json new file mode 100644 index 00000000000..f8dce30d465 --- /dev/null +++ b/.changelog/c52e29cb0bc14958b66aa365b5b1e365.json @@ -0,0 +1,8 @@ +{ + "id": "c52e29cb-0bc1-4958-b66a-a365b5b1e365", + "type": "feature", + "description": "Add support for SUCCEEDED value in coreDeviceExecutionStatus field. Documentation updates for Greengrass V2.", + "modules": [ + "service/greengrassv2" + ] +} \ No newline at end of file diff --git a/service/cloudformation/api_op_DescribeStacks.go b/service/cloudformation/api_op_DescribeStacks.go index 5cbb38fb471..715bccdad8a 100644 --- a/service/cloudformation/api_op_DescribeStacks.go +++ b/service/cloudformation/api_op_DescribeStacks.go @@ -848,6 +848,30 @@ func stackDeleteCompleteStateRetryable(ctx context.Context, input *DescribeStack } } + if err == nil { + pathValue, err := jmespath.Search("Stacks[].StackStatus", output) + if err != nil { + return false, fmt.Errorf("error evaluating waiter state: %w", err) + } + + expectedValue := "UPDATE_COMPLETE" + listOfValues, ok := pathValue.([]interface{}) + if !ok { + return false, fmt.Errorf("waiter comparator expected list got %T", pathValue) + } + + for _, v := range listOfValues { + value, ok := v.(types.StackStatus) + if !ok { + return false, fmt.Errorf("waiter comparator expected types.StackStatus value, got %T", pathValue) + } + + if string(value) == expectedValue { + return false, fmt.Errorf("waiter state transitioned to Failure") + } + } + } + return true, nil } diff --git a/service/glue/internal/endpoints/endpoints.go b/service/glue/internal/endpoints/endpoints.go index 0e9af675083..0ca8c4e1273 100644 --- a/service/glue/internal/endpoints/endpoints.go +++ b/service/glue/internal/endpoints/endpoints.go @@ -168,12 +168,18 @@ var defaultPartitions = endpoints.Partitions{ endpoints.EndpointKey{ Region: "eu-central-1", }: endpoints.Endpoint{}, + endpoints.EndpointKey{ + Region: "eu-central-2", + }: endpoints.Endpoint{}, endpoints.EndpointKey{ Region: "eu-north-1", }: endpoints.Endpoint{}, endpoints.EndpointKey{ Region: "eu-south-1", }: endpoints.Endpoint{}, + endpoints.EndpointKey{ + Region: "eu-south-2", + }: endpoints.Endpoint{}, endpoints.EndpointKey{ Region: "eu-west-1", }: endpoints.Endpoint{}, diff --git a/service/greengrassv2/types/enums.go b/service/greengrassv2/types/enums.go index a86d1924ef0..cfae09409ca 100644 --- a/service/greengrassv2/types/enums.go +++ b/service/greengrassv2/types/enums.go @@ -171,6 +171,7 @@ const ( EffectiveDeploymentExecutionStatusTimedOut EffectiveDeploymentExecutionStatus = "TIMED_OUT" EffectiveDeploymentExecutionStatusCanceled EffectiveDeploymentExecutionStatus = "CANCELED" EffectiveDeploymentExecutionStatusRejected EffectiveDeploymentExecutionStatus = "REJECTED" + EffectiveDeploymentExecutionStatusSucceeded EffectiveDeploymentExecutionStatus = "SUCCEEDED" ) // Values returns all known values for EffectiveDeploymentExecutionStatus. Note @@ -186,6 +187,7 @@ func (EffectiveDeploymentExecutionStatus) Values() []EffectiveDeploymentExecutio "TIMED_OUT", "CANCELED", "REJECTED", + "SUCCEEDED", } } diff --git a/service/greengrassv2/types/types.go b/service/greengrassv2/types/types.go index fd16e1dff78..ce9ea77afc9 100644 --- a/service/greengrassv2/types/types.go +++ b/service/greengrassv2/types/types.go @@ -527,6 +527,30 @@ type EffectiveDeployment struct { // The status of the deployment job on the Greengrass core device. // + // * IN_PROGRESS – + // The deployment job is running. + // + // * QUEUED – The deployment job is in the job + // queue and waiting to run. + // + // * FAILED – The deployment failed. For more + // information, see the statusDetails field. + // + // * COMPLETED – The deployment to an + // IoT thing was completed successfully. + // + // * TIMED_OUT – The deployment didn't + // complete in the allotted time. + // + // * CANCELED – The deployment was canceled by the + // user. + // + // * REJECTED – The deployment was rejected. For more information, see the + // statusDetails field. + // + // * SUCCEEDED – The deployment to an IoT thing group was + // completed successfully. + // // This member is required. CoreDeviceExecutionStatus EffectiveDeploymentExecutionStatus @@ -614,12 +638,14 @@ type InstalledComponent struct { // The most recent deployment source that brought the component to the Greengrass // core device. For a thing group deployment or thing deployment, the source will - // be the The ID of the deployment. and for local deployments it will be LOCAL. + // be the The ID of the deployment. and for local deployments it will be LOCAL. Any + // deployment will attempt to reinstall currently broken components on the device, + // which will update the last installation source. LastInstallationSource *string - // The last time the Greengrass core device sent a message containing a certain - // component to the Amazon Web Services Cloud. A component does not need to see a - // state change for this field to update. + // The last time the Greengrass core device sent a message containing a component's + // state to the Amazon Web Services Cloud. A component does not need to see a state + // change for this field to update. LastReportedTimestamp *time.Time // The status of how current the data is. This response is based off of component diff --git a/service/kinesisanalytics/internal/endpoints/endpoints.go b/service/kinesisanalytics/internal/endpoints/endpoints.go index 6e7113bb96f..cdb23c92c88 100644 --- a/service/kinesisanalytics/internal/endpoints/endpoints.go +++ b/service/kinesisanalytics/internal/endpoints/endpoints.go @@ -153,6 +153,9 @@ var defaultPartitions = endpoints.Partitions{ endpoints.EndpointKey{ Region: "ap-south-1", }: endpoints.Endpoint{}, + endpoints.EndpointKey{ + Region: "ap-south-2", + }: endpoints.Endpoint{}, endpoints.EndpointKey{ Region: "ap-southeast-1", }: endpoints.Endpoint{}, @@ -168,12 +171,18 @@ var defaultPartitions = endpoints.Partitions{ endpoints.EndpointKey{ Region: "eu-central-1", }: endpoints.Endpoint{}, + endpoints.EndpointKey{ + Region: "eu-central-2", + }: endpoints.Endpoint{}, endpoints.EndpointKey{ Region: "eu-north-1", }: endpoints.Endpoint{}, endpoints.EndpointKey{ Region: "eu-south-1", }: endpoints.Endpoint{}, + endpoints.EndpointKey{ + Region: "eu-south-2", + }: endpoints.Endpoint{}, endpoints.EndpointKey{ Region: "eu-west-1", }: endpoints.Endpoint{}, diff --git a/service/kinesisanalyticsv2/internal/endpoints/endpoints.go b/service/kinesisanalyticsv2/internal/endpoints/endpoints.go index 4ffb6adcdc5..8db566b8d6c 100644 --- a/service/kinesisanalyticsv2/internal/endpoints/endpoints.go +++ b/service/kinesisanalyticsv2/internal/endpoints/endpoints.go @@ -153,6 +153,9 @@ var defaultPartitions = endpoints.Partitions{ endpoints.EndpointKey{ Region: "ap-south-1", }: endpoints.Endpoint{}, + endpoints.EndpointKey{ + Region: "ap-south-2", + }: endpoints.Endpoint{}, endpoints.EndpointKey{ Region: "ap-southeast-1", }: endpoints.Endpoint{}, @@ -168,12 +171,18 @@ var defaultPartitions = endpoints.Partitions{ endpoints.EndpointKey{ Region: "eu-central-1", }: endpoints.Endpoint{}, + endpoints.EndpointKey{ + Region: "eu-central-2", + }: endpoints.Endpoint{}, endpoints.EndpointKey{ Region: "eu-north-1", }: endpoints.Endpoint{}, endpoints.EndpointKey{ Region: "eu-south-1", }: endpoints.Endpoint{}, + endpoints.EndpointKey{ + Region: "eu-south-2", + }: endpoints.Endpoint{}, endpoints.EndpointKey{ Region: "eu-west-1", }: endpoints.Endpoint{}, diff --git a/service/polly/internal/endpoints/endpoints.go b/service/polly/internal/endpoints/endpoints.go index a1f3d94e876..ba46828fba7 100644 --- a/service/polly/internal/endpoints/endpoints.go +++ b/service/polly/internal/endpoints/endpoints.go @@ -147,6 +147,9 @@ var defaultPartitions = endpoints.Partitions{ endpoints.EndpointKey{ Region: "ap-northeast-2", }: endpoints.Endpoint{}, + endpoints.EndpointKey{ + Region: "ap-northeast-3", + }: endpoints.Endpoint{}, endpoints.EndpointKey{ Region: "ap-south-1", }: endpoints.Endpoint{}, diff --git a/service/proton/api_op_CreateComponent.go b/service/proton/api_op_CreateComponent.go index c7f3f22eac7..a2428e17e0a 100644 --- a/service/proton/api_op_CreateComponent.go +++ b/service/proton/api_op_CreateComponent.go @@ -4,6 +4,7 @@ package proton import ( "context" + "fmt" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" "github.com/aws/aws-sdk-go-v2/service/proton/types" @@ -55,6 +56,9 @@ type CreateComponentInput struct { // This member is required. TemplateFile *string + // The client token for the created component. + ClientToken *string + // An optional customer-provided description of the component. Description *string @@ -146,6 +150,9 @@ func (c *Client) addOperationCreateComponentMiddlewares(stack *middleware.Stack, if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addIdempotencyToken_opCreateComponentMiddleware(stack, options); err != nil { + return err + } if err = addOpCreateComponentValidationMiddleware(stack); err != nil { return err } @@ -164,6 +171,39 @@ func (c *Client) addOperationCreateComponentMiddlewares(stack *middleware.Stack, return nil } +type idempotencyToken_initializeOpCreateComponent struct { + tokenProvider IdempotencyTokenProvider +} + +func (*idempotencyToken_initializeOpCreateComponent) ID() string { + return "OperationIdempotencyTokenAutoFill" +} + +func (m *idempotencyToken_initializeOpCreateComponent) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + if m.tokenProvider == nil { + return next.HandleInitialize(ctx, in) + } + + input, ok := in.Parameters.(*CreateComponentInput) + if !ok { + return out, metadata, fmt.Errorf("expected middleware input to be of type *CreateComponentInput ") + } + + if input.ClientToken == nil { + t, err := m.tokenProvider.GetIdempotencyToken() + if err != nil { + return out, metadata, err + } + input.ClientToken = &t + } + return next.HandleInitialize(ctx, in) +} +func addIdempotencyToken_opCreateComponentMiddleware(stack *middleware.Stack, cfg Options) error { + return stack.Initialize.Add(&idempotencyToken_initializeOpCreateComponent{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before) +} + func newServiceMetadataMiddleware_opCreateComponent(region string) *awsmiddleware.RegisterServiceMetadata { return &awsmiddleware.RegisterServiceMetadata{ Region: region, diff --git a/service/proton/api_op_CreateServiceInstance.go b/service/proton/api_op_CreateServiceInstance.go new file mode 100644 index 00000000000..1bdcb1d9399 --- /dev/null +++ b/service/proton/api_op_CreateServiceInstance.go @@ -0,0 +1,189 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package proton + +import ( + "context" + "fmt" + awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" + "github.com/aws/aws-sdk-go-v2/aws/signer/v4" + "github.com/aws/aws-sdk-go-v2/service/proton/types" + "github.com/aws/smithy-go/middleware" + smithyhttp "github.com/aws/smithy-go/transport/http" +) + +// Create a service instance. +func (c *Client) CreateServiceInstance(ctx context.Context, params *CreateServiceInstanceInput, optFns ...func(*Options)) (*CreateServiceInstanceOutput, error) { + if params == nil { + params = &CreateServiceInstanceInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "CreateServiceInstance", params, optFns, c.addOperationCreateServiceInstanceMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*CreateServiceInstanceOutput) + out.ResultMetadata = metadata + return out, nil +} + +type CreateServiceInstanceInput struct { + + // The name of the service instance to create. + // + // This member is required. + Name *string + + // The name of the service the service instance is added to. + // + // This member is required. + ServiceName *string + + // The spec for the service instance you want to create. + // + // This value conforms to the media type: application/yaml + // + // This member is required. + Spec *string + + // The client token of the service instance to create. + ClientToken *string + + // An optional list of metadata items that you can associate with the Proton + // service instance. A tag is a key-value pair. For more information, see Proton + // resources and tagging + // (https://docs.aws.amazon.com/proton/latest/userguide/resources.html) in the + // Proton User Guide. + Tags []types.Tag + + // To create a new major and minor version of the service template, exclude major + // Version. + TemplateMajorVersion *string + + // To create a new minor version of the service template, include a major Version. + TemplateMinorVersion *string + + noSmithyDocumentSerde +} + +type CreateServiceInstanceOutput struct { + + // The detailed data of the service instance being created. + // + // This member is required. + ServiceInstance *types.ServiceInstance + + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (c *Client) addOperationCreateServiceInstanceMiddlewares(stack *middleware.Stack, options Options) (err error) { + err = stack.Serialize.Add(&awsAwsjson10_serializeOpCreateServiceInstance{}, middleware.After) + if err != nil { + return err + } + err = stack.Deserialize.Add(&awsAwsjson10_deserializeOpCreateServiceInstance{}, middleware.After) + if err != nil { + return err + } + if err = addSetLoggerMiddleware(stack, options); err != nil { + return err + } + if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil { + return err + } + if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil { + return err + } + if err = addResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil { + return err + } + if err = addRetryMiddlewares(stack, options); err != nil { + return err + } + if err = addHTTPSignerV4Middleware(stack, options); err != nil { + return err + } + if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil { + return err + } + if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil { + return err + } + if err = addClientUserAgent(stack); err != nil { + return err + } + if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil { + return err + } + if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { + return err + } + if err = addIdempotencyToken_opCreateServiceInstanceMiddleware(stack, options); err != nil { + return err + } + if err = addOpCreateServiceInstanceValidationMiddleware(stack); err != nil { + return err + } + if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateServiceInstance(options.Region), middleware.Before); err != nil { + return err + } + if err = addRequestIDRetrieverMiddleware(stack); err != nil { + return err + } + if err = addResponseErrorMiddleware(stack); err != nil { + return err + } + if err = addRequestResponseLogging(stack, options); err != nil { + return err + } + return nil +} + +type idempotencyToken_initializeOpCreateServiceInstance struct { + tokenProvider IdempotencyTokenProvider +} + +func (*idempotencyToken_initializeOpCreateServiceInstance) ID() string { + return "OperationIdempotencyTokenAutoFill" +} + +func (m *idempotencyToken_initializeOpCreateServiceInstance) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + if m.tokenProvider == nil { + return next.HandleInitialize(ctx, in) + } + + input, ok := in.Parameters.(*CreateServiceInstanceInput) + if !ok { + return out, metadata, fmt.Errorf("expected middleware input to be of type *CreateServiceInstanceInput ") + } + + if input.ClientToken == nil { + t, err := m.tokenProvider.GetIdempotencyToken() + if err != nil { + return out, metadata, err + } + input.ClientToken = &t + } + return next.HandleInitialize(ctx, in) +} +func addIdempotencyToken_opCreateServiceInstanceMiddleware(stack *middleware.Stack, cfg Options) error { + return stack.Initialize.Add(&idempotencyToken_initializeOpCreateServiceInstance{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before) +} + +func newServiceMetadataMiddleware_opCreateServiceInstance(region string) *awsmiddleware.RegisterServiceMetadata { + return &awsmiddleware.RegisterServiceMetadata{ + Region: region, + ServiceID: ServiceID, + SigningName: "proton", + OperationName: "CreateServiceInstance", + } +} diff --git a/service/proton/api_op_CreateServiceSyncConfig.go b/service/proton/api_op_CreateServiceSyncConfig.go new file mode 100644 index 00000000000..92a78c9352e --- /dev/null +++ b/service/proton/api_op_CreateServiceSyncConfig.go @@ -0,0 +1,141 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package proton + +import ( + "context" + awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" + "github.com/aws/aws-sdk-go-v2/aws/signer/v4" + "github.com/aws/aws-sdk-go-v2/service/proton/types" + "github.com/aws/smithy-go/middleware" + smithyhttp "github.com/aws/smithy-go/transport/http" +) + +// Create the Proton Ops configuration file. +func (c *Client) CreateServiceSyncConfig(ctx context.Context, params *CreateServiceSyncConfigInput, optFns ...func(*Options)) (*CreateServiceSyncConfigOutput, error) { + if params == nil { + params = &CreateServiceSyncConfigInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "CreateServiceSyncConfig", params, optFns, c.addOperationCreateServiceSyncConfigMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*CreateServiceSyncConfigOutput) + out.ResultMetadata = metadata + return out, nil +} + +type CreateServiceSyncConfigInput struct { + + // The repository branch for your Proton Ops file. + // + // This member is required. + Branch *string + + // The path to the Proton Ops file. + // + // This member is required. + FilePath *string + + // The repository name. + // + // This member is required. + RepositoryName *string + + // The provider type for your repository. + // + // This member is required. + RepositoryProvider types.RepositoryProvider + + // The name of the service the Proton Ops file is for. + // + // This member is required. + ServiceName *string + + noSmithyDocumentSerde +} + +type CreateServiceSyncConfigOutput struct { + + // The detailed data of the Proton Ops file. + ServiceSyncConfig *types.ServiceSyncConfig + + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (c *Client) addOperationCreateServiceSyncConfigMiddlewares(stack *middleware.Stack, options Options) (err error) { + err = stack.Serialize.Add(&awsAwsjson10_serializeOpCreateServiceSyncConfig{}, middleware.After) + if err != nil { + return err + } + err = stack.Deserialize.Add(&awsAwsjson10_deserializeOpCreateServiceSyncConfig{}, middleware.After) + if err != nil { + return err + } + if err = addSetLoggerMiddleware(stack, options); err != nil { + return err + } + if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil { + return err + } + if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil { + return err + } + if err = addResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil { + return err + } + if err = addRetryMiddlewares(stack, options); err != nil { + return err + } + if err = addHTTPSignerV4Middleware(stack, options); err != nil { + return err + } + if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil { + return err + } + if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil { + return err + } + if err = addClientUserAgent(stack); err != nil { + return err + } + if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil { + return err + } + if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { + return err + } + if err = addOpCreateServiceSyncConfigValidationMiddleware(stack); err != nil { + return err + } + if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateServiceSyncConfig(options.Region), middleware.Before); err != nil { + return err + } + if err = addRequestIDRetrieverMiddleware(stack); err != nil { + return err + } + if err = addResponseErrorMiddleware(stack); err != nil { + return err + } + if err = addRequestResponseLogging(stack, options); err != nil { + return err + } + return nil +} + +func newServiceMetadataMiddleware_opCreateServiceSyncConfig(region string) *awsmiddleware.RegisterServiceMetadata { + return &awsmiddleware.RegisterServiceMetadata{ + Region: region, + ServiceID: ServiceID, + SigningName: "proton", + OperationName: "CreateServiceSyncConfig", + } +} diff --git a/service/proton/api_op_DeleteServiceSyncConfig.go b/service/proton/api_op_DeleteServiceSyncConfig.go new file mode 100644 index 00000000000..161597b4335 --- /dev/null +++ b/service/proton/api_op_DeleteServiceSyncConfig.go @@ -0,0 +1,122 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package proton + +import ( + "context" + awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" + "github.com/aws/aws-sdk-go-v2/aws/signer/v4" + "github.com/aws/aws-sdk-go-v2/service/proton/types" + "github.com/aws/smithy-go/middleware" + smithyhttp "github.com/aws/smithy-go/transport/http" +) + +// Delete the Proton Ops file. +func (c *Client) DeleteServiceSyncConfig(ctx context.Context, params *DeleteServiceSyncConfigInput, optFns ...func(*Options)) (*DeleteServiceSyncConfigOutput, error) { + if params == nil { + params = &DeleteServiceSyncConfigInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "DeleteServiceSyncConfig", params, optFns, c.addOperationDeleteServiceSyncConfigMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*DeleteServiceSyncConfigOutput) + out.ResultMetadata = metadata + return out, nil +} + +type DeleteServiceSyncConfigInput struct { + + // The name of the service that you want to delete the service sync configuration + // for. + // + // This member is required. + ServiceName *string + + noSmithyDocumentSerde +} + +type DeleteServiceSyncConfigOutput struct { + + // The detailed data for the service sync config. + ServiceSyncConfig *types.ServiceSyncConfig + + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (c *Client) addOperationDeleteServiceSyncConfigMiddlewares(stack *middleware.Stack, options Options) (err error) { + err = stack.Serialize.Add(&awsAwsjson10_serializeOpDeleteServiceSyncConfig{}, middleware.After) + if err != nil { + return err + } + err = stack.Deserialize.Add(&awsAwsjson10_deserializeOpDeleteServiceSyncConfig{}, middleware.After) + if err != nil { + return err + } + if err = addSetLoggerMiddleware(stack, options); err != nil { + return err + } + if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil { + return err + } + if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil { + return err + } + if err = addResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil { + return err + } + if err = addRetryMiddlewares(stack, options); err != nil { + return err + } + if err = addHTTPSignerV4Middleware(stack, options); err != nil { + return err + } + if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil { + return err + } + if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil { + return err + } + if err = addClientUserAgent(stack); err != nil { + return err + } + if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil { + return err + } + if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { + return err + } + if err = addOpDeleteServiceSyncConfigValidationMiddleware(stack); err != nil { + return err + } + if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteServiceSyncConfig(options.Region), middleware.Before); err != nil { + return err + } + if err = addRequestIDRetrieverMiddleware(stack); err != nil { + return err + } + if err = addResponseErrorMiddleware(stack); err != nil { + return err + } + if err = addRequestResponseLogging(stack, options); err != nil { + return err + } + return nil +} + +func newServiceMetadataMiddleware_opDeleteServiceSyncConfig(region string) *awsmiddleware.RegisterServiceMetadata { + return &awsmiddleware.RegisterServiceMetadata{ + Region: region, + ServiceID: ServiceID, + SigningName: "proton", + OperationName: "DeleteServiceSyncConfig", + } +} diff --git a/service/proton/api_op_GetResourcesSummary.go b/service/proton/api_op_GetResourcesSummary.go index c2f2a1961ed..7b0f2a6d18e 100644 --- a/service/proton/api_op_GetResourcesSummary.go +++ b/service/proton/api_op_GetResourcesSummary.go @@ -18,8 +18,8 @@ import ( // The action returns staleness counts (counts of resources that are up-to-date, // behind a template major version, or behind a template minor version), the total // number of resources, and the number of resources that are in a failed state, -// grouped by resource type. Components, environments, and service templates are -// exceptions—see the components, environments, and serviceTemplates field +// grouped by resource type. Components, environments, and service templates return +// less information - see the components, environments, and serviceTemplates field // descriptions. For context, the action also returns the total number of each type // of Proton template in the Amazon Web Services account. For more information, see // Proton dashboard diff --git a/service/proton/api_op_GetServiceInstance.go b/service/proton/api_op_GetServiceInstance.go index a0ac119ec05..24246ec5b39 100644 --- a/service/proton/api_op_GetServiceInstance.go +++ b/service/proton/api_op_GetServiceInstance.go @@ -40,7 +40,7 @@ type GetServiceInstanceInput struct { // This member is required. Name *string - // The name of the service that the service instance belongs to. + // The name of the service that you want the service instance input for. // // This member is required. ServiceName *string diff --git a/service/proton/api_op_GetServiceInstanceSyncStatus.go b/service/proton/api_op_GetServiceInstanceSyncStatus.go new file mode 100644 index 00000000000..aef78c2925c --- /dev/null +++ b/service/proton/api_op_GetServiceInstanceSyncStatus.go @@ -0,0 +1,132 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package proton + +import ( + "context" + awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" + "github.com/aws/aws-sdk-go-v2/aws/signer/v4" + "github.com/aws/aws-sdk-go-v2/service/proton/types" + "github.com/aws/smithy-go/middleware" + smithyhttp "github.com/aws/smithy-go/transport/http" +) + +// Get the status of the synced service instance. +func (c *Client) GetServiceInstanceSyncStatus(ctx context.Context, params *GetServiceInstanceSyncStatusInput, optFns ...func(*Options)) (*GetServiceInstanceSyncStatusOutput, error) { + if params == nil { + params = &GetServiceInstanceSyncStatusInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "GetServiceInstanceSyncStatus", params, optFns, c.addOperationGetServiceInstanceSyncStatusMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*GetServiceInstanceSyncStatusOutput) + out.ResultMetadata = metadata + return out, nil +} + +type GetServiceInstanceSyncStatusInput struct { + + // The name of the service instance that you want the sync status input for. + // + // This member is required. + ServiceInstanceName *string + + // The name of the service that the service instance belongs to. + // + // This member is required. + ServiceName *string + + noSmithyDocumentSerde +} + +type GetServiceInstanceSyncStatusOutput struct { + + // The service instance sync desired state that's returned by Proton + DesiredState *types.Revision + + // The detailed data of the latest successful sync with the service instance. + LatestSuccessfulSync *types.ResourceSyncAttempt + + // The detailed data of the latest sync with the service instance. + LatestSync *types.ResourceSyncAttempt + + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (c *Client) addOperationGetServiceInstanceSyncStatusMiddlewares(stack *middleware.Stack, options Options) (err error) { + err = stack.Serialize.Add(&awsAwsjson10_serializeOpGetServiceInstanceSyncStatus{}, middleware.After) + if err != nil { + return err + } + err = stack.Deserialize.Add(&awsAwsjson10_deserializeOpGetServiceInstanceSyncStatus{}, middleware.After) + if err != nil { + return err + } + if err = addSetLoggerMiddleware(stack, options); err != nil { + return err + } + if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil { + return err + } + if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil { + return err + } + if err = addResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil { + return err + } + if err = addRetryMiddlewares(stack, options); err != nil { + return err + } + if err = addHTTPSignerV4Middleware(stack, options); err != nil { + return err + } + if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil { + return err + } + if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil { + return err + } + if err = addClientUserAgent(stack); err != nil { + return err + } + if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil { + return err + } + if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { + return err + } + if err = addOpGetServiceInstanceSyncStatusValidationMiddleware(stack); err != nil { + return err + } + if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetServiceInstanceSyncStatus(options.Region), middleware.Before); err != nil { + return err + } + if err = addRequestIDRetrieverMiddleware(stack); err != nil { + return err + } + if err = addResponseErrorMiddleware(stack); err != nil { + return err + } + if err = addRequestResponseLogging(stack, options); err != nil { + return err + } + return nil +} + +func newServiceMetadataMiddleware_opGetServiceInstanceSyncStatus(region string) *awsmiddleware.RegisterServiceMetadata { + return &awsmiddleware.RegisterServiceMetadata{ + Region: region, + ServiceID: ServiceID, + SigningName: "proton", + OperationName: "GetServiceInstanceSyncStatus", + } +} diff --git a/service/proton/api_op_GetServiceSyncBlockerSummary.go b/service/proton/api_op_GetServiceSyncBlockerSummary.go new file mode 100644 index 00000000000..103b7cb78ad --- /dev/null +++ b/service/proton/api_op_GetServiceSyncBlockerSummary.go @@ -0,0 +1,127 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package proton + +import ( + "context" + awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" + "github.com/aws/aws-sdk-go-v2/aws/signer/v4" + "github.com/aws/aws-sdk-go-v2/service/proton/types" + "github.com/aws/smithy-go/middleware" + smithyhttp "github.com/aws/smithy-go/transport/http" +) + +// Get detailed data for the service sync blocker summary. +func (c *Client) GetServiceSyncBlockerSummary(ctx context.Context, params *GetServiceSyncBlockerSummaryInput, optFns ...func(*Options)) (*GetServiceSyncBlockerSummaryOutput, error) { + if params == nil { + params = &GetServiceSyncBlockerSummaryInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "GetServiceSyncBlockerSummary", params, optFns, c.addOperationGetServiceSyncBlockerSummaryMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*GetServiceSyncBlockerSummaryOutput) + out.ResultMetadata = metadata + return out, nil +} + +type GetServiceSyncBlockerSummaryInput struct { + + // The name of the service that you want to get the service sync blocker summary + // for. If given only the service name, all instances are blocked. + // + // This member is required. + ServiceName *string + + // The name of the service instance that you want to get the service sync blocker + // summary for. If given bothe the instance name and the service name, only the + // instance is blocked. + ServiceInstanceName *string + + noSmithyDocumentSerde +} + +type GetServiceSyncBlockerSummaryOutput struct { + + // The detailed data of the requested service sync blocker summary. + ServiceSyncBlockerSummary *types.ServiceSyncBlockerSummary + + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (c *Client) addOperationGetServiceSyncBlockerSummaryMiddlewares(stack *middleware.Stack, options Options) (err error) { + err = stack.Serialize.Add(&awsAwsjson10_serializeOpGetServiceSyncBlockerSummary{}, middleware.After) + if err != nil { + return err + } + err = stack.Deserialize.Add(&awsAwsjson10_deserializeOpGetServiceSyncBlockerSummary{}, middleware.After) + if err != nil { + return err + } + if err = addSetLoggerMiddleware(stack, options); err != nil { + return err + } + if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil { + return err + } + if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil { + return err + } + if err = addResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil { + return err + } + if err = addRetryMiddlewares(stack, options); err != nil { + return err + } + if err = addHTTPSignerV4Middleware(stack, options); err != nil { + return err + } + if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil { + return err + } + if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil { + return err + } + if err = addClientUserAgent(stack); err != nil { + return err + } + if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil { + return err + } + if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { + return err + } + if err = addOpGetServiceSyncBlockerSummaryValidationMiddleware(stack); err != nil { + return err + } + if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetServiceSyncBlockerSummary(options.Region), middleware.Before); err != nil { + return err + } + if err = addRequestIDRetrieverMiddleware(stack); err != nil { + return err + } + if err = addResponseErrorMiddleware(stack); err != nil { + return err + } + if err = addRequestResponseLogging(stack, options); err != nil { + return err + } + return nil +} + +func newServiceMetadataMiddleware_opGetServiceSyncBlockerSummary(region string) *awsmiddleware.RegisterServiceMetadata { + return &awsmiddleware.RegisterServiceMetadata{ + Region: region, + ServiceID: ServiceID, + SigningName: "proton", + OperationName: "GetServiceSyncBlockerSummary", + } +} diff --git a/service/proton/api_op_GetServiceSyncConfig.go b/service/proton/api_op_GetServiceSyncConfig.go new file mode 100644 index 00000000000..4015ddb13e2 --- /dev/null +++ b/service/proton/api_op_GetServiceSyncConfig.go @@ -0,0 +1,121 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package proton + +import ( + "context" + awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" + "github.com/aws/aws-sdk-go-v2/aws/signer/v4" + "github.com/aws/aws-sdk-go-v2/service/proton/types" + "github.com/aws/smithy-go/middleware" + smithyhttp "github.com/aws/smithy-go/transport/http" +) + +// Get detailed information for the service sync configuration. +func (c *Client) GetServiceSyncConfig(ctx context.Context, params *GetServiceSyncConfigInput, optFns ...func(*Options)) (*GetServiceSyncConfigOutput, error) { + if params == nil { + params = &GetServiceSyncConfigInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "GetServiceSyncConfig", params, optFns, c.addOperationGetServiceSyncConfigMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*GetServiceSyncConfigOutput) + out.ResultMetadata = metadata + return out, nil +} + +type GetServiceSyncConfigInput struct { + + // The name of the service that you want to get the service sync configuration for. + // + // This member is required. + ServiceName *string + + noSmithyDocumentSerde +} + +type GetServiceSyncConfigOutput struct { + + // The detailed data of the requested service sync configuration. + ServiceSyncConfig *types.ServiceSyncConfig + + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (c *Client) addOperationGetServiceSyncConfigMiddlewares(stack *middleware.Stack, options Options) (err error) { + err = stack.Serialize.Add(&awsAwsjson10_serializeOpGetServiceSyncConfig{}, middleware.After) + if err != nil { + return err + } + err = stack.Deserialize.Add(&awsAwsjson10_deserializeOpGetServiceSyncConfig{}, middleware.After) + if err != nil { + return err + } + if err = addSetLoggerMiddleware(stack, options); err != nil { + return err + } + if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil { + return err + } + if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil { + return err + } + if err = addResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil { + return err + } + if err = addRetryMiddlewares(stack, options); err != nil { + return err + } + if err = addHTTPSignerV4Middleware(stack, options); err != nil { + return err + } + if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil { + return err + } + if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil { + return err + } + if err = addClientUserAgent(stack); err != nil { + return err + } + if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil { + return err + } + if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { + return err + } + if err = addOpGetServiceSyncConfigValidationMiddleware(stack); err != nil { + return err + } + if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetServiceSyncConfig(options.Region), middleware.Before); err != nil { + return err + } + if err = addRequestIDRetrieverMiddleware(stack); err != nil { + return err + } + if err = addResponseErrorMiddleware(stack); err != nil { + return err + } + if err = addRequestResponseLogging(stack, options); err != nil { + return err + } + return nil +} + +func newServiceMetadataMiddleware_opGetServiceSyncConfig(region string) *awsmiddleware.RegisterServiceMetadata { + return &awsmiddleware.RegisterServiceMetadata{ + Region: region, + ServiceID: ServiceID, + SigningName: "proton", + OperationName: "GetServiceSyncConfig", + } +} diff --git a/service/proton/api_op_UpdateComponent.go b/service/proton/api_op_UpdateComponent.go index 2bda0473af6..41cf037e417 100644 --- a/service/proton/api_op_UpdateComponent.go +++ b/service/proton/api_op_UpdateComponent.go @@ -4,6 +4,7 @@ package proton import ( "context" + "fmt" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" "github.com/aws/aws-sdk-go-v2/service/proton/types" @@ -49,6 +50,9 @@ type UpdateComponentInput struct { // This member is required. Name *string + // The client token for the updated component. + ClientToken *string + // An optional customer-provided description of the component. Description *string @@ -140,6 +144,9 @@ func (c *Client) addOperationUpdateComponentMiddlewares(stack *middleware.Stack, if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addIdempotencyToken_opUpdateComponentMiddleware(stack, options); err != nil { + return err + } if err = addOpUpdateComponentValidationMiddleware(stack); err != nil { return err } @@ -158,6 +165,39 @@ func (c *Client) addOperationUpdateComponentMiddlewares(stack *middleware.Stack, return nil } +type idempotencyToken_initializeOpUpdateComponent struct { + tokenProvider IdempotencyTokenProvider +} + +func (*idempotencyToken_initializeOpUpdateComponent) ID() string { + return "OperationIdempotencyTokenAutoFill" +} + +func (m *idempotencyToken_initializeOpUpdateComponent) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + if m.tokenProvider == nil { + return next.HandleInitialize(ctx, in) + } + + input, ok := in.Parameters.(*UpdateComponentInput) + if !ok { + return out, metadata, fmt.Errorf("expected middleware input to be of type *UpdateComponentInput ") + } + + if input.ClientToken == nil { + t, err := m.tokenProvider.GetIdempotencyToken() + if err != nil { + return out, metadata, err + } + input.ClientToken = &t + } + return next.HandleInitialize(ctx, in) +} +func addIdempotencyToken_opUpdateComponentMiddleware(stack *middleware.Stack, cfg Options) error { + return stack.Initialize.Add(&idempotencyToken_initializeOpUpdateComponent{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before) +} + func newServiceMetadataMiddleware_opUpdateComponent(region string) *awsmiddleware.RegisterServiceMetadata { return &awsmiddleware.RegisterServiceMetadata{ Region: region, diff --git a/service/proton/api_op_UpdateServiceInstance.go b/service/proton/api_op_UpdateServiceInstance.go index cc24bf3069f..3d6d4a82564 100644 --- a/service/proton/api_op_UpdateServiceInstance.go +++ b/service/proton/api_op_UpdateServiceInstance.go @@ -4,6 +4,7 @@ package proton import ( "context" + "fmt" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" "github.com/aws/aws-sdk-go-v2/service/proton/types" @@ -62,6 +63,9 @@ type UpdateServiceInstanceInput struct { // This member is required. ServiceName *string + // The client token of the service instance to update. + ClientToken *string + // The formatted specification that defines the service instance update. // // This value conforms to the media type: application/yaml @@ -134,6 +138,9 @@ func (c *Client) addOperationUpdateServiceInstanceMiddlewares(stack *middleware. if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addIdempotencyToken_opUpdateServiceInstanceMiddleware(stack, options); err != nil { + return err + } if err = addOpUpdateServiceInstanceValidationMiddleware(stack); err != nil { return err } @@ -152,6 +159,39 @@ func (c *Client) addOperationUpdateServiceInstanceMiddlewares(stack *middleware. return nil } +type idempotencyToken_initializeOpUpdateServiceInstance struct { + tokenProvider IdempotencyTokenProvider +} + +func (*idempotencyToken_initializeOpUpdateServiceInstance) ID() string { + return "OperationIdempotencyTokenAutoFill" +} + +func (m *idempotencyToken_initializeOpUpdateServiceInstance) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + if m.tokenProvider == nil { + return next.HandleInitialize(ctx, in) + } + + input, ok := in.Parameters.(*UpdateServiceInstanceInput) + if !ok { + return out, metadata, fmt.Errorf("expected middleware input to be of type *UpdateServiceInstanceInput ") + } + + if input.ClientToken == nil { + t, err := m.tokenProvider.GetIdempotencyToken() + if err != nil { + return out, metadata, err + } + input.ClientToken = &t + } + return next.HandleInitialize(ctx, in) +} +func addIdempotencyToken_opUpdateServiceInstanceMiddleware(stack *middleware.Stack, cfg Options) error { + return stack.Initialize.Add(&idempotencyToken_initializeOpUpdateServiceInstance{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before) +} + func newServiceMetadataMiddleware_opUpdateServiceInstance(region string) *awsmiddleware.RegisterServiceMetadata { return &awsmiddleware.RegisterServiceMetadata{ Region: region, diff --git a/service/proton/api_op_UpdateServiceSyncBlocker.go b/service/proton/api_op_UpdateServiceSyncBlocker.go new file mode 100644 index 00000000000..bfebcd80996 --- /dev/null +++ b/service/proton/api_op_UpdateServiceSyncBlocker.go @@ -0,0 +1,137 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package proton + +import ( + "context" + awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" + "github.com/aws/aws-sdk-go-v2/aws/signer/v4" + "github.com/aws/aws-sdk-go-v2/service/proton/types" + "github.com/aws/smithy-go/middleware" + smithyhttp "github.com/aws/smithy-go/transport/http" +) + +// Update the service sync blocker by resolving it. +func (c *Client) UpdateServiceSyncBlocker(ctx context.Context, params *UpdateServiceSyncBlockerInput, optFns ...func(*Options)) (*UpdateServiceSyncBlockerOutput, error) { + if params == nil { + params = &UpdateServiceSyncBlockerInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "UpdateServiceSyncBlocker", params, optFns, c.addOperationUpdateServiceSyncBlockerMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*UpdateServiceSyncBlockerOutput) + out.ResultMetadata = metadata + return out, nil +} + +type UpdateServiceSyncBlockerInput struct { + + // The ID of the service sync blocker. + // + // This member is required. + Id *string + + // The reason the service sync blocker was resolved. + // + // This member is required. + ResolvedReason *string + + noSmithyDocumentSerde +} + +type UpdateServiceSyncBlockerOutput struct { + + // The name of the service that you want to update the service sync blocker for. + // + // This member is required. + ServiceName *string + + // The detailed data on the service sync blocker that was updated. + // + // This member is required. + ServiceSyncBlocker *types.SyncBlocker + + // The name of the service instance that you want to update the service sync + // blocker for. + ServiceInstanceName *string + + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (c *Client) addOperationUpdateServiceSyncBlockerMiddlewares(stack *middleware.Stack, options Options) (err error) { + err = stack.Serialize.Add(&awsAwsjson10_serializeOpUpdateServiceSyncBlocker{}, middleware.After) + if err != nil { + return err + } + err = stack.Deserialize.Add(&awsAwsjson10_deserializeOpUpdateServiceSyncBlocker{}, middleware.After) + if err != nil { + return err + } + if err = addSetLoggerMiddleware(stack, options); err != nil { + return err + } + if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil { + return err + } + if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil { + return err + } + if err = addResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil { + return err + } + if err = addRetryMiddlewares(stack, options); err != nil { + return err + } + if err = addHTTPSignerV4Middleware(stack, options); err != nil { + return err + } + if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil { + return err + } + if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil { + return err + } + if err = addClientUserAgent(stack); err != nil { + return err + } + if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil { + return err + } + if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { + return err + } + if err = addOpUpdateServiceSyncBlockerValidationMiddleware(stack); err != nil { + return err + } + if err = stack.Initialize.Add(newServiceMetadataMiddleware_opUpdateServiceSyncBlocker(options.Region), middleware.Before); err != nil { + return err + } + if err = addRequestIDRetrieverMiddleware(stack); err != nil { + return err + } + if err = addResponseErrorMiddleware(stack); err != nil { + return err + } + if err = addRequestResponseLogging(stack, options); err != nil { + return err + } + return nil +} + +func newServiceMetadataMiddleware_opUpdateServiceSyncBlocker(region string) *awsmiddleware.RegisterServiceMetadata { + return &awsmiddleware.RegisterServiceMetadata{ + Region: region, + ServiceID: ServiceID, + SigningName: "proton", + OperationName: "UpdateServiceSyncBlocker", + } +} diff --git a/service/proton/api_op_UpdateServiceSyncConfig.go b/service/proton/api_op_UpdateServiceSyncConfig.go new file mode 100644 index 00000000000..2b045f0214a --- /dev/null +++ b/service/proton/api_op_UpdateServiceSyncConfig.go @@ -0,0 +1,141 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package proton + +import ( + "context" + awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" + "github.com/aws/aws-sdk-go-v2/aws/signer/v4" + "github.com/aws/aws-sdk-go-v2/service/proton/types" + "github.com/aws/smithy-go/middleware" + smithyhttp "github.com/aws/smithy-go/transport/http" +) + +// Update the Proton Ops config file. +func (c *Client) UpdateServiceSyncConfig(ctx context.Context, params *UpdateServiceSyncConfigInput, optFns ...func(*Options)) (*UpdateServiceSyncConfigOutput, error) { + if params == nil { + params = &UpdateServiceSyncConfigInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "UpdateServiceSyncConfig", params, optFns, c.addOperationUpdateServiceSyncConfigMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*UpdateServiceSyncConfigOutput) + out.ResultMetadata = metadata + return out, nil +} + +type UpdateServiceSyncConfigInput struct { + + // The name of the code repository branch where the Proton Ops file is found. + // + // This member is required. + Branch *string + + // The path to the Proton Ops file. + // + // This member is required. + FilePath *string + + // The name of the repository where the Proton Ops file is found. + // + // This member is required. + RepositoryName *string + + // The name of the repository provider where the Proton Ops file is found. + // + // This member is required. + RepositoryProvider types.RepositoryProvider + + // The name of the service the Proton Ops file is for. + // + // This member is required. + ServiceName *string + + noSmithyDocumentSerde +} + +type UpdateServiceSyncConfigOutput struct { + + // The detailed data of the Proton Ops file. + ServiceSyncConfig *types.ServiceSyncConfig + + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (c *Client) addOperationUpdateServiceSyncConfigMiddlewares(stack *middleware.Stack, options Options) (err error) { + err = stack.Serialize.Add(&awsAwsjson10_serializeOpUpdateServiceSyncConfig{}, middleware.After) + if err != nil { + return err + } + err = stack.Deserialize.Add(&awsAwsjson10_deserializeOpUpdateServiceSyncConfig{}, middleware.After) + if err != nil { + return err + } + if err = addSetLoggerMiddleware(stack, options); err != nil { + return err + } + if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil { + return err + } + if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil { + return err + } + if err = addResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil { + return err + } + if err = addRetryMiddlewares(stack, options); err != nil { + return err + } + if err = addHTTPSignerV4Middleware(stack, options); err != nil { + return err + } + if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil { + return err + } + if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil { + return err + } + if err = addClientUserAgent(stack); err != nil { + return err + } + if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil { + return err + } + if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { + return err + } + if err = addOpUpdateServiceSyncConfigValidationMiddleware(stack); err != nil { + return err + } + if err = stack.Initialize.Add(newServiceMetadataMiddleware_opUpdateServiceSyncConfig(options.Region), middleware.Before); err != nil { + return err + } + if err = addRequestIDRetrieverMiddleware(stack); err != nil { + return err + } + if err = addResponseErrorMiddleware(stack); err != nil { + return err + } + if err = addRequestResponseLogging(stack, options); err != nil { + return err + } + return nil +} + +func newServiceMetadataMiddleware_opUpdateServiceSyncConfig(region string) *awsmiddleware.RegisterServiceMetadata { + return &awsmiddleware.RegisterServiceMetadata{ + Region: region, + ServiceID: ServiceID, + SigningName: "proton", + OperationName: "UpdateServiceSyncConfig", + } +} diff --git a/service/proton/deserializers.go b/service/proton/deserializers.go index e8bd1dd655b..a54376aadc7 100644 --- a/service/proton/deserializers.go +++ b/service/proton/deserializers.go @@ -1543,14 +1543,14 @@ func awsAwsjson10_deserializeOpErrorCreateService(response *smithyhttp.Response, } } -type awsAwsjson10_deserializeOpCreateServiceTemplate struct { +type awsAwsjson10_deserializeOpCreateServiceInstance struct { } -func (*awsAwsjson10_deserializeOpCreateServiceTemplate) ID() string { +func (*awsAwsjson10_deserializeOpCreateServiceInstance) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson10_deserializeOpCreateServiceTemplate) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson10_deserializeOpCreateServiceInstance) 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) @@ -1564,9 +1564,9 @@ func (m *awsAwsjson10_deserializeOpCreateServiceTemplate) HandleDeserialize(ctx } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson10_deserializeOpErrorCreateServiceTemplate(response, &metadata) + return out, metadata, awsAwsjson10_deserializeOpErrorCreateServiceInstance(response, &metadata) } - output := &CreateServiceTemplateOutput{} + output := &CreateServiceInstanceOutput{} out.Result = output var buff [1024]byte @@ -1586,7 +1586,7 @@ func (m *awsAwsjson10_deserializeOpCreateServiceTemplate) HandleDeserialize(ctx return out, metadata, err } - err = awsAwsjson10_deserializeOpDocumentCreateServiceTemplateOutput(&output, shape) + err = awsAwsjson10_deserializeOpDocumentCreateServiceInstanceOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -1600,7 +1600,7 @@ func (m *awsAwsjson10_deserializeOpCreateServiceTemplate) HandleDeserialize(ctx return out, metadata, err } -func awsAwsjson10_deserializeOpErrorCreateServiceTemplate(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson10_deserializeOpErrorCreateServiceInstance(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)} @@ -1650,8 +1650,8 @@ func awsAwsjson10_deserializeOpErrorCreateServiceTemplate(response *smithyhttp.R case strings.EqualFold("InternalServerException", errorCode): return awsAwsjson10_deserializeErrorInternalServerException(response, errorBody) - case strings.EqualFold("ServiceQuotaExceededException", errorCode): - return awsAwsjson10_deserializeErrorServiceQuotaExceededException(response, errorBody) + case strings.EqualFold("ResourceNotFoundException", errorCode): + return awsAwsjson10_deserializeErrorResourceNotFoundException(response, errorBody) case strings.EqualFold("ThrottlingException", errorCode): return awsAwsjson10_deserializeErrorThrottlingException(response, errorBody) @@ -1669,14 +1669,14 @@ func awsAwsjson10_deserializeOpErrorCreateServiceTemplate(response *smithyhttp.R } } -type awsAwsjson10_deserializeOpCreateServiceTemplateVersion struct { +type awsAwsjson10_deserializeOpCreateServiceSyncConfig struct { } -func (*awsAwsjson10_deserializeOpCreateServiceTemplateVersion) ID() string { +func (*awsAwsjson10_deserializeOpCreateServiceSyncConfig) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson10_deserializeOpCreateServiceTemplateVersion) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson10_deserializeOpCreateServiceSyncConfig) 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) @@ -1690,9 +1690,9 @@ func (m *awsAwsjson10_deserializeOpCreateServiceTemplateVersion) HandleDeseriali } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson10_deserializeOpErrorCreateServiceTemplateVersion(response, &metadata) + return out, metadata, awsAwsjson10_deserializeOpErrorCreateServiceSyncConfig(response, &metadata) } - output := &CreateServiceTemplateVersionOutput{} + output := &CreateServiceSyncConfigOutput{} out.Result = output var buff [1024]byte @@ -1712,7 +1712,7 @@ func (m *awsAwsjson10_deserializeOpCreateServiceTemplateVersion) HandleDeseriali return out, metadata, err } - err = awsAwsjson10_deserializeOpDocumentCreateServiceTemplateVersionOutput(&output, shape) + err = awsAwsjson10_deserializeOpDocumentCreateServiceSyncConfigOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -1726,7 +1726,7 @@ func (m *awsAwsjson10_deserializeOpCreateServiceTemplateVersion) HandleDeseriali return out, metadata, err } -func awsAwsjson10_deserializeOpErrorCreateServiceTemplateVersion(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson10_deserializeOpErrorCreateServiceSyncConfig(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)} @@ -1776,9 +1776,6 @@ func awsAwsjson10_deserializeOpErrorCreateServiceTemplateVersion(response *smith case strings.EqualFold("InternalServerException", errorCode): return awsAwsjson10_deserializeErrorInternalServerException(response, errorBody) - case strings.EqualFold("ResourceNotFoundException", errorCode): - return awsAwsjson10_deserializeErrorResourceNotFoundException(response, errorBody) - case strings.EqualFold("ServiceQuotaExceededException", errorCode): return awsAwsjson10_deserializeErrorServiceQuotaExceededException(response, errorBody) @@ -1798,14 +1795,14 @@ func awsAwsjson10_deserializeOpErrorCreateServiceTemplateVersion(response *smith } } -type awsAwsjson10_deserializeOpCreateTemplateSyncConfig struct { +type awsAwsjson10_deserializeOpCreateServiceTemplate struct { } -func (*awsAwsjson10_deserializeOpCreateTemplateSyncConfig) ID() string { +func (*awsAwsjson10_deserializeOpCreateServiceTemplate) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson10_deserializeOpCreateTemplateSyncConfig) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson10_deserializeOpCreateServiceTemplate) 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) @@ -1819,9 +1816,9 @@ func (m *awsAwsjson10_deserializeOpCreateTemplateSyncConfig) HandleDeserialize(c } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson10_deserializeOpErrorCreateTemplateSyncConfig(response, &metadata) + return out, metadata, awsAwsjson10_deserializeOpErrorCreateServiceTemplate(response, &metadata) } - output := &CreateTemplateSyncConfigOutput{} + output := &CreateServiceTemplateOutput{} out.Result = output var buff [1024]byte @@ -1841,7 +1838,7 @@ func (m *awsAwsjson10_deserializeOpCreateTemplateSyncConfig) HandleDeserialize(c return out, metadata, err } - err = awsAwsjson10_deserializeOpDocumentCreateTemplateSyncConfigOutput(&output, shape) + err = awsAwsjson10_deserializeOpDocumentCreateServiceTemplateOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -1855,7 +1852,7 @@ func (m *awsAwsjson10_deserializeOpCreateTemplateSyncConfig) HandleDeserialize(c return out, metadata, err } -func awsAwsjson10_deserializeOpErrorCreateTemplateSyncConfig(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson10_deserializeOpErrorCreateServiceTemplate(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)} @@ -1924,14 +1921,14 @@ func awsAwsjson10_deserializeOpErrorCreateTemplateSyncConfig(response *smithyhtt } } -type awsAwsjson10_deserializeOpDeleteComponent struct { +type awsAwsjson10_deserializeOpCreateServiceTemplateVersion struct { } -func (*awsAwsjson10_deserializeOpDeleteComponent) ID() string { +func (*awsAwsjson10_deserializeOpCreateServiceTemplateVersion) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson10_deserializeOpDeleteComponent) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson10_deserializeOpCreateServiceTemplateVersion) 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) @@ -1945,9 +1942,9 @@ func (m *awsAwsjson10_deserializeOpDeleteComponent) HandleDeserialize(ctx contex } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson10_deserializeOpErrorDeleteComponent(response, &metadata) + return out, metadata, awsAwsjson10_deserializeOpErrorCreateServiceTemplateVersion(response, &metadata) } - output := &DeleteComponentOutput{} + output := &CreateServiceTemplateVersionOutput{} out.Result = output var buff [1024]byte @@ -1967,7 +1964,7 @@ func (m *awsAwsjson10_deserializeOpDeleteComponent) HandleDeserialize(ctx contex return out, metadata, err } - err = awsAwsjson10_deserializeOpDocumentDeleteComponentOutput(&output, shape) + err = awsAwsjson10_deserializeOpDocumentCreateServiceTemplateVersionOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -1981,7 +1978,7 @@ func (m *awsAwsjson10_deserializeOpDeleteComponent) HandleDeserialize(ctx contex return out, metadata, err } -func awsAwsjson10_deserializeOpErrorDeleteComponent(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson10_deserializeOpErrorCreateServiceTemplateVersion(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)} @@ -2034,6 +2031,9 @@ func awsAwsjson10_deserializeOpErrorDeleteComponent(response *smithyhttp.Respons case strings.EqualFold("ResourceNotFoundException", errorCode): return awsAwsjson10_deserializeErrorResourceNotFoundException(response, errorBody) + case strings.EqualFold("ServiceQuotaExceededException", errorCode): + return awsAwsjson10_deserializeErrorServiceQuotaExceededException(response, errorBody) + case strings.EqualFold("ThrottlingException", errorCode): return awsAwsjson10_deserializeErrorThrottlingException(response, errorBody) @@ -2050,14 +2050,14 @@ func awsAwsjson10_deserializeOpErrorDeleteComponent(response *smithyhttp.Respons } } -type awsAwsjson10_deserializeOpDeleteEnvironment struct { +type awsAwsjson10_deserializeOpCreateTemplateSyncConfig struct { } -func (*awsAwsjson10_deserializeOpDeleteEnvironment) ID() string { +func (*awsAwsjson10_deserializeOpCreateTemplateSyncConfig) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson10_deserializeOpDeleteEnvironment) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson10_deserializeOpCreateTemplateSyncConfig) 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) @@ -2071,9 +2071,9 @@ func (m *awsAwsjson10_deserializeOpDeleteEnvironment) HandleDeserialize(ctx cont } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson10_deserializeOpErrorDeleteEnvironment(response, &metadata) + return out, metadata, awsAwsjson10_deserializeOpErrorCreateTemplateSyncConfig(response, &metadata) } - output := &DeleteEnvironmentOutput{} + output := &CreateTemplateSyncConfigOutput{} out.Result = output var buff [1024]byte @@ -2093,7 +2093,7 @@ func (m *awsAwsjson10_deserializeOpDeleteEnvironment) HandleDeserialize(ctx cont return out, metadata, err } - err = awsAwsjson10_deserializeOpDocumentDeleteEnvironmentOutput(&output, shape) + err = awsAwsjson10_deserializeOpDocumentCreateTemplateSyncConfigOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -2107,7 +2107,7 @@ func (m *awsAwsjson10_deserializeOpDeleteEnvironment) HandleDeserialize(ctx cont return out, metadata, err } -func awsAwsjson10_deserializeOpErrorDeleteEnvironment(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson10_deserializeOpErrorCreateTemplateSyncConfig(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)} @@ -2157,8 +2157,8 @@ func awsAwsjson10_deserializeOpErrorDeleteEnvironment(response *smithyhttp.Respo case strings.EqualFold("InternalServerException", errorCode): return awsAwsjson10_deserializeErrorInternalServerException(response, errorBody) - case strings.EqualFold("ResourceNotFoundException", errorCode): - return awsAwsjson10_deserializeErrorResourceNotFoundException(response, errorBody) + case strings.EqualFold("ServiceQuotaExceededException", errorCode): + return awsAwsjson10_deserializeErrorServiceQuotaExceededException(response, errorBody) case strings.EqualFold("ThrottlingException", errorCode): return awsAwsjson10_deserializeErrorThrottlingException(response, errorBody) @@ -2176,14 +2176,14 @@ func awsAwsjson10_deserializeOpErrorDeleteEnvironment(response *smithyhttp.Respo } } -type awsAwsjson10_deserializeOpDeleteEnvironmentAccountConnection struct { +type awsAwsjson10_deserializeOpDeleteComponent struct { } -func (*awsAwsjson10_deserializeOpDeleteEnvironmentAccountConnection) ID() string { +func (*awsAwsjson10_deserializeOpDeleteComponent) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson10_deserializeOpDeleteEnvironmentAccountConnection) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson10_deserializeOpDeleteComponent) 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) @@ -2197,9 +2197,9 @@ func (m *awsAwsjson10_deserializeOpDeleteEnvironmentAccountConnection) HandleDes } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson10_deserializeOpErrorDeleteEnvironmentAccountConnection(response, &metadata) + return out, metadata, awsAwsjson10_deserializeOpErrorDeleteComponent(response, &metadata) } - output := &DeleteEnvironmentAccountConnectionOutput{} + output := &DeleteComponentOutput{} out.Result = output var buff [1024]byte @@ -2219,7 +2219,7 @@ func (m *awsAwsjson10_deserializeOpDeleteEnvironmentAccountConnection) HandleDes return out, metadata, err } - err = awsAwsjson10_deserializeOpDocumentDeleteEnvironmentAccountConnectionOutput(&output, shape) + err = awsAwsjson10_deserializeOpDocumentDeleteComponentOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -2233,7 +2233,7 @@ func (m *awsAwsjson10_deserializeOpDeleteEnvironmentAccountConnection) HandleDes return out, metadata, err } -func awsAwsjson10_deserializeOpErrorDeleteEnvironmentAccountConnection(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson10_deserializeOpErrorDeleteComponent(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)} @@ -2302,14 +2302,14 @@ func awsAwsjson10_deserializeOpErrorDeleteEnvironmentAccountConnection(response } } -type awsAwsjson10_deserializeOpDeleteEnvironmentTemplate struct { +type awsAwsjson10_deserializeOpDeleteEnvironment struct { } -func (*awsAwsjson10_deserializeOpDeleteEnvironmentTemplate) ID() string { +func (*awsAwsjson10_deserializeOpDeleteEnvironment) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson10_deserializeOpDeleteEnvironmentTemplate) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson10_deserializeOpDeleteEnvironment) 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) @@ -2323,9 +2323,9 @@ func (m *awsAwsjson10_deserializeOpDeleteEnvironmentTemplate) HandleDeserialize( } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson10_deserializeOpErrorDeleteEnvironmentTemplate(response, &metadata) + return out, metadata, awsAwsjson10_deserializeOpErrorDeleteEnvironment(response, &metadata) } - output := &DeleteEnvironmentTemplateOutput{} + output := &DeleteEnvironmentOutput{} out.Result = output var buff [1024]byte @@ -2345,7 +2345,7 @@ func (m *awsAwsjson10_deserializeOpDeleteEnvironmentTemplate) HandleDeserialize( return out, metadata, err } - err = awsAwsjson10_deserializeOpDocumentDeleteEnvironmentTemplateOutput(&output, shape) + err = awsAwsjson10_deserializeOpDocumentDeleteEnvironmentOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -2359,7 +2359,7 @@ func (m *awsAwsjson10_deserializeOpDeleteEnvironmentTemplate) HandleDeserialize( return out, metadata, err } -func awsAwsjson10_deserializeOpErrorDeleteEnvironmentTemplate(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson10_deserializeOpErrorDeleteEnvironment(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)} @@ -2428,14 +2428,14 @@ func awsAwsjson10_deserializeOpErrorDeleteEnvironmentTemplate(response *smithyht } } -type awsAwsjson10_deserializeOpDeleteEnvironmentTemplateVersion struct { +type awsAwsjson10_deserializeOpDeleteEnvironmentAccountConnection struct { } -func (*awsAwsjson10_deserializeOpDeleteEnvironmentTemplateVersion) ID() string { +func (*awsAwsjson10_deserializeOpDeleteEnvironmentAccountConnection) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson10_deserializeOpDeleteEnvironmentTemplateVersion) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson10_deserializeOpDeleteEnvironmentAccountConnection) 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) @@ -2449,9 +2449,9 @@ func (m *awsAwsjson10_deserializeOpDeleteEnvironmentTemplateVersion) HandleDeser } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson10_deserializeOpErrorDeleteEnvironmentTemplateVersion(response, &metadata) + return out, metadata, awsAwsjson10_deserializeOpErrorDeleteEnvironmentAccountConnection(response, &metadata) } - output := &DeleteEnvironmentTemplateVersionOutput{} + output := &DeleteEnvironmentAccountConnectionOutput{} out.Result = output var buff [1024]byte @@ -2471,7 +2471,7 @@ func (m *awsAwsjson10_deserializeOpDeleteEnvironmentTemplateVersion) HandleDeser return out, metadata, err } - err = awsAwsjson10_deserializeOpDocumentDeleteEnvironmentTemplateVersionOutput(&output, shape) + err = awsAwsjson10_deserializeOpDocumentDeleteEnvironmentAccountConnectionOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -2485,7 +2485,7 @@ func (m *awsAwsjson10_deserializeOpDeleteEnvironmentTemplateVersion) HandleDeser return out, metadata, err } -func awsAwsjson10_deserializeOpErrorDeleteEnvironmentTemplateVersion(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson10_deserializeOpErrorDeleteEnvironmentAccountConnection(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)} @@ -2554,14 +2554,14 @@ func awsAwsjson10_deserializeOpErrorDeleteEnvironmentTemplateVersion(response *s } } -type awsAwsjson10_deserializeOpDeleteRepository struct { +type awsAwsjson10_deserializeOpDeleteEnvironmentTemplate struct { } -func (*awsAwsjson10_deserializeOpDeleteRepository) ID() string { +func (*awsAwsjson10_deserializeOpDeleteEnvironmentTemplate) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson10_deserializeOpDeleteRepository) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson10_deserializeOpDeleteEnvironmentTemplate) 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) @@ -2575,9 +2575,9 @@ func (m *awsAwsjson10_deserializeOpDeleteRepository) HandleDeserialize(ctx conte } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson10_deserializeOpErrorDeleteRepository(response, &metadata) + return out, metadata, awsAwsjson10_deserializeOpErrorDeleteEnvironmentTemplate(response, &metadata) } - output := &DeleteRepositoryOutput{} + output := &DeleteEnvironmentTemplateOutput{} out.Result = output var buff [1024]byte @@ -2597,7 +2597,7 @@ func (m *awsAwsjson10_deserializeOpDeleteRepository) HandleDeserialize(ctx conte return out, metadata, err } - err = awsAwsjson10_deserializeOpDocumentDeleteRepositoryOutput(&output, shape) + err = awsAwsjson10_deserializeOpDocumentDeleteEnvironmentTemplateOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -2611,7 +2611,7 @@ func (m *awsAwsjson10_deserializeOpDeleteRepository) HandleDeserialize(ctx conte return out, metadata, err } -func awsAwsjson10_deserializeOpErrorDeleteRepository(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson10_deserializeOpErrorDeleteEnvironmentTemplate(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)} @@ -2680,14 +2680,14 @@ func awsAwsjson10_deserializeOpErrorDeleteRepository(response *smithyhttp.Respon } } -type awsAwsjson10_deserializeOpDeleteService struct { +type awsAwsjson10_deserializeOpDeleteEnvironmentTemplateVersion struct { } -func (*awsAwsjson10_deserializeOpDeleteService) ID() string { +func (*awsAwsjson10_deserializeOpDeleteEnvironmentTemplateVersion) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson10_deserializeOpDeleteService) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson10_deserializeOpDeleteEnvironmentTemplateVersion) 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) @@ -2701,9 +2701,9 @@ func (m *awsAwsjson10_deserializeOpDeleteService) HandleDeserialize(ctx context. } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson10_deserializeOpErrorDeleteService(response, &metadata) + return out, metadata, awsAwsjson10_deserializeOpErrorDeleteEnvironmentTemplateVersion(response, &metadata) } - output := &DeleteServiceOutput{} + output := &DeleteEnvironmentTemplateVersionOutput{} out.Result = output var buff [1024]byte @@ -2723,7 +2723,7 @@ func (m *awsAwsjson10_deserializeOpDeleteService) HandleDeserialize(ctx context. return out, metadata, err } - err = awsAwsjson10_deserializeOpDocumentDeleteServiceOutput(&output, shape) + err = awsAwsjson10_deserializeOpDocumentDeleteEnvironmentTemplateVersionOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -2737,7 +2737,7 @@ func (m *awsAwsjson10_deserializeOpDeleteService) HandleDeserialize(ctx context. return out, metadata, err } -func awsAwsjson10_deserializeOpErrorDeleteService(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson10_deserializeOpErrorDeleteEnvironmentTemplateVersion(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)} @@ -2806,14 +2806,14 @@ func awsAwsjson10_deserializeOpErrorDeleteService(response *smithyhttp.Response, } } -type awsAwsjson10_deserializeOpDeleteServiceTemplate struct { +type awsAwsjson10_deserializeOpDeleteRepository struct { } -func (*awsAwsjson10_deserializeOpDeleteServiceTemplate) ID() string { +func (*awsAwsjson10_deserializeOpDeleteRepository) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson10_deserializeOpDeleteServiceTemplate) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson10_deserializeOpDeleteRepository) 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) @@ -2827,9 +2827,9 @@ func (m *awsAwsjson10_deserializeOpDeleteServiceTemplate) HandleDeserialize(ctx } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson10_deserializeOpErrorDeleteServiceTemplate(response, &metadata) + return out, metadata, awsAwsjson10_deserializeOpErrorDeleteRepository(response, &metadata) } - output := &DeleteServiceTemplateOutput{} + output := &DeleteRepositoryOutput{} out.Result = output var buff [1024]byte @@ -2849,7 +2849,7 @@ func (m *awsAwsjson10_deserializeOpDeleteServiceTemplate) HandleDeserialize(ctx return out, metadata, err } - err = awsAwsjson10_deserializeOpDocumentDeleteServiceTemplateOutput(&output, shape) + err = awsAwsjson10_deserializeOpDocumentDeleteRepositoryOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -2863,7 +2863,7 @@ func (m *awsAwsjson10_deserializeOpDeleteServiceTemplate) HandleDeserialize(ctx return out, metadata, err } -func awsAwsjson10_deserializeOpErrorDeleteServiceTemplate(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson10_deserializeOpErrorDeleteRepository(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)} @@ -2932,14 +2932,14 @@ func awsAwsjson10_deserializeOpErrorDeleteServiceTemplate(response *smithyhttp.R } } -type awsAwsjson10_deserializeOpDeleteServiceTemplateVersion struct { +type awsAwsjson10_deserializeOpDeleteService struct { } -func (*awsAwsjson10_deserializeOpDeleteServiceTemplateVersion) ID() string { +func (*awsAwsjson10_deserializeOpDeleteService) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson10_deserializeOpDeleteServiceTemplateVersion) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson10_deserializeOpDeleteService) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -2953,9 +2953,9 @@ func (m *awsAwsjson10_deserializeOpDeleteServiceTemplateVersion) HandleDeseriali } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson10_deserializeOpErrorDeleteServiceTemplateVersion(response, &metadata) + return out, metadata, awsAwsjson10_deserializeOpErrorDeleteService(response, &metadata) } - output := &DeleteServiceTemplateVersionOutput{} + output := &DeleteServiceOutput{} out.Result = output var buff [1024]byte @@ -2975,7 +2975,7 @@ func (m *awsAwsjson10_deserializeOpDeleteServiceTemplateVersion) HandleDeseriali return out, metadata, err } - err = awsAwsjson10_deserializeOpDocumentDeleteServiceTemplateVersionOutput(&output, shape) + err = awsAwsjson10_deserializeOpDocumentDeleteServiceOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -2989,7 +2989,7 @@ func (m *awsAwsjson10_deserializeOpDeleteServiceTemplateVersion) HandleDeseriali return out, metadata, err } -func awsAwsjson10_deserializeOpErrorDeleteServiceTemplateVersion(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson10_deserializeOpErrorDeleteService(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -3058,14 +3058,14 @@ func awsAwsjson10_deserializeOpErrorDeleteServiceTemplateVersion(response *smith } } -type awsAwsjson10_deserializeOpDeleteTemplateSyncConfig struct { +type awsAwsjson10_deserializeOpDeleteServiceSyncConfig struct { } -func (*awsAwsjson10_deserializeOpDeleteTemplateSyncConfig) ID() string { +func (*awsAwsjson10_deserializeOpDeleteServiceSyncConfig) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson10_deserializeOpDeleteTemplateSyncConfig) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson10_deserializeOpDeleteServiceSyncConfig) 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) @@ -3079,9 +3079,9 @@ func (m *awsAwsjson10_deserializeOpDeleteTemplateSyncConfig) HandleDeserialize(c } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson10_deserializeOpErrorDeleteTemplateSyncConfig(response, &metadata) + return out, metadata, awsAwsjson10_deserializeOpErrorDeleteServiceSyncConfig(response, &metadata) } - output := &DeleteTemplateSyncConfigOutput{} + output := &DeleteServiceSyncConfigOutput{} out.Result = output var buff [1024]byte @@ -3101,7 +3101,7 @@ func (m *awsAwsjson10_deserializeOpDeleteTemplateSyncConfig) HandleDeserialize(c return out, metadata, err } - err = awsAwsjson10_deserializeOpDocumentDeleteTemplateSyncConfigOutput(&output, shape) + err = awsAwsjson10_deserializeOpDocumentDeleteServiceSyncConfigOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -3115,7 +3115,7 @@ func (m *awsAwsjson10_deserializeOpDeleteTemplateSyncConfig) HandleDeserialize(c return out, metadata, err } -func awsAwsjson10_deserializeOpErrorDeleteTemplateSyncConfig(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson10_deserializeOpErrorDeleteServiceSyncConfig(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)} @@ -3184,14 +3184,14 @@ func awsAwsjson10_deserializeOpErrorDeleteTemplateSyncConfig(response *smithyhtt } } -type awsAwsjson10_deserializeOpGetAccountSettings struct { +type awsAwsjson10_deserializeOpDeleteServiceTemplate struct { } -func (*awsAwsjson10_deserializeOpGetAccountSettings) ID() string { +func (*awsAwsjson10_deserializeOpDeleteServiceTemplate) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson10_deserializeOpGetAccountSettings) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson10_deserializeOpDeleteServiceTemplate) 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) @@ -3205,9 +3205,9 @@ func (m *awsAwsjson10_deserializeOpGetAccountSettings) HandleDeserialize(ctx con } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson10_deserializeOpErrorGetAccountSettings(response, &metadata) + return out, metadata, awsAwsjson10_deserializeOpErrorDeleteServiceTemplate(response, &metadata) } - output := &GetAccountSettingsOutput{} + output := &DeleteServiceTemplateOutput{} out.Result = output var buff [1024]byte @@ -3227,7 +3227,7 @@ func (m *awsAwsjson10_deserializeOpGetAccountSettings) HandleDeserialize(ctx con return out, metadata, err } - err = awsAwsjson10_deserializeOpDocumentGetAccountSettingsOutput(&output, shape) + err = awsAwsjson10_deserializeOpDocumentDeleteServiceTemplateOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -3241,7 +3241,7 @@ func (m *awsAwsjson10_deserializeOpGetAccountSettings) HandleDeserialize(ctx con return out, metadata, err } -func awsAwsjson10_deserializeOpErrorGetAccountSettings(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson10_deserializeOpErrorDeleteServiceTemplate(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)} @@ -3285,6 +3285,9 @@ func awsAwsjson10_deserializeOpErrorGetAccountSettings(response *smithyhttp.Resp case strings.EqualFold("AccessDeniedException", errorCode): return awsAwsjson10_deserializeErrorAccessDeniedException(response, errorBody) + case strings.EqualFold("ConflictException", errorCode): + return awsAwsjson10_deserializeErrorConflictException(response, errorBody) + case strings.EqualFold("InternalServerException", errorCode): return awsAwsjson10_deserializeErrorInternalServerException(response, errorBody) @@ -3307,14 +3310,14 @@ func awsAwsjson10_deserializeOpErrorGetAccountSettings(response *smithyhttp.Resp } } -type awsAwsjson10_deserializeOpGetComponent struct { +type awsAwsjson10_deserializeOpDeleteServiceTemplateVersion struct { } -func (*awsAwsjson10_deserializeOpGetComponent) ID() string { +func (*awsAwsjson10_deserializeOpDeleteServiceTemplateVersion) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson10_deserializeOpGetComponent) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson10_deserializeOpDeleteServiceTemplateVersion) 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) @@ -3328,9 +3331,9 @@ func (m *awsAwsjson10_deserializeOpGetComponent) HandleDeserialize(ctx context.C } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson10_deserializeOpErrorGetComponent(response, &metadata) + return out, metadata, awsAwsjson10_deserializeOpErrorDeleteServiceTemplateVersion(response, &metadata) } - output := &GetComponentOutput{} + output := &DeleteServiceTemplateVersionOutput{} out.Result = output var buff [1024]byte @@ -3350,7 +3353,7 @@ func (m *awsAwsjson10_deserializeOpGetComponent) HandleDeserialize(ctx context.C return out, metadata, err } - err = awsAwsjson10_deserializeOpDocumentGetComponentOutput(&output, shape) + err = awsAwsjson10_deserializeOpDocumentDeleteServiceTemplateVersionOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -3364,7 +3367,7 @@ func (m *awsAwsjson10_deserializeOpGetComponent) HandleDeserialize(ctx context.C return out, metadata, err } -func awsAwsjson10_deserializeOpErrorGetComponent(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson10_deserializeOpErrorDeleteServiceTemplateVersion(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)} @@ -3408,6 +3411,9 @@ func awsAwsjson10_deserializeOpErrorGetComponent(response *smithyhttp.Response, case strings.EqualFold("AccessDeniedException", errorCode): return awsAwsjson10_deserializeErrorAccessDeniedException(response, errorBody) + case strings.EqualFold("ConflictException", errorCode): + return awsAwsjson10_deserializeErrorConflictException(response, errorBody) + case strings.EqualFold("InternalServerException", errorCode): return awsAwsjson10_deserializeErrorInternalServerException(response, errorBody) @@ -3430,14 +3436,14 @@ func awsAwsjson10_deserializeOpErrorGetComponent(response *smithyhttp.Response, } } -type awsAwsjson10_deserializeOpGetEnvironment struct { +type awsAwsjson10_deserializeOpDeleteTemplateSyncConfig struct { } -func (*awsAwsjson10_deserializeOpGetEnvironment) ID() string { +func (*awsAwsjson10_deserializeOpDeleteTemplateSyncConfig) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson10_deserializeOpGetEnvironment) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson10_deserializeOpDeleteTemplateSyncConfig) 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) @@ -3451,9 +3457,9 @@ func (m *awsAwsjson10_deserializeOpGetEnvironment) HandleDeserialize(ctx context } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson10_deserializeOpErrorGetEnvironment(response, &metadata) + return out, metadata, awsAwsjson10_deserializeOpErrorDeleteTemplateSyncConfig(response, &metadata) } - output := &GetEnvironmentOutput{} + output := &DeleteTemplateSyncConfigOutput{} out.Result = output var buff [1024]byte @@ -3473,7 +3479,7 @@ func (m *awsAwsjson10_deserializeOpGetEnvironment) HandleDeserialize(ctx context return out, metadata, err } - err = awsAwsjson10_deserializeOpDocumentGetEnvironmentOutput(&output, shape) + err = awsAwsjson10_deserializeOpDocumentDeleteTemplateSyncConfigOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -3487,7 +3493,7 @@ func (m *awsAwsjson10_deserializeOpGetEnvironment) HandleDeserialize(ctx context return out, metadata, err } -func awsAwsjson10_deserializeOpErrorGetEnvironment(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson10_deserializeOpErrorDeleteTemplateSyncConfig(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)} @@ -3531,6 +3537,9 @@ func awsAwsjson10_deserializeOpErrorGetEnvironment(response *smithyhttp.Response case strings.EqualFold("AccessDeniedException", errorCode): return awsAwsjson10_deserializeErrorAccessDeniedException(response, errorBody) + case strings.EqualFold("ConflictException", errorCode): + return awsAwsjson10_deserializeErrorConflictException(response, errorBody) + case strings.EqualFold("InternalServerException", errorCode): return awsAwsjson10_deserializeErrorInternalServerException(response, errorBody) @@ -3553,14 +3562,14 @@ func awsAwsjson10_deserializeOpErrorGetEnvironment(response *smithyhttp.Response } } -type awsAwsjson10_deserializeOpGetEnvironmentAccountConnection struct { +type awsAwsjson10_deserializeOpGetAccountSettings struct { } -func (*awsAwsjson10_deserializeOpGetEnvironmentAccountConnection) ID() string { +func (*awsAwsjson10_deserializeOpGetAccountSettings) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson10_deserializeOpGetEnvironmentAccountConnection) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson10_deserializeOpGetAccountSettings) 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) @@ -3574,9 +3583,9 @@ func (m *awsAwsjson10_deserializeOpGetEnvironmentAccountConnection) HandleDeseri } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson10_deserializeOpErrorGetEnvironmentAccountConnection(response, &metadata) + return out, metadata, awsAwsjson10_deserializeOpErrorGetAccountSettings(response, &metadata) } - output := &GetEnvironmentAccountConnectionOutput{} + output := &GetAccountSettingsOutput{} out.Result = output var buff [1024]byte @@ -3596,7 +3605,7 @@ func (m *awsAwsjson10_deserializeOpGetEnvironmentAccountConnection) HandleDeseri return out, metadata, err } - err = awsAwsjson10_deserializeOpDocumentGetEnvironmentAccountConnectionOutput(&output, shape) + err = awsAwsjson10_deserializeOpDocumentGetAccountSettingsOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -3610,7 +3619,7 @@ func (m *awsAwsjson10_deserializeOpGetEnvironmentAccountConnection) HandleDeseri return out, metadata, err } -func awsAwsjson10_deserializeOpErrorGetEnvironmentAccountConnection(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson10_deserializeOpErrorGetAccountSettings(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)} @@ -3676,14 +3685,14 @@ func awsAwsjson10_deserializeOpErrorGetEnvironmentAccountConnection(response *sm } } -type awsAwsjson10_deserializeOpGetEnvironmentTemplate struct { +type awsAwsjson10_deserializeOpGetComponent struct { } -func (*awsAwsjson10_deserializeOpGetEnvironmentTemplate) ID() string { +func (*awsAwsjson10_deserializeOpGetComponent) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson10_deserializeOpGetEnvironmentTemplate) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson10_deserializeOpGetComponent) 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) @@ -3697,9 +3706,9 @@ func (m *awsAwsjson10_deserializeOpGetEnvironmentTemplate) HandleDeserialize(ctx } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson10_deserializeOpErrorGetEnvironmentTemplate(response, &metadata) + return out, metadata, awsAwsjson10_deserializeOpErrorGetComponent(response, &metadata) } - output := &GetEnvironmentTemplateOutput{} + output := &GetComponentOutput{} out.Result = output var buff [1024]byte @@ -3719,7 +3728,7 @@ func (m *awsAwsjson10_deserializeOpGetEnvironmentTemplate) HandleDeserialize(ctx return out, metadata, err } - err = awsAwsjson10_deserializeOpDocumentGetEnvironmentTemplateOutput(&output, shape) + err = awsAwsjson10_deserializeOpDocumentGetComponentOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -3733,7 +3742,7 @@ func (m *awsAwsjson10_deserializeOpGetEnvironmentTemplate) HandleDeserialize(ctx return out, metadata, err } -func awsAwsjson10_deserializeOpErrorGetEnvironmentTemplate(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson10_deserializeOpErrorGetComponent(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)} @@ -3799,14 +3808,14 @@ func awsAwsjson10_deserializeOpErrorGetEnvironmentTemplate(response *smithyhttp. } } -type awsAwsjson10_deserializeOpGetEnvironmentTemplateVersion struct { +type awsAwsjson10_deserializeOpGetEnvironment struct { } -func (*awsAwsjson10_deserializeOpGetEnvironmentTemplateVersion) ID() string { +func (*awsAwsjson10_deserializeOpGetEnvironment) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson10_deserializeOpGetEnvironmentTemplateVersion) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson10_deserializeOpGetEnvironment) 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) @@ -3820,9 +3829,9 @@ func (m *awsAwsjson10_deserializeOpGetEnvironmentTemplateVersion) HandleDeserial } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson10_deserializeOpErrorGetEnvironmentTemplateVersion(response, &metadata) + return out, metadata, awsAwsjson10_deserializeOpErrorGetEnvironment(response, &metadata) } - output := &GetEnvironmentTemplateVersionOutput{} + output := &GetEnvironmentOutput{} out.Result = output var buff [1024]byte @@ -3842,7 +3851,7 @@ func (m *awsAwsjson10_deserializeOpGetEnvironmentTemplateVersion) HandleDeserial return out, metadata, err } - err = awsAwsjson10_deserializeOpDocumentGetEnvironmentTemplateVersionOutput(&output, shape) + err = awsAwsjson10_deserializeOpDocumentGetEnvironmentOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -3856,7 +3865,7 @@ func (m *awsAwsjson10_deserializeOpGetEnvironmentTemplateVersion) HandleDeserial return out, metadata, err } -func awsAwsjson10_deserializeOpErrorGetEnvironmentTemplateVersion(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson10_deserializeOpErrorGetEnvironment(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)} @@ -3922,14 +3931,14 @@ func awsAwsjson10_deserializeOpErrorGetEnvironmentTemplateVersion(response *smit } } -type awsAwsjson10_deserializeOpGetRepository struct { +type awsAwsjson10_deserializeOpGetEnvironmentAccountConnection struct { } -func (*awsAwsjson10_deserializeOpGetRepository) ID() string { +func (*awsAwsjson10_deserializeOpGetEnvironmentAccountConnection) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson10_deserializeOpGetRepository) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson10_deserializeOpGetEnvironmentAccountConnection) 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) @@ -3943,9 +3952,9 @@ func (m *awsAwsjson10_deserializeOpGetRepository) HandleDeserialize(ctx context. } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson10_deserializeOpErrorGetRepository(response, &metadata) + return out, metadata, awsAwsjson10_deserializeOpErrorGetEnvironmentAccountConnection(response, &metadata) } - output := &GetRepositoryOutput{} + output := &GetEnvironmentAccountConnectionOutput{} out.Result = output var buff [1024]byte @@ -3965,7 +3974,7 @@ func (m *awsAwsjson10_deserializeOpGetRepository) HandleDeserialize(ctx context. return out, metadata, err } - err = awsAwsjson10_deserializeOpDocumentGetRepositoryOutput(&output, shape) + err = awsAwsjson10_deserializeOpDocumentGetEnvironmentAccountConnectionOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -3979,7 +3988,7 @@ func (m *awsAwsjson10_deserializeOpGetRepository) HandleDeserialize(ctx context. return out, metadata, err } -func awsAwsjson10_deserializeOpErrorGetRepository(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson10_deserializeOpErrorGetEnvironmentAccountConnection(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)} @@ -4045,14 +4054,14 @@ func awsAwsjson10_deserializeOpErrorGetRepository(response *smithyhttp.Response, } } -type awsAwsjson10_deserializeOpGetRepositorySyncStatus struct { +type awsAwsjson10_deserializeOpGetEnvironmentTemplate struct { } -func (*awsAwsjson10_deserializeOpGetRepositorySyncStatus) ID() string { +func (*awsAwsjson10_deserializeOpGetEnvironmentTemplate) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson10_deserializeOpGetRepositorySyncStatus) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson10_deserializeOpGetEnvironmentTemplate) 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) @@ -4066,9 +4075,9 @@ func (m *awsAwsjson10_deserializeOpGetRepositorySyncStatus) HandleDeserialize(ct } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson10_deserializeOpErrorGetRepositorySyncStatus(response, &metadata) + return out, metadata, awsAwsjson10_deserializeOpErrorGetEnvironmentTemplate(response, &metadata) } - output := &GetRepositorySyncStatusOutput{} + output := &GetEnvironmentTemplateOutput{} out.Result = output var buff [1024]byte @@ -4088,7 +4097,7 @@ func (m *awsAwsjson10_deserializeOpGetRepositorySyncStatus) HandleDeserialize(ct return out, metadata, err } - err = awsAwsjson10_deserializeOpDocumentGetRepositorySyncStatusOutput(&output, shape) + err = awsAwsjson10_deserializeOpDocumentGetEnvironmentTemplateOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -4102,7 +4111,7 @@ func (m *awsAwsjson10_deserializeOpGetRepositorySyncStatus) HandleDeserialize(ct return out, metadata, err } -func awsAwsjson10_deserializeOpErrorGetRepositorySyncStatus(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson10_deserializeOpErrorGetEnvironmentTemplate(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)} @@ -4168,14 +4177,14 @@ func awsAwsjson10_deserializeOpErrorGetRepositorySyncStatus(response *smithyhttp } } -type awsAwsjson10_deserializeOpGetResourcesSummary struct { +type awsAwsjson10_deserializeOpGetEnvironmentTemplateVersion struct { } -func (*awsAwsjson10_deserializeOpGetResourcesSummary) ID() string { +func (*awsAwsjson10_deserializeOpGetEnvironmentTemplateVersion) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson10_deserializeOpGetResourcesSummary) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson10_deserializeOpGetEnvironmentTemplateVersion) 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) @@ -4189,9 +4198,9 @@ func (m *awsAwsjson10_deserializeOpGetResourcesSummary) HandleDeserialize(ctx co } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson10_deserializeOpErrorGetResourcesSummary(response, &metadata) + return out, metadata, awsAwsjson10_deserializeOpErrorGetEnvironmentTemplateVersion(response, &metadata) } - output := &GetResourcesSummaryOutput{} + output := &GetEnvironmentTemplateVersionOutput{} out.Result = output var buff [1024]byte @@ -4211,7 +4220,7 @@ func (m *awsAwsjson10_deserializeOpGetResourcesSummary) HandleDeserialize(ctx co return out, metadata, err } - err = awsAwsjson10_deserializeOpDocumentGetResourcesSummaryOutput(&output, shape) + err = awsAwsjson10_deserializeOpDocumentGetEnvironmentTemplateVersionOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -4225,7 +4234,7 @@ func (m *awsAwsjson10_deserializeOpGetResourcesSummary) HandleDeserialize(ctx co return out, metadata, err } -func awsAwsjson10_deserializeOpErrorGetResourcesSummary(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson10_deserializeOpErrorGetEnvironmentTemplateVersion(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)} @@ -4272,6 +4281,9 @@ func awsAwsjson10_deserializeOpErrorGetResourcesSummary(response *smithyhttp.Res case strings.EqualFold("InternalServerException", errorCode): return awsAwsjson10_deserializeErrorInternalServerException(response, errorBody) + case strings.EqualFold("ResourceNotFoundException", errorCode): + return awsAwsjson10_deserializeErrorResourceNotFoundException(response, errorBody) + case strings.EqualFold("ThrottlingException", errorCode): return awsAwsjson10_deserializeErrorThrottlingException(response, errorBody) @@ -4288,14 +4300,14 @@ func awsAwsjson10_deserializeOpErrorGetResourcesSummary(response *smithyhttp.Res } } -type awsAwsjson10_deserializeOpGetService struct { +type awsAwsjson10_deserializeOpGetRepository struct { } -func (*awsAwsjson10_deserializeOpGetService) ID() string { +func (*awsAwsjson10_deserializeOpGetRepository) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson10_deserializeOpGetService) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson10_deserializeOpGetRepository) 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) @@ -4309,9 +4321,9 @@ func (m *awsAwsjson10_deserializeOpGetService) HandleDeserialize(ctx context.Con } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson10_deserializeOpErrorGetService(response, &metadata) + return out, metadata, awsAwsjson10_deserializeOpErrorGetRepository(response, &metadata) } - output := &GetServiceOutput{} + output := &GetRepositoryOutput{} out.Result = output var buff [1024]byte @@ -4331,7 +4343,7 @@ func (m *awsAwsjson10_deserializeOpGetService) HandleDeserialize(ctx context.Con return out, metadata, err } - err = awsAwsjson10_deserializeOpDocumentGetServiceOutput(&output, shape) + err = awsAwsjson10_deserializeOpDocumentGetRepositoryOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -4345,7 +4357,7 @@ func (m *awsAwsjson10_deserializeOpGetService) HandleDeserialize(ctx context.Con return out, metadata, err } -func awsAwsjson10_deserializeOpErrorGetService(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson10_deserializeOpErrorGetRepository(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)} @@ -4411,14 +4423,14 @@ func awsAwsjson10_deserializeOpErrorGetService(response *smithyhttp.Response, me } } -type awsAwsjson10_deserializeOpGetServiceInstance struct { +type awsAwsjson10_deserializeOpGetRepositorySyncStatus struct { } -func (*awsAwsjson10_deserializeOpGetServiceInstance) ID() string { +func (*awsAwsjson10_deserializeOpGetRepositorySyncStatus) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson10_deserializeOpGetServiceInstance) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson10_deserializeOpGetRepositorySyncStatus) 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) @@ -4432,9 +4444,9 @@ func (m *awsAwsjson10_deserializeOpGetServiceInstance) HandleDeserialize(ctx con } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson10_deserializeOpErrorGetServiceInstance(response, &metadata) + return out, metadata, awsAwsjson10_deserializeOpErrorGetRepositorySyncStatus(response, &metadata) } - output := &GetServiceInstanceOutput{} + output := &GetRepositorySyncStatusOutput{} out.Result = output var buff [1024]byte @@ -4454,7 +4466,7 @@ func (m *awsAwsjson10_deserializeOpGetServiceInstance) HandleDeserialize(ctx con return out, metadata, err } - err = awsAwsjson10_deserializeOpDocumentGetServiceInstanceOutput(&output, shape) + err = awsAwsjson10_deserializeOpDocumentGetRepositorySyncStatusOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -4468,7 +4480,7 @@ func (m *awsAwsjson10_deserializeOpGetServiceInstance) HandleDeserialize(ctx con return out, metadata, err } -func awsAwsjson10_deserializeOpErrorGetServiceInstance(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson10_deserializeOpErrorGetRepositorySyncStatus(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)} @@ -4534,14 +4546,14 @@ func awsAwsjson10_deserializeOpErrorGetServiceInstance(response *smithyhttp.Resp } } -type awsAwsjson10_deserializeOpGetServiceTemplate struct { +type awsAwsjson10_deserializeOpGetResourcesSummary struct { } -func (*awsAwsjson10_deserializeOpGetServiceTemplate) ID() string { +func (*awsAwsjson10_deserializeOpGetResourcesSummary) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson10_deserializeOpGetServiceTemplate) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson10_deserializeOpGetResourcesSummary) 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) @@ -4555,9 +4567,9 @@ func (m *awsAwsjson10_deserializeOpGetServiceTemplate) HandleDeserialize(ctx con } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson10_deserializeOpErrorGetServiceTemplate(response, &metadata) + return out, metadata, awsAwsjson10_deserializeOpErrorGetResourcesSummary(response, &metadata) } - output := &GetServiceTemplateOutput{} + output := &GetResourcesSummaryOutput{} out.Result = output var buff [1024]byte @@ -4577,7 +4589,7 @@ func (m *awsAwsjson10_deserializeOpGetServiceTemplate) HandleDeserialize(ctx con return out, metadata, err } - err = awsAwsjson10_deserializeOpDocumentGetServiceTemplateOutput(&output, shape) + err = awsAwsjson10_deserializeOpDocumentGetResourcesSummaryOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -4591,7 +4603,7 @@ func (m *awsAwsjson10_deserializeOpGetServiceTemplate) HandleDeserialize(ctx con return out, metadata, err } -func awsAwsjson10_deserializeOpErrorGetServiceTemplate(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson10_deserializeOpErrorGetResourcesSummary(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)} @@ -4638,9 +4650,6 @@ func awsAwsjson10_deserializeOpErrorGetServiceTemplate(response *smithyhttp.Resp case strings.EqualFold("InternalServerException", errorCode): return awsAwsjson10_deserializeErrorInternalServerException(response, errorBody) - case strings.EqualFold("ResourceNotFoundException", errorCode): - return awsAwsjson10_deserializeErrorResourceNotFoundException(response, errorBody) - case strings.EqualFold("ThrottlingException", errorCode): return awsAwsjson10_deserializeErrorThrottlingException(response, errorBody) @@ -4657,14 +4666,14 @@ func awsAwsjson10_deserializeOpErrorGetServiceTemplate(response *smithyhttp.Resp } } -type awsAwsjson10_deserializeOpGetServiceTemplateVersion struct { +type awsAwsjson10_deserializeOpGetService struct { } -func (*awsAwsjson10_deserializeOpGetServiceTemplateVersion) ID() string { +func (*awsAwsjson10_deserializeOpGetService) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson10_deserializeOpGetServiceTemplateVersion) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson10_deserializeOpGetService) 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) @@ -4678,9 +4687,9 @@ func (m *awsAwsjson10_deserializeOpGetServiceTemplateVersion) HandleDeserialize( } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson10_deserializeOpErrorGetServiceTemplateVersion(response, &metadata) + return out, metadata, awsAwsjson10_deserializeOpErrorGetService(response, &metadata) } - output := &GetServiceTemplateVersionOutput{} + output := &GetServiceOutput{} out.Result = output var buff [1024]byte @@ -4700,7 +4709,7 @@ func (m *awsAwsjson10_deserializeOpGetServiceTemplateVersion) HandleDeserialize( return out, metadata, err } - err = awsAwsjson10_deserializeOpDocumentGetServiceTemplateVersionOutput(&output, shape) + err = awsAwsjson10_deserializeOpDocumentGetServiceOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -4714,7 +4723,7 @@ func (m *awsAwsjson10_deserializeOpGetServiceTemplateVersion) HandleDeserialize( return out, metadata, err } -func awsAwsjson10_deserializeOpErrorGetServiceTemplateVersion(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson10_deserializeOpErrorGetService(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)} @@ -4780,14 +4789,14 @@ func awsAwsjson10_deserializeOpErrorGetServiceTemplateVersion(response *smithyht } } -type awsAwsjson10_deserializeOpGetTemplateSyncConfig struct { +type awsAwsjson10_deserializeOpGetServiceInstance struct { } -func (*awsAwsjson10_deserializeOpGetTemplateSyncConfig) ID() string { +func (*awsAwsjson10_deserializeOpGetServiceInstance) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson10_deserializeOpGetTemplateSyncConfig) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson10_deserializeOpGetServiceInstance) 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) @@ -4801,9 +4810,9 @@ func (m *awsAwsjson10_deserializeOpGetTemplateSyncConfig) HandleDeserialize(ctx } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson10_deserializeOpErrorGetTemplateSyncConfig(response, &metadata) + return out, metadata, awsAwsjson10_deserializeOpErrorGetServiceInstance(response, &metadata) } - output := &GetTemplateSyncConfigOutput{} + output := &GetServiceInstanceOutput{} out.Result = output var buff [1024]byte @@ -4823,7 +4832,7 @@ func (m *awsAwsjson10_deserializeOpGetTemplateSyncConfig) HandleDeserialize(ctx return out, metadata, err } - err = awsAwsjson10_deserializeOpDocumentGetTemplateSyncConfigOutput(&output, shape) + err = awsAwsjson10_deserializeOpDocumentGetServiceInstanceOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -4837,7 +4846,7 @@ func (m *awsAwsjson10_deserializeOpGetTemplateSyncConfig) HandleDeserialize(ctx return out, metadata, err } -func awsAwsjson10_deserializeOpErrorGetTemplateSyncConfig(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson10_deserializeOpErrorGetServiceInstance(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)} @@ -4903,14 +4912,14 @@ func awsAwsjson10_deserializeOpErrorGetTemplateSyncConfig(response *smithyhttp.R } } -type awsAwsjson10_deserializeOpGetTemplateSyncStatus struct { +type awsAwsjson10_deserializeOpGetServiceInstanceSyncStatus struct { } -func (*awsAwsjson10_deserializeOpGetTemplateSyncStatus) ID() string { +func (*awsAwsjson10_deserializeOpGetServiceInstanceSyncStatus) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson10_deserializeOpGetTemplateSyncStatus) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson10_deserializeOpGetServiceInstanceSyncStatus) 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) @@ -4924,9 +4933,9 @@ func (m *awsAwsjson10_deserializeOpGetTemplateSyncStatus) HandleDeserialize(ctx } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson10_deserializeOpErrorGetTemplateSyncStatus(response, &metadata) + return out, metadata, awsAwsjson10_deserializeOpErrorGetServiceInstanceSyncStatus(response, &metadata) } - output := &GetTemplateSyncStatusOutput{} + output := &GetServiceInstanceSyncStatusOutput{} out.Result = output var buff [1024]byte @@ -4946,7 +4955,7 @@ func (m *awsAwsjson10_deserializeOpGetTemplateSyncStatus) HandleDeserialize(ctx return out, metadata, err } - err = awsAwsjson10_deserializeOpDocumentGetTemplateSyncStatusOutput(&output, shape) + err = awsAwsjson10_deserializeOpDocumentGetServiceInstanceSyncStatusOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -4960,7 +4969,7 @@ func (m *awsAwsjson10_deserializeOpGetTemplateSyncStatus) HandleDeserialize(ctx return out, metadata, err } -func awsAwsjson10_deserializeOpErrorGetTemplateSyncStatus(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson10_deserializeOpErrorGetServiceInstanceSyncStatus(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)} @@ -5026,14 +5035,14 @@ func awsAwsjson10_deserializeOpErrorGetTemplateSyncStatus(response *smithyhttp.R } } -type awsAwsjson10_deserializeOpListComponentOutputs struct { +type awsAwsjson10_deserializeOpGetServiceSyncBlockerSummary struct { } -func (*awsAwsjson10_deserializeOpListComponentOutputs) ID() string { +func (*awsAwsjson10_deserializeOpGetServiceSyncBlockerSummary) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson10_deserializeOpListComponentOutputs) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson10_deserializeOpGetServiceSyncBlockerSummary) 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) @@ -5047,9 +5056,9 @@ func (m *awsAwsjson10_deserializeOpListComponentOutputs) HandleDeserialize(ctx c } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson10_deserializeOpErrorListComponentOutputs(response, &metadata) + return out, metadata, awsAwsjson10_deserializeOpErrorGetServiceSyncBlockerSummary(response, &metadata) } - output := &ListComponentOutputsOutput{} + output := &GetServiceSyncBlockerSummaryOutput{} out.Result = output var buff [1024]byte @@ -5069,7 +5078,7 @@ func (m *awsAwsjson10_deserializeOpListComponentOutputs) HandleDeserialize(ctx c return out, metadata, err } - err = awsAwsjson10_deserializeOpDocumentListComponentOutputsOutput(&output, shape) + err = awsAwsjson10_deserializeOpDocumentGetServiceSyncBlockerSummaryOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -5083,7 +5092,7 @@ func (m *awsAwsjson10_deserializeOpListComponentOutputs) HandleDeserialize(ctx c return out, metadata, err } -func awsAwsjson10_deserializeOpErrorListComponentOutputs(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson10_deserializeOpErrorGetServiceSyncBlockerSummary(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)} @@ -5149,14 +5158,14 @@ func awsAwsjson10_deserializeOpErrorListComponentOutputs(response *smithyhttp.Re } } -type awsAwsjson10_deserializeOpListComponentProvisionedResources struct { +type awsAwsjson10_deserializeOpGetServiceSyncConfig struct { } -func (*awsAwsjson10_deserializeOpListComponentProvisionedResources) ID() string { +func (*awsAwsjson10_deserializeOpGetServiceSyncConfig) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson10_deserializeOpListComponentProvisionedResources) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson10_deserializeOpGetServiceSyncConfig) 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) @@ -5170,9 +5179,9 @@ func (m *awsAwsjson10_deserializeOpListComponentProvisionedResources) HandleDese } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson10_deserializeOpErrorListComponentProvisionedResources(response, &metadata) + return out, metadata, awsAwsjson10_deserializeOpErrorGetServiceSyncConfig(response, &metadata) } - output := &ListComponentProvisionedResourcesOutput{} + output := &GetServiceSyncConfigOutput{} out.Result = output var buff [1024]byte @@ -5192,7 +5201,7 @@ func (m *awsAwsjson10_deserializeOpListComponentProvisionedResources) HandleDese return out, metadata, err } - err = awsAwsjson10_deserializeOpDocumentListComponentProvisionedResourcesOutput(&output, shape) + err = awsAwsjson10_deserializeOpDocumentGetServiceSyncConfigOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -5206,7 +5215,7 @@ func (m *awsAwsjson10_deserializeOpListComponentProvisionedResources) HandleDese return out, metadata, err } -func awsAwsjson10_deserializeOpErrorListComponentProvisionedResources(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson10_deserializeOpErrorGetServiceSyncConfig(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)} @@ -5272,14 +5281,14 @@ func awsAwsjson10_deserializeOpErrorListComponentProvisionedResources(response * } } -type awsAwsjson10_deserializeOpListComponents struct { +type awsAwsjson10_deserializeOpGetServiceTemplate struct { } -func (*awsAwsjson10_deserializeOpListComponents) ID() string { +func (*awsAwsjson10_deserializeOpGetServiceTemplate) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson10_deserializeOpListComponents) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson10_deserializeOpGetServiceTemplate) 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) @@ -5293,9 +5302,9 @@ func (m *awsAwsjson10_deserializeOpListComponents) HandleDeserialize(ctx context } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson10_deserializeOpErrorListComponents(response, &metadata) + return out, metadata, awsAwsjson10_deserializeOpErrorGetServiceTemplate(response, &metadata) } - output := &ListComponentsOutput{} + output := &GetServiceTemplateOutput{} out.Result = output var buff [1024]byte @@ -5315,7 +5324,7 @@ func (m *awsAwsjson10_deserializeOpListComponents) HandleDeserialize(ctx context return out, metadata, err } - err = awsAwsjson10_deserializeOpDocumentListComponentsOutput(&output, shape) + err = awsAwsjson10_deserializeOpDocumentGetServiceTemplateOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -5329,7 +5338,7 @@ func (m *awsAwsjson10_deserializeOpListComponents) HandleDeserialize(ctx context return out, metadata, err } -func awsAwsjson10_deserializeOpErrorListComponents(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson10_deserializeOpErrorGetServiceTemplate(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)} @@ -5376,6 +5385,9 @@ func awsAwsjson10_deserializeOpErrorListComponents(response *smithyhttp.Response case strings.EqualFold("InternalServerException", errorCode): return awsAwsjson10_deserializeErrorInternalServerException(response, errorBody) + case strings.EqualFold("ResourceNotFoundException", errorCode): + return awsAwsjson10_deserializeErrorResourceNotFoundException(response, errorBody) + case strings.EqualFold("ThrottlingException", errorCode): return awsAwsjson10_deserializeErrorThrottlingException(response, errorBody) @@ -5392,14 +5404,14 @@ func awsAwsjson10_deserializeOpErrorListComponents(response *smithyhttp.Response } } -type awsAwsjson10_deserializeOpListEnvironmentAccountConnections struct { +type awsAwsjson10_deserializeOpGetServiceTemplateVersion struct { } -func (*awsAwsjson10_deserializeOpListEnvironmentAccountConnections) ID() string { +func (*awsAwsjson10_deserializeOpGetServiceTemplateVersion) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson10_deserializeOpListEnvironmentAccountConnections) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson10_deserializeOpGetServiceTemplateVersion) 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) @@ -5413,9 +5425,9 @@ func (m *awsAwsjson10_deserializeOpListEnvironmentAccountConnections) HandleDese } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson10_deserializeOpErrorListEnvironmentAccountConnections(response, &metadata) + return out, metadata, awsAwsjson10_deserializeOpErrorGetServiceTemplateVersion(response, &metadata) } - output := &ListEnvironmentAccountConnectionsOutput{} + output := &GetServiceTemplateVersionOutput{} out.Result = output var buff [1024]byte @@ -5435,7 +5447,7 @@ func (m *awsAwsjson10_deserializeOpListEnvironmentAccountConnections) HandleDese return out, metadata, err } - err = awsAwsjson10_deserializeOpDocumentListEnvironmentAccountConnectionsOutput(&output, shape) + err = awsAwsjson10_deserializeOpDocumentGetServiceTemplateVersionOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -5449,7 +5461,7 @@ func (m *awsAwsjson10_deserializeOpListEnvironmentAccountConnections) HandleDese return out, metadata, err } -func awsAwsjson10_deserializeOpErrorListEnvironmentAccountConnections(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson10_deserializeOpErrorGetServiceTemplateVersion(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)} @@ -5496,6 +5508,9 @@ func awsAwsjson10_deserializeOpErrorListEnvironmentAccountConnections(response * case strings.EqualFold("InternalServerException", errorCode): return awsAwsjson10_deserializeErrorInternalServerException(response, errorBody) + case strings.EqualFold("ResourceNotFoundException", errorCode): + return awsAwsjson10_deserializeErrorResourceNotFoundException(response, errorBody) + case strings.EqualFold("ThrottlingException", errorCode): return awsAwsjson10_deserializeErrorThrottlingException(response, errorBody) @@ -5512,14 +5527,14 @@ func awsAwsjson10_deserializeOpErrorListEnvironmentAccountConnections(response * } } -type awsAwsjson10_deserializeOpListEnvironmentOutputs struct { +type awsAwsjson10_deserializeOpGetTemplateSyncConfig struct { } -func (*awsAwsjson10_deserializeOpListEnvironmentOutputs) ID() string { +func (*awsAwsjson10_deserializeOpGetTemplateSyncConfig) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson10_deserializeOpListEnvironmentOutputs) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson10_deserializeOpGetTemplateSyncConfig) 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) @@ -5533,9 +5548,9 @@ func (m *awsAwsjson10_deserializeOpListEnvironmentOutputs) HandleDeserialize(ctx } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson10_deserializeOpErrorListEnvironmentOutputs(response, &metadata) + return out, metadata, awsAwsjson10_deserializeOpErrorGetTemplateSyncConfig(response, &metadata) } - output := &ListEnvironmentOutputsOutput{} + output := &GetTemplateSyncConfigOutput{} out.Result = output var buff [1024]byte @@ -5555,7 +5570,7 @@ func (m *awsAwsjson10_deserializeOpListEnvironmentOutputs) HandleDeserialize(ctx return out, metadata, err } - err = awsAwsjson10_deserializeOpDocumentListEnvironmentOutputsOutput(&output, shape) + err = awsAwsjson10_deserializeOpDocumentGetTemplateSyncConfigOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -5569,7 +5584,7 @@ func (m *awsAwsjson10_deserializeOpListEnvironmentOutputs) HandleDeserialize(ctx return out, metadata, err } -func awsAwsjson10_deserializeOpErrorListEnvironmentOutputs(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson10_deserializeOpErrorGetTemplateSyncConfig(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)} @@ -5635,14 +5650,14 @@ func awsAwsjson10_deserializeOpErrorListEnvironmentOutputs(response *smithyhttp. } } -type awsAwsjson10_deserializeOpListEnvironmentProvisionedResources struct { +type awsAwsjson10_deserializeOpGetTemplateSyncStatus struct { } -func (*awsAwsjson10_deserializeOpListEnvironmentProvisionedResources) ID() string { +func (*awsAwsjson10_deserializeOpGetTemplateSyncStatus) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson10_deserializeOpListEnvironmentProvisionedResources) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson10_deserializeOpGetTemplateSyncStatus) 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) @@ -5656,9 +5671,9 @@ func (m *awsAwsjson10_deserializeOpListEnvironmentProvisionedResources) HandleDe } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson10_deserializeOpErrorListEnvironmentProvisionedResources(response, &metadata) + return out, metadata, awsAwsjson10_deserializeOpErrorGetTemplateSyncStatus(response, &metadata) } - output := &ListEnvironmentProvisionedResourcesOutput{} + output := &GetTemplateSyncStatusOutput{} out.Result = output var buff [1024]byte @@ -5678,7 +5693,7 @@ func (m *awsAwsjson10_deserializeOpListEnvironmentProvisionedResources) HandleDe return out, metadata, err } - err = awsAwsjson10_deserializeOpDocumentListEnvironmentProvisionedResourcesOutput(&output, shape) + err = awsAwsjson10_deserializeOpDocumentGetTemplateSyncStatusOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -5692,7 +5707,7 @@ func (m *awsAwsjson10_deserializeOpListEnvironmentProvisionedResources) HandleDe return out, metadata, err } -func awsAwsjson10_deserializeOpErrorListEnvironmentProvisionedResources(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson10_deserializeOpErrorGetTemplateSyncStatus(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)} @@ -5758,14 +5773,14 @@ func awsAwsjson10_deserializeOpErrorListEnvironmentProvisionedResources(response } } -type awsAwsjson10_deserializeOpListEnvironments struct { +type awsAwsjson10_deserializeOpListComponentOutputs struct { } -func (*awsAwsjson10_deserializeOpListEnvironments) ID() string { +func (*awsAwsjson10_deserializeOpListComponentOutputs) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson10_deserializeOpListEnvironments) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson10_deserializeOpListComponentOutputs) 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) @@ -5779,9 +5794,9 @@ func (m *awsAwsjson10_deserializeOpListEnvironments) HandleDeserialize(ctx conte } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson10_deserializeOpErrorListEnvironments(response, &metadata) + return out, metadata, awsAwsjson10_deserializeOpErrorListComponentOutputs(response, &metadata) } - output := &ListEnvironmentsOutput{} + output := &ListComponentOutputsOutput{} out.Result = output var buff [1024]byte @@ -5801,7 +5816,7 @@ func (m *awsAwsjson10_deserializeOpListEnvironments) HandleDeserialize(ctx conte return out, metadata, err } - err = awsAwsjson10_deserializeOpDocumentListEnvironmentsOutput(&output, shape) + err = awsAwsjson10_deserializeOpDocumentListComponentOutputsOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -5815,7 +5830,7 @@ func (m *awsAwsjson10_deserializeOpListEnvironments) HandleDeserialize(ctx conte return out, metadata, err } -func awsAwsjson10_deserializeOpErrorListEnvironments(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson10_deserializeOpErrorListComponentOutputs(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)} @@ -5881,14 +5896,14 @@ func awsAwsjson10_deserializeOpErrorListEnvironments(response *smithyhttp.Respon } } -type awsAwsjson10_deserializeOpListEnvironmentTemplates struct { +type awsAwsjson10_deserializeOpListComponentProvisionedResources struct { } -func (*awsAwsjson10_deserializeOpListEnvironmentTemplates) ID() string { +func (*awsAwsjson10_deserializeOpListComponentProvisionedResources) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson10_deserializeOpListEnvironmentTemplates) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson10_deserializeOpListComponentProvisionedResources) 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) @@ -5902,9 +5917,9 @@ func (m *awsAwsjson10_deserializeOpListEnvironmentTemplates) HandleDeserialize(c } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson10_deserializeOpErrorListEnvironmentTemplates(response, &metadata) + return out, metadata, awsAwsjson10_deserializeOpErrorListComponentProvisionedResources(response, &metadata) } - output := &ListEnvironmentTemplatesOutput{} + output := &ListComponentProvisionedResourcesOutput{} out.Result = output var buff [1024]byte @@ -5924,7 +5939,7 @@ func (m *awsAwsjson10_deserializeOpListEnvironmentTemplates) HandleDeserialize(c return out, metadata, err } - err = awsAwsjson10_deserializeOpDocumentListEnvironmentTemplatesOutput(&output, shape) + err = awsAwsjson10_deserializeOpDocumentListComponentProvisionedResourcesOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -5938,7 +5953,7 @@ func (m *awsAwsjson10_deserializeOpListEnvironmentTemplates) HandleDeserialize(c return out, metadata, err } -func awsAwsjson10_deserializeOpErrorListEnvironmentTemplates(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson10_deserializeOpErrorListComponentProvisionedResources(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)} @@ -5985,6 +6000,9 @@ func awsAwsjson10_deserializeOpErrorListEnvironmentTemplates(response *smithyhtt case strings.EqualFold("InternalServerException", errorCode): return awsAwsjson10_deserializeErrorInternalServerException(response, errorBody) + case strings.EqualFold("ResourceNotFoundException", errorCode): + return awsAwsjson10_deserializeErrorResourceNotFoundException(response, errorBody) + case strings.EqualFold("ThrottlingException", errorCode): return awsAwsjson10_deserializeErrorThrottlingException(response, errorBody) @@ -6001,14 +6019,14 @@ func awsAwsjson10_deserializeOpErrorListEnvironmentTemplates(response *smithyhtt } } -type awsAwsjson10_deserializeOpListEnvironmentTemplateVersions struct { +type awsAwsjson10_deserializeOpListComponents struct { } -func (*awsAwsjson10_deserializeOpListEnvironmentTemplateVersions) ID() string { +func (*awsAwsjson10_deserializeOpListComponents) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson10_deserializeOpListEnvironmentTemplateVersions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson10_deserializeOpListComponents) 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) @@ -6022,9 +6040,9 @@ func (m *awsAwsjson10_deserializeOpListEnvironmentTemplateVersions) HandleDeseri } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson10_deserializeOpErrorListEnvironmentTemplateVersions(response, &metadata) + return out, metadata, awsAwsjson10_deserializeOpErrorListComponents(response, &metadata) } - output := &ListEnvironmentTemplateVersionsOutput{} + output := &ListComponentsOutput{} out.Result = output var buff [1024]byte @@ -6044,7 +6062,7 @@ func (m *awsAwsjson10_deserializeOpListEnvironmentTemplateVersions) HandleDeseri return out, metadata, err } - err = awsAwsjson10_deserializeOpDocumentListEnvironmentTemplateVersionsOutput(&output, shape) + err = awsAwsjson10_deserializeOpDocumentListComponentsOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -6058,7 +6076,7 @@ func (m *awsAwsjson10_deserializeOpListEnvironmentTemplateVersions) HandleDeseri return out, metadata, err } -func awsAwsjson10_deserializeOpErrorListEnvironmentTemplateVersions(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson10_deserializeOpErrorListComponents(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)} @@ -6105,9 +6123,6 @@ func awsAwsjson10_deserializeOpErrorListEnvironmentTemplateVersions(response *sm case strings.EqualFold("InternalServerException", errorCode): return awsAwsjson10_deserializeErrorInternalServerException(response, errorBody) - case strings.EqualFold("ResourceNotFoundException", errorCode): - return awsAwsjson10_deserializeErrorResourceNotFoundException(response, errorBody) - case strings.EqualFold("ThrottlingException", errorCode): return awsAwsjson10_deserializeErrorThrottlingException(response, errorBody) @@ -6124,14 +6139,14 @@ func awsAwsjson10_deserializeOpErrorListEnvironmentTemplateVersions(response *sm } } -type awsAwsjson10_deserializeOpListRepositories struct { +type awsAwsjson10_deserializeOpListEnvironmentAccountConnections struct { } -func (*awsAwsjson10_deserializeOpListRepositories) ID() string { +func (*awsAwsjson10_deserializeOpListEnvironmentAccountConnections) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson10_deserializeOpListRepositories) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson10_deserializeOpListEnvironmentAccountConnections) 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) @@ -6145,9 +6160,9 @@ func (m *awsAwsjson10_deserializeOpListRepositories) HandleDeserialize(ctx conte } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson10_deserializeOpErrorListRepositories(response, &metadata) + return out, metadata, awsAwsjson10_deserializeOpErrorListEnvironmentAccountConnections(response, &metadata) } - output := &ListRepositoriesOutput{} + output := &ListEnvironmentAccountConnectionsOutput{} out.Result = output var buff [1024]byte @@ -6167,7 +6182,7 @@ func (m *awsAwsjson10_deserializeOpListRepositories) HandleDeserialize(ctx conte return out, metadata, err } - err = awsAwsjson10_deserializeOpDocumentListRepositoriesOutput(&output, shape) + err = awsAwsjson10_deserializeOpDocumentListEnvironmentAccountConnectionsOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -6181,7 +6196,7 @@ func (m *awsAwsjson10_deserializeOpListRepositories) HandleDeserialize(ctx conte return out, metadata, err } -func awsAwsjson10_deserializeOpErrorListRepositories(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson10_deserializeOpErrorListEnvironmentAccountConnections(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)} @@ -6228,9 +6243,6 @@ func awsAwsjson10_deserializeOpErrorListRepositories(response *smithyhttp.Respon case strings.EqualFold("InternalServerException", errorCode): return awsAwsjson10_deserializeErrorInternalServerException(response, errorBody) - case strings.EqualFold("ResourceNotFoundException", errorCode): - return awsAwsjson10_deserializeErrorResourceNotFoundException(response, errorBody) - case strings.EqualFold("ThrottlingException", errorCode): return awsAwsjson10_deserializeErrorThrottlingException(response, errorBody) @@ -6247,14 +6259,14 @@ func awsAwsjson10_deserializeOpErrorListRepositories(response *smithyhttp.Respon } } -type awsAwsjson10_deserializeOpListRepositorySyncDefinitions struct { +type awsAwsjson10_deserializeOpListEnvironmentOutputs struct { } -func (*awsAwsjson10_deserializeOpListRepositorySyncDefinitions) ID() string { +func (*awsAwsjson10_deserializeOpListEnvironmentOutputs) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson10_deserializeOpListRepositorySyncDefinitions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson10_deserializeOpListEnvironmentOutputs) 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) @@ -6268,9 +6280,9 @@ func (m *awsAwsjson10_deserializeOpListRepositorySyncDefinitions) HandleDeserial } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson10_deserializeOpErrorListRepositorySyncDefinitions(response, &metadata) + return out, metadata, awsAwsjson10_deserializeOpErrorListEnvironmentOutputs(response, &metadata) } - output := &ListRepositorySyncDefinitionsOutput{} + output := &ListEnvironmentOutputsOutput{} out.Result = output var buff [1024]byte @@ -6290,7 +6302,7 @@ func (m *awsAwsjson10_deserializeOpListRepositorySyncDefinitions) HandleDeserial return out, metadata, err } - err = awsAwsjson10_deserializeOpDocumentListRepositorySyncDefinitionsOutput(&output, shape) + err = awsAwsjson10_deserializeOpDocumentListEnvironmentOutputsOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -6304,7 +6316,7 @@ func (m *awsAwsjson10_deserializeOpListRepositorySyncDefinitions) HandleDeserial return out, metadata, err } -func awsAwsjson10_deserializeOpErrorListRepositorySyncDefinitions(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson10_deserializeOpErrorListEnvironmentOutputs(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)} @@ -6351,6 +6363,9 @@ func awsAwsjson10_deserializeOpErrorListRepositorySyncDefinitions(response *smit case strings.EqualFold("InternalServerException", errorCode): return awsAwsjson10_deserializeErrorInternalServerException(response, errorBody) + case strings.EqualFold("ResourceNotFoundException", errorCode): + return awsAwsjson10_deserializeErrorResourceNotFoundException(response, errorBody) + case strings.EqualFold("ThrottlingException", errorCode): return awsAwsjson10_deserializeErrorThrottlingException(response, errorBody) @@ -6367,14 +6382,14 @@ func awsAwsjson10_deserializeOpErrorListRepositorySyncDefinitions(response *smit } } -type awsAwsjson10_deserializeOpListServiceInstanceOutputs struct { +type awsAwsjson10_deserializeOpListEnvironmentProvisionedResources struct { } -func (*awsAwsjson10_deserializeOpListServiceInstanceOutputs) ID() string { +func (*awsAwsjson10_deserializeOpListEnvironmentProvisionedResources) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson10_deserializeOpListServiceInstanceOutputs) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson10_deserializeOpListEnvironmentProvisionedResources) 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) @@ -6388,9 +6403,9 @@ func (m *awsAwsjson10_deserializeOpListServiceInstanceOutputs) HandleDeserialize } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson10_deserializeOpErrorListServiceInstanceOutputs(response, &metadata) + return out, metadata, awsAwsjson10_deserializeOpErrorListEnvironmentProvisionedResources(response, &metadata) } - output := &ListServiceInstanceOutputsOutput{} + output := &ListEnvironmentProvisionedResourcesOutput{} out.Result = output var buff [1024]byte @@ -6410,7 +6425,7 @@ func (m *awsAwsjson10_deserializeOpListServiceInstanceOutputs) HandleDeserialize return out, metadata, err } - err = awsAwsjson10_deserializeOpDocumentListServiceInstanceOutputsOutput(&output, shape) + err = awsAwsjson10_deserializeOpDocumentListEnvironmentProvisionedResourcesOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -6424,7 +6439,7 @@ func (m *awsAwsjson10_deserializeOpListServiceInstanceOutputs) HandleDeserialize return out, metadata, err } -func awsAwsjson10_deserializeOpErrorListServiceInstanceOutputs(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson10_deserializeOpErrorListEnvironmentProvisionedResources(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)} @@ -6490,14 +6505,14 @@ func awsAwsjson10_deserializeOpErrorListServiceInstanceOutputs(response *smithyh } } -type awsAwsjson10_deserializeOpListServiceInstanceProvisionedResources struct { +type awsAwsjson10_deserializeOpListEnvironments struct { } -func (*awsAwsjson10_deserializeOpListServiceInstanceProvisionedResources) ID() string { +func (*awsAwsjson10_deserializeOpListEnvironments) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson10_deserializeOpListServiceInstanceProvisionedResources) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson10_deserializeOpListEnvironments) 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) @@ -6511,9 +6526,9 @@ func (m *awsAwsjson10_deserializeOpListServiceInstanceProvisionedResources) Hand } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson10_deserializeOpErrorListServiceInstanceProvisionedResources(response, &metadata) + return out, metadata, awsAwsjson10_deserializeOpErrorListEnvironments(response, &metadata) } - output := &ListServiceInstanceProvisionedResourcesOutput{} + output := &ListEnvironmentsOutput{} out.Result = output var buff [1024]byte @@ -6533,7 +6548,7 @@ func (m *awsAwsjson10_deserializeOpListServiceInstanceProvisionedResources) Hand return out, metadata, err } - err = awsAwsjson10_deserializeOpDocumentListServiceInstanceProvisionedResourcesOutput(&output, shape) + err = awsAwsjson10_deserializeOpDocumentListEnvironmentsOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -6547,7 +6562,7 @@ func (m *awsAwsjson10_deserializeOpListServiceInstanceProvisionedResources) Hand return out, metadata, err } -func awsAwsjson10_deserializeOpErrorListServiceInstanceProvisionedResources(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson10_deserializeOpErrorListEnvironments(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)} @@ -6613,14 +6628,14 @@ func awsAwsjson10_deserializeOpErrorListServiceInstanceProvisionedResources(resp } } -type awsAwsjson10_deserializeOpListServiceInstances struct { +type awsAwsjson10_deserializeOpListEnvironmentTemplates struct { } -func (*awsAwsjson10_deserializeOpListServiceInstances) ID() string { +func (*awsAwsjson10_deserializeOpListEnvironmentTemplates) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson10_deserializeOpListServiceInstances) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson10_deserializeOpListEnvironmentTemplates) 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) @@ -6634,9 +6649,9 @@ func (m *awsAwsjson10_deserializeOpListServiceInstances) HandleDeserialize(ctx c } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson10_deserializeOpErrorListServiceInstances(response, &metadata) + return out, metadata, awsAwsjson10_deserializeOpErrorListEnvironmentTemplates(response, &metadata) } - output := &ListServiceInstancesOutput{} + output := &ListEnvironmentTemplatesOutput{} out.Result = output var buff [1024]byte @@ -6656,7 +6671,7 @@ func (m *awsAwsjson10_deserializeOpListServiceInstances) HandleDeserialize(ctx c return out, metadata, err } - err = awsAwsjson10_deserializeOpDocumentListServiceInstancesOutput(&output, shape) + err = awsAwsjson10_deserializeOpDocumentListEnvironmentTemplatesOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -6670,7 +6685,7 @@ func (m *awsAwsjson10_deserializeOpListServiceInstances) HandleDeserialize(ctx c return out, metadata, err } -func awsAwsjson10_deserializeOpErrorListServiceInstances(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson10_deserializeOpErrorListEnvironmentTemplates(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)} @@ -6717,9 +6732,6 @@ func awsAwsjson10_deserializeOpErrorListServiceInstances(response *smithyhttp.Re case strings.EqualFold("InternalServerException", errorCode): return awsAwsjson10_deserializeErrorInternalServerException(response, errorBody) - case strings.EqualFold("ResourceNotFoundException", errorCode): - return awsAwsjson10_deserializeErrorResourceNotFoundException(response, errorBody) - case strings.EqualFold("ThrottlingException", errorCode): return awsAwsjson10_deserializeErrorThrottlingException(response, errorBody) @@ -6736,14 +6748,14 @@ func awsAwsjson10_deserializeOpErrorListServiceInstances(response *smithyhttp.Re } } -type awsAwsjson10_deserializeOpListServicePipelineOutputs struct { +type awsAwsjson10_deserializeOpListEnvironmentTemplateVersions struct { } -func (*awsAwsjson10_deserializeOpListServicePipelineOutputs) ID() string { +func (*awsAwsjson10_deserializeOpListEnvironmentTemplateVersions) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson10_deserializeOpListServicePipelineOutputs) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson10_deserializeOpListEnvironmentTemplateVersions) 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) @@ -6757,9 +6769,9 @@ func (m *awsAwsjson10_deserializeOpListServicePipelineOutputs) HandleDeserialize } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson10_deserializeOpErrorListServicePipelineOutputs(response, &metadata) + return out, metadata, awsAwsjson10_deserializeOpErrorListEnvironmentTemplateVersions(response, &metadata) } - output := &ListServicePipelineOutputsOutput{} + output := &ListEnvironmentTemplateVersionsOutput{} out.Result = output var buff [1024]byte @@ -6779,7 +6791,7 @@ func (m *awsAwsjson10_deserializeOpListServicePipelineOutputs) HandleDeserialize return out, metadata, err } - err = awsAwsjson10_deserializeOpDocumentListServicePipelineOutputsOutput(&output, shape) + err = awsAwsjson10_deserializeOpDocumentListEnvironmentTemplateVersionsOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -6793,7 +6805,7 @@ func (m *awsAwsjson10_deserializeOpListServicePipelineOutputs) HandleDeserialize return out, metadata, err } -func awsAwsjson10_deserializeOpErrorListServicePipelineOutputs(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson10_deserializeOpErrorListEnvironmentTemplateVersions(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)} @@ -6859,14 +6871,14 @@ func awsAwsjson10_deserializeOpErrorListServicePipelineOutputs(response *smithyh } } -type awsAwsjson10_deserializeOpListServicePipelineProvisionedResources struct { +type awsAwsjson10_deserializeOpListRepositories struct { } -func (*awsAwsjson10_deserializeOpListServicePipelineProvisionedResources) ID() string { +func (*awsAwsjson10_deserializeOpListRepositories) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson10_deserializeOpListServicePipelineProvisionedResources) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson10_deserializeOpListRepositories) 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) @@ -6880,9 +6892,9 @@ func (m *awsAwsjson10_deserializeOpListServicePipelineProvisionedResources) Hand } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson10_deserializeOpErrorListServicePipelineProvisionedResources(response, &metadata) + return out, metadata, awsAwsjson10_deserializeOpErrorListRepositories(response, &metadata) } - output := &ListServicePipelineProvisionedResourcesOutput{} + output := &ListRepositoriesOutput{} out.Result = output var buff [1024]byte @@ -6902,7 +6914,7 @@ func (m *awsAwsjson10_deserializeOpListServicePipelineProvisionedResources) Hand return out, metadata, err } - err = awsAwsjson10_deserializeOpDocumentListServicePipelineProvisionedResourcesOutput(&output, shape) + err = awsAwsjson10_deserializeOpDocumentListRepositoriesOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -6916,7 +6928,7 @@ func (m *awsAwsjson10_deserializeOpListServicePipelineProvisionedResources) Hand return out, metadata, err } -func awsAwsjson10_deserializeOpErrorListServicePipelineProvisionedResources(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson10_deserializeOpErrorListRepositories(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)} @@ -6982,14 +6994,14 @@ func awsAwsjson10_deserializeOpErrorListServicePipelineProvisionedResources(resp } } -type awsAwsjson10_deserializeOpListServices struct { +type awsAwsjson10_deserializeOpListRepositorySyncDefinitions struct { } -func (*awsAwsjson10_deserializeOpListServices) ID() string { +func (*awsAwsjson10_deserializeOpListRepositorySyncDefinitions) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson10_deserializeOpListServices) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson10_deserializeOpListRepositorySyncDefinitions) 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) @@ -7003,9 +7015,9 @@ func (m *awsAwsjson10_deserializeOpListServices) HandleDeserialize(ctx context.C } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson10_deserializeOpErrorListServices(response, &metadata) + return out, metadata, awsAwsjson10_deserializeOpErrorListRepositorySyncDefinitions(response, &metadata) } - output := &ListServicesOutput{} + output := &ListRepositorySyncDefinitionsOutput{} out.Result = output var buff [1024]byte @@ -7025,7 +7037,7 @@ func (m *awsAwsjson10_deserializeOpListServices) HandleDeserialize(ctx context.C return out, metadata, err } - err = awsAwsjson10_deserializeOpDocumentListServicesOutput(&output, shape) + err = awsAwsjson10_deserializeOpDocumentListRepositorySyncDefinitionsOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -7039,7 +7051,7 @@ func (m *awsAwsjson10_deserializeOpListServices) HandleDeserialize(ctx context.C return out, metadata, err } -func awsAwsjson10_deserializeOpErrorListServices(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson10_deserializeOpErrorListRepositorySyncDefinitions(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)} @@ -7102,14 +7114,14 @@ func awsAwsjson10_deserializeOpErrorListServices(response *smithyhttp.Response, } } -type awsAwsjson10_deserializeOpListServiceTemplates struct { +type awsAwsjson10_deserializeOpListServiceInstanceOutputs struct { } -func (*awsAwsjson10_deserializeOpListServiceTemplates) ID() string { +func (*awsAwsjson10_deserializeOpListServiceInstanceOutputs) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson10_deserializeOpListServiceTemplates) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson10_deserializeOpListServiceInstanceOutputs) 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) @@ -7123,9 +7135,9 @@ func (m *awsAwsjson10_deserializeOpListServiceTemplates) HandleDeserialize(ctx c } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson10_deserializeOpErrorListServiceTemplates(response, &metadata) + return out, metadata, awsAwsjson10_deserializeOpErrorListServiceInstanceOutputs(response, &metadata) } - output := &ListServiceTemplatesOutput{} + output := &ListServiceInstanceOutputsOutput{} out.Result = output var buff [1024]byte @@ -7145,7 +7157,7 @@ func (m *awsAwsjson10_deserializeOpListServiceTemplates) HandleDeserialize(ctx c return out, metadata, err } - err = awsAwsjson10_deserializeOpDocumentListServiceTemplatesOutput(&output, shape) + err = awsAwsjson10_deserializeOpDocumentListServiceInstanceOutputsOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -7159,7 +7171,7 @@ func (m *awsAwsjson10_deserializeOpListServiceTemplates) HandleDeserialize(ctx c return out, metadata, err } -func awsAwsjson10_deserializeOpErrorListServiceTemplates(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson10_deserializeOpErrorListServiceInstanceOutputs(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)} @@ -7206,6 +7218,9 @@ func awsAwsjson10_deserializeOpErrorListServiceTemplates(response *smithyhttp.Re case strings.EqualFold("InternalServerException", errorCode): return awsAwsjson10_deserializeErrorInternalServerException(response, errorBody) + case strings.EqualFold("ResourceNotFoundException", errorCode): + return awsAwsjson10_deserializeErrorResourceNotFoundException(response, errorBody) + case strings.EqualFold("ThrottlingException", errorCode): return awsAwsjson10_deserializeErrorThrottlingException(response, errorBody) @@ -7222,14 +7237,14 @@ func awsAwsjson10_deserializeOpErrorListServiceTemplates(response *smithyhttp.Re } } -type awsAwsjson10_deserializeOpListServiceTemplateVersions struct { +type awsAwsjson10_deserializeOpListServiceInstanceProvisionedResources struct { } -func (*awsAwsjson10_deserializeOpListServiceTemplateVersions) ID() string { +func (*awsAwsjson10_deserializeOpListServiceInstanceProvisionedResources) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson10_deserializeOpListServiceTemplateVersions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson10_deserializeOpListServiceInstanceProvisionedResources) 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) @@ -7243,9 +7258,9 @@ func (m *awsAwsjson10_deserializeOpListServiceTemplateVersions) HandleDeserializ } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson10_deserializeOpErrorListServiceTemplateVersions(response, &metadata) + return out, metadata, awsAwsjson10_deserializeOpErrorListServiceInstanceProvisionedResources(response, &metadata) } - output := &ListServiceTemplateVersionsOutput{} + output := &ListServiceInstanceProvisionedResourcesOutput{} out.Result = output var buff [1024]byte @@ -7265,7 +7280,7 @@ func (m *awsAwsjson10_deserializeOpListServiceTemplateVersions) HandleDeserializ return out, metadata, err } - err = awsAwsjson10_deserializeOpDocumentListServiceTemplateVersionsOutput(&output, shape) + err = awsAwsjson10_deserializeOpDocumentListServiceInstanceProvisionedResourcesOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -7279,7 +7294,7 @@ func (m *awsAwsjson10_deserializeOpListServiceTemplateVersions) HandleDeserializ return out, metadata, err } -func awsAwsjson10_deserializeOpErrorListServiceTemplateVersions(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson10_deserializeOpErrorListServiceInstanceProvisionedResources(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)} @@ -7345,14 +7360,14 @@ func awsAwsjson10_deserializeOpErrorListServiceTemplateVersions(response *smithy } } -type awsAwsjson10_deserializeOpListTagsForResource struct { +type awsAwsjson10_deserializeOpListServiceInstances struct { } -func (*awsAwsjson10_deserializeOpListTagsForResource) ID() string { +func (*awsAwsjson10_deserializeOpListServiceInstances) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson10_deserializeOpListTagsForResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson10_deserializeOpListServiceInstances) 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) @@ -7366,9 +7381,9 @@ func (m *awsAwsjson10_deserializeOpListTagsForResource) HandleDeserialize(ctx co } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson10_deserializeOpErrorListTagsForResource(response, &metadata) + return out, metadata, awsAwsjson10_deserializeOpErrorListServiceInstances(response, &metadata) } - output := &ListTagsForResourceOutput{} + output := &ListServiceInstancesOutput{} out.Result = output var buff [1024]byte @@ -7388,7 +7403,7 @@ func (m *awsAwsjson10_deserializeOpListTagsForResource) HandleDeserialize(ctx co return out, metadata, err } - err = awsAwsjson10_deserializeOpDocumentListTagsForResourceOutput(&output, shape) + err = awsAwsjson10_deserializeOpDocumentListServiceInstancesOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -7402,7 +7417,7 @@ func (m *awsAwsjson10_deserializeOpListTagsForResource) HandleDeserialize(ctx co return out, metadata, err } -func awsAwsjson10_deserializeOpErrorListTagsForResource(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson10_deserializeOpErrorListServiceInstances(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)} @@ -7468,14 +7483,14 @@ func awsAwsjson10_deserializeOpErrorListTagsForResource(response *smithyhttp.Res } } -type awsAwsjson10_deserializeOpNotifyResourceDeploymentStatusChange struct { +type awsAwsjson10_deserializeOpListServicePipelineOutputs struct { } -func (*awsAwsjson10_deserializeOpNotifyResourceDeploymentStatusChange) ID() string { +func (*awsAwsjson10_deserializeOpListServicePipelineOutputs) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson10_deserializeOpNotifyResourceDeploymentStatusChange) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson10_deserializeOpListServicePipelineOutputs) 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) @@ -7489,9 +7504,9 @@ func (m *awsAwsjson10_deserializeOpNotifyResourceDeploymentStatusChange) HandleD } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson10_deserializeOpErrorNotifyResourceDeploymentStatusChange(response, &metadata) + return out, metadata, awsAwsjson10_deserializeOpErrorListServicePipelineOutputs(response, &metadata) } - output := &NotifyResourceDeploymentStatusChangeOutput{} + output := &ListServicePipelineOutputsOutput{} out.Result = output var buff [1024]byte @@ -7511,7 +7526,7 @@ func (m *awsAwsjson10_deserializeOpNotifyResourceDeploymentStatusChange) HandleD return out, metadata, err } - err = awsAwsjson10_deserializeOpDocumentNotifyResourceDeploymentStatusChangeOutput(&output, shape) + err = awsAwsjson10_deserializeOpDocumentListServicePipelineOutputsOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -7525,7 +7540,7 @@ func (m *awsAwsjson10_deserializeOpNotifyResourceDeploymentStatusChange) HandleD return out, metadata, err } -func awsAwsjson10_deserializeOpErrorNotifyResourceDeploymentStatusChange(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson10_deserializeOpErrorListServicePipelineOutputs(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)} @@ -7569,18 +7584,12 @@ func awsAwsjson10_deserializeOpErrorNotifyResourceDeploymentStatusChange(respons case strings.EqualFold("AccessDeniedException", errorCode): return awsAwsjson10_deserializeErrorAccessDeniedException(response, errorBody) - case strings.EqualFold("ConflictException", errorCode): - return awsAwsjson10_deserializeErrorConflictException(response, errorBody) - case strings.EqualFold("InternalServerException", errorCode): return awsAwsjson10_deserializeErrorInternalServerException(response, errorBody) case strings.EqualFold("ResourceNotFoundException", errorCode): return awsAwsjson10_deserializeErrorResourceNotFoundException(response, errorBody) - case strings.EqualFold("ServiceQuotaExceededException", errorCode): - return awsAwsjson10_deserializeErrorServiceQuotaExceededException(response, errorBody) - case strings.EqualFold("ThrottlingException", errorCode): return awsAwsjson10_deserializeErrorThrottlingException(response, errorBody) @@ -7597,14 +7606,14 @@ func awsAwsjson10_deserializeOpErrorNotifyResourceDeploymentStatusChange(respons } } -type awsAwsjson10_deserializeOpRejectEnvironmentAccountConnection struct { +type awsAwsjson10_deserializeOpListServicePipelineProvisionedResources struct { } -func (*awsAwsjson10_deserializeOpRejectEnvironmentAccountConnection) ID() string { +func (*awsAwsjson10_deserializeOpListServicePipelineProvisionedResources) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson10_deserializeOpRejectEnvironmentAccountConnection) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson10_deserializeOpListServicePipelineProvisionedResources) 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) @@ -7618,9 +7627,9 @@ func (m *awsAwsjson10_deserializeOpRejectEnvironmentAccountConnection) HandleDes } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson10_deserializeOpErrorRejectEnvironmentAccountConnection(response, &metadata) + return out, metadata, awsAwsjson10_deserializeOpErrorListServicePipelineProvisionedResources(response, &metadata) } - output := &RejectEnvironmentAccountConnectionOutput{} + output := &ListServicePipelineProvisionedResourcesOutput{} out.Result = output var buff [1024]byte @@ -7640,7 +7649,7 @@ func (m *awsAwsjson10_deserializeOpRejectEnvironmentAccountConnection) HandleDes return out, metadata, err } - err = awsAwsjson10_deserializeOpDocumentRejectEnvironmentAccountConnectionOutput(&output, shape) + err = awsAwsjson10_deserializeOpDocumentListServicePipelineProvisionedResourcesOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -7654,7 +7663,7 @@ func (m *awsAwsjson10_deserializeOpRejectEnvironmentAccountConnection) HandleDes return out, metadata, err } -func awsAwsjson10_deserializeOpErrorRejectEnvironmentAccountConnection(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson10_deserializeOpErrorListServicePipelineProvisionedResources(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)} @@ -7698,9 +7707,6 @@ func awsAwsjson10_deserializeOpErrorRejectEnvironmentAccountConnection(response case strings.EqualFold("AccessDeniedException", errorCode): return awsAwsjson10_deserializeErrorAccessDeniedException(response, errorBody) - case strings.EqualFold("ConflictException", errorCode): - return awsAwsjson10_deserializeErrorConflictException(response, errorBody) - case strings.EqualFold("InternalServerException", errorCode): return awsAwsjson10_deserializeErrorInternalServerException(response, errorBody) @@ -7723,14 +7729,14 @@ func awsAwsjson10_deserializeOpErrorRejectEnvironmentAccountConnection(response } } -type awsAwsjson10_deserializeOpTagResource struct { +type awsAwsjson10_deserializeOpListServices struct { } -func (*awsAwsjson10_deserializeOpTagResource) ID() string { +func (*awsAwsjson10_deserializeOpListServices) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson10_deserializeOpTagResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson10_deserializeOpListServices) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -7744,9 +7750,9 @@ func (m *awsAwsjson10_deserializeOpTagResource) HandleDeserialize(ctx context.Co } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson10_deserializeOpErrorTagResource(response, &metadata) + return out, metadata, awsAwsjson10_deserializeOpErrorListServices(response, &metadata) } - output := &TagResourceOutput{} + output := &ListServicesOutput{} out.Result = output var buff [1024]byte @@ -7766,7 +7772,7 @@ func (m *awsAwsjson10_deserializeOpTagResource) HandleDeserialize(ctx context.Co return out, metadata, err } - err = awsAwsjson10_deserializeOpDocumentTagResourceOutput(&output, shape) + err = awsAwsjson10_deserializeOpDocumentListServicesOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -7780,7 +7786,7 @@ func (m *awsAwsjson10_deserializeOpTagResource) HandleDeserialize(ctx context.Co return out, metadata, err } -func awsAwsjson10_deserializeOpErrorTagResource(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson10_deserializeOpErrorListServices(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -7824,15 +7830,9 @@ func awsAwsjson10_deserializeOpErrorTagResource(response *smithyhttp.Response, m case strings.EqualFold("AccessDeniedException", errorCode): return awsAwsjson10_deserializeErrorAccessDeniedException(response, errorBody) - case strings.EqualFold("ConflictException", errorCode): - return awsAwsjson10_deserializeErrorConflictException(response, errorBody) - case strings.EqualFold("InternalServerException", errorCode): return awsAwsjson10_deserializeErrorInternalServerException(response, errorBody) - case strings.EqualFold("ResourceNotFoundException", errorCode): - return awsAwsjson10_deserializeErrorResourceNotFoundException(response, errorBody) - case strings.EqualFold("ThrottlingException", errorCode): return awsAwsjson10_deserializeErrorThrottlingException(response, errorBody) @@ -7849,14 +7849,14 @@ func awsAwsjson10_deserializeOpErrorTagResource(response *smithyhttp.Response, m } } -type awsAwsjson10_deserializeOpUntagResource struct { +type awsAwsjson10_deserializeOpListServiceTemplates struct { } -func (*awsAwsjson10_deserializeOpUntagResource) ID() string { +func (*awsAwsjson10_deserializeOpListServiceTemplates) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson10_deserializeOpUntagResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson10_deserializeOpListServiceTemplates) 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) @@ -7870,9 +7870,9 @@ func (m *awsAwsjson10_deserializeOpUntagResource) HandleDeserialize(ctx context. } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson10_deserializeOpErrorUntagResource(response, &metadata) + return out, metadata, awsAwsjson10_deserializeOpErrorListServiceTemplates(response, &metadata) } - output := &UntagResourceOutput{} + output := &ListServiceTemplatesOutput{} out.Result = output var buff [1024]byte @@ -7892,7 +7892,7 @@ func (m *awsAwsjson10_deserializeOpUntagResource) HandleDeserialize(ctx context. return out, metadata, err } - err = awsAwsjson10_deserializeOpDocumentUntagResourceOutput(&output, shape) + err = awsAwsjson10_deserializeOpDocumentListServiceTemplatesOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -7906,7 +7906,7 @@ func (m *awsAwsjson10_deserializeOpUntagResource) HandleDeserialize(ctx context. return out, metadata, err } -func awsAwsjson10_deserializeOpErrorUntagResource(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson10_deserializeOpErrorListServiceTemplates(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)} @@ -7950,15 +7950,9 @@ func awsAwsjson10_deserializeOpErrorUntagResource(response *smithyhttp.Response, case strings.EqualFold("AccessDeniedException", errorCode): return awsAwsjson10_deserializeErrorAccessDeniedException(response, errorBody) - case strings.EqualFold("ConflictException", errorCode): - return awsAwsjson10_deserializeErrorConflictException(response, errorBody) - case strings.EqualFold("InternalServerException", errorCode): return awsAwsjson10_deserializeErrorInternalServerException(response, errorBody) - case strings.EqualFold("ResourceNotFoundException", errorCode): - return awsAwsjson10_deserializeErrorResourceNotFoundException(response, errorBody) - case strings.EqualFold("ThrottlingException", errorCode): return awsAwsjson10_deserializeErrorThrottlingException(response, errorBody) @@ -7975,14 +7969,14 @@ func awsAwsjson10_deserializeOpErrorUntagResource(response *smithyhttp.Response, } } -type awsAwsjson10_deserializeOpUpdateAccountSettings struct { +type awsAwsjson10_deserializeOpListServiceTemplateVersions struct { } -func (*awsAwsjson10_deserializeOpUpdateAccountSettings) ID() string { +func (*awsAwsjson10_deserializeOpListServiceTemplateVersions) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson10_deserializeOpUpdateAccountSettings) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson10_deserializeOpListServiceTemplateVersions) 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) @@ -7996,9 +7990,9 @@ func (m *awsAwsjson10_deserializeOpUpdateAccountSettings) HandleDeserialize(ctx } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson10_deserializeOpErrorUpdateAccountSettings(response, &metadata) + return out, metadata, awsAwsjson10_deserializeOpErrorListServiceTemplateVersions(response, &metadata) } - output := &UpdateAccountSettingsOutput{} + output := &ListServiceTemplateVersionsOutput{} out.Result = output var buff [1024]byte @@ -8018,7 +8012,7 @@ func (m *awsAwsjson10_deserializeOpUpdateAccountSettings) HandleDeserialize(ctx return out, metadata, err } - err = awsAwsjson10_deserializeOpDocumentUpdateAccountSettingsOutput(&output, shape) + err = awsAwsjson10_deserializeOpDocumentListServiceTemplateVersionsOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -8032,7 +8026,7 @@ func (m *awsAwsjson10_deserializeOpUpdateAccountSettings) HandleDeserialize(ctx return out, metadata, err } -func awsAwsjson10_deserializeOpErrorUpdateAccountSettings(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson10_deserializeOpErrorListServiceTemplateVersions(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)} @@ -8076,12 +8070,12 @@ func awsAwsjson10_deserializeOpErrorUpdateAccountSettings(response *smithyhttp.R case strings.EqualFold("AccessDeniedException", errorCode): return awsAwsjson10_deserializeErrorAccessDeniedException(response, errorBody) - case strings.EqualFold("ConflictException", errorCode): - return awsAwsjson10_deserializeErrorConflictException(response, errorBody) - case strings.EqualFold("InternalServerException", errorCode): return awsAwsjson10_deserializeErrorInternalServerException(response, errorBody) + case strings.EqualFold("ResourceNotFoundException", errorCode): + return awsAwsjson10_deserializeErrorResourceNotFoundException(response, errorBody) + case strings.EqualFold("ThrottlingException", errorCode): return awsAwsjson10_deserializeErrorThrottlingException(response, errorBody) @@ -8098,14 +8092,14 @@ func awsAwsjson10_deserializeOpErrorUpdateAccountSettings(response *smithyhttp.R } } -type awsAwsjson10_deserializeOpUpdateComponent struct { +type awsAwsjson10_deserializeOpListTagsForResource struct { } -func (*awsAwsjson10_deserializeOpUpdateComponent) ID() string { +func (*awsAwsjson10_deserializeOpListTagsForResource) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson10_deserializeOpUpdateComponent) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson10_deserializeOpListTagsForResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -8119,9 +8113,9 @@ func (m *awsAwsjson10_deserializeOpUpdateComponent) HandleDeserialize(ctx contex } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson10_deserializeOpErrorUpdateComponent(response, &metadata) + return out, metadata, awsAwsjson10_deserializeOpErrorListTagsForResource(response, &metadata) } - output := &UpdateComponentOutput{} + output := &ListTagsForResourceOutput{} out.Result = output var buff [1024]byte @@ -8141,7 +8135,7 @@ func (m *awsAwsjson10_deserializeOpUpdateComponent) HandleDeserialize(ctx contex return out, metadata, err } - err = awsAwsjson10_deserializeOpDocumentUpdateComponentOutput(&output, shape) + err = awsAwsjson10_deserializeOpDocumentListTagsForResourceOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -8155,7 +8149,7 @@ func (m *awsAwsjson10_deserializeOpUpdateComponent) HandleDeserialize(ctx contex return out, metadata, err } -func awsAwsjson10_deserializeOpErrorUpdateComponent(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson10_deserializeOpErrorListTagsForResource(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -8199,18 +8193,12 @@ func awsAwsjson10_deserializeOpErrorUpdateComponent(response *smithyhttp.Respons case strings.EqualFold("AccessDeniedException", errorCode): return awsAwsjson10_deserializeErrorAccessDeniedException(response, errorBody) - case strings.EqualFold("ConflictException", errorCode): - return awsAwsjson10_deserializeErrorConflictException(response, errorBody) - case strings.EqualFold("InternalServerException", errorCode): return awsAwsjson10_deserializeErrorInternalServerException(response, errorBody) case strings.EqualFold("ResourceNotFoundException", errorCode): return awsAwsjson10_deserializeErrorResourceNotFoundException(response, errorBody) - case strings.EqualFold("ServiceQuotaExceededException", errorCode): - return awsAwsjson10_deserializeErrorServiceQuotaExceededException(response, errorBody) - case strings.EqualFold("ThrottlingException", errorCode): return awsAwsjson10_deserializeErrorThrottlingException(response, errorBody) @@ -8227,14 +8215,14 @@ func awsAwsjson10_deserializeOpErrorUpdateComponent(response *smithyhttp.Respons } } -type awsAwsjson10_deserializeOpUpdateEnvironment struct { +type awsAwsjson10_deserializeOpNotifyResourceDeploymentStatusChange struct { } -func (*awsAwsjson10_deserializeOpUpdateEnvironment) ID() string { +func (*awsAwsjson10_deserializeOpNotifyResourceDeploymentStatusChange) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson10_deserializeOpUpdateEnvironment) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson10_deserializeOpNotifyResourceDeploymentStatusChange) 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) @@ -8248,9 +8236,9 @@ func (m *awsAwsjson10_deserializeOpUpdateEnvironment) HandleDeserialize(ctx cont } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson10_deserializeOpErrorUpdateEnvironment(response, &metadata) + return out, metadata, awsAwsjson10_deserializeOpErrorNotifyResourceDeploymentStatusChange(response, &metadata) } - output := &UpdateEnvironmentOutput{} + output := &NotifyResourceDeploymentStatusChangeOutput{} out.Result = output var buff [1024]byte @@ -8270,7 +8258,7 @@ func (m *awsAwsjson10_deserializeOpUpdateEnvironment) HandleDeserialize(ctx cont return out, metadata, err } - err = awsAwsjson10_deserializeOpDocumentUpdateEnvironmentOutput(&output, shape) + err = awsAwsjson10_deserializeOpDocumentNotifyResourceDeploymentStatusChangeOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -8284,7 +8272,7 @@ func (m *awsAwsjson10_deserializeOpUpdateEnvironment) HandleDeserialize(ctx cont return out, metadata, err } -func awsAwsjson10_deserializeOpErrorUpdateEnvironment(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson10_deserializeOpErrorNotifyResourceDeploymentStatusChange(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)} @@ -8337,6 +8325,9 @@ func awsAwsjson10_deserializeOpErrorUpdateEnvironment(response *smithyhttp.Respo case strings.EqualFold("ResourceNotFoundException", errorCode): return awsAwsjson10_deserializeErrorResourceNotFoundException(response, errorBody) + case strings.EqualFold("ServiceQuotaExceededException", errorCode): + return awsAwsjson10_deserializeErrorServiceQuotaExceededException(response, errorBody) + case strings.EqualFold("ThrottlingException", errorCode): return awsAwsjson10_deserializeErrorThrottlingException(response, errorBody) @@ -8353,14 +8344,14 @@ func awsAwsjson10_deserializeOpErrorUpdateEnvironment(response *smithyhttp.Respo } } -type awsAwsjson10_deserializeOpUpdateEnvironmentAccountConnection struct { +type awsAwsjson10_deserializeOpRejectEnvironmentAccountConnection struct { } -func (*awsAwsjson10_deserializeOpUpdateEnvironmentAccountConnection) ID() string { +func (*awsAwsjson10_deserializeOpRejectEnvironmentAccountConnection) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson10_deserializeOpUpdateEnvironmentAccountConnection) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson10_deserializeOpRejectEnvironmentAccountConnection) 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) @@ -8374,9 +8365,9 @@ func (m *awsAwsjson10_deserializeOpUpdateEnvironmentAccountConnection) HandleDes } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson10_deserializeOpErrorUpdateEnvironmentAccountConnection(response, &metadata) + return out, metadata, awsAwsjson10_deserializeOpErrorRejectEnvironmentAccountConnection(response, &metadata) } - output := &UpdateEnvironmentAccountConnectionOutput{} + output := &RejectEnvironmentAccountConnectionOutput{} out.Result = output var buff [1024]byte @@ -8396,7 +8387,7 @@ func (m *awsAwsjson10_deserializeOpUpdateEnvironmentAccountConnection) HandleDes return out, metadata, err } - err = awsAwsjson10_deserializeOpDocumentUpdateEnvironmentAccountConnectionOutput(&output, shape) + err = awsAwsjson10_deserializeOpDocumentRejectEnvironmentAccountConnectionOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -8410,7 +8401,7 @@ func (m *awsAwsjson10_deserializeOpUpdateEnvironmentAccountConnection) HandleDes return out, metadata, err } -func awsAwsjson10_deserializeOpErrorUpdateEnvironmentAccountConnection(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson10_deserializeOpErrorRejectEnvironmentAccountConnection(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)} @@ -8479,14 +8470,14 @@ func awsAwsjson10_deserializeOpErrorUpdateEnvironmentAccountConnection(response } } -type awsAwsjson10_deserializeOpUpdateEnvironmentTemplate struct { +type awsAwsjson10_deserializeOpTagResource struct { } -func (*awsAwsjson10_deserializeOpUpdateEnvironmentTemplate) ID() string { +func (*awsAwsjson10_deserializeOpTagResource) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson10_deserializeOpUpdateEnvironmentTemplate) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson10_deserializeOpTagResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -8500,9 +8491,9 @@ func (m *awsAwsjson10_deserializeOpUpdateEnvironmentTemplate) HandleDeserialize( } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson10_deserializeOpErrorUpdateEnvironmentTemplate(response, &metadata) + return out, metadata, awsAwsjson10_deserializeOpErrorTagResource(response, &metadata) } - output := &UpdateEnvironmentTemplateOutput{} + output := &TagResourceOutput{} out.Result = output var buff [1024]byte @@ -8522,7 +8513,7 @@ func (m *awsAwsjson10_deserializeOpUpdateEnvironmentTemplate) HandleDeserialize( return out, metadata, err } - err = awsAwsjson10_deserializeOpDocumentUpdateEnvironmentTemplateOutput(&output, shape) + err = awsAwsjson10_deserializeOpDocumentTagResourceOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -8536,7 +8527,7 @@ func (m *awsAwsjson10_deserializeOpUpdateEnvironmentTemplate) HandleDeserialize( return out, metadata, err } -func awsAwsjson10_deserializeOpErrorUpdateEnvironmentTemplate(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson10_deserializeOpErrorTagResource(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -8605,14 +8596,14 @@ func awsAwsjson10_deserializeOpErrorUpdateEnvironmentTemplate(response *smithyht } } -type awsAwsjson10_deserializeOpUpdateEnvironmentTemplateVersion struct { +type awsAwsjson10_deserializeOpUntagResource struct { } -func (*awsAwsjson10_deserializeOpUpdateEnvironmentTemplateVersion) ID() string { +func (*awsAwsjson10_deserializeOpUntagResource) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson10_deserializeOpUpdateEnvironmentTemplateVersion) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson10_deserializeOpUntagResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -8626,9 +8617,9 @@ func (m *awsAwsjson10_deserializeOpUpdateEnvironmentTemplateVersion) HandleDeser } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson10_deserializeOpErrorUpdateEnvironmentTemplateVersion(response, &metadata) + return out, metadata, awsAwsjson10_deserializeOpErrorUntagResource(response, &metadata) } - output := &UpdateEnvironmentTemplateVersionOutput{} + output := &UntagResourceOutput{} out.Result = output var buff [1024]byte @@ -8648,7 +8639,7 @@ func (m *awsAwsjson10_deserializeOpUpdateEnvironmentTemplateVersion) HandleDeser return out, metadata, err } - err = awsAwsjson10_deserializeOpDocumentUpdateEnvironmentTemplateVersionOutput(&output, shape) + err = awsAwsjson10_deserializeOpDocumentUntagResourceOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -8662,7 +8653,7 @@ func (m *awsAwsjson10_deserializeOpUpdateEnvironmentTemplateVersion) HandleDeser return out, metadata, err } -func awsAwsjson10_deserializeOpErrorUpdateEnvironmentTemplateVersion(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson10_deserializeOpErrorUntagResource(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -8731,14 +8722,14 @@ func awsAwsjson10_deserializeOpErrorUpdateEnvironmentTemplateVersion(response *s } } -type awsAwsjson10_deserializeOpUpdateService struct { +type awsAwsjson10_deserializeOpUpdateAccountSettings struct { } -func (*awsAwsjson10_deserializeOpUpdateService) ID() string { +func (*awsAwsjson10_deserializeOpUpdateAccountSettings) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson10_deserializeOpUpdateService) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson10_deserializeOpUpdateAccountSettings) 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) @@ -8752,9 +8743,9 @@ func (m *awsAwsjson10_deserializeOpUpdateService) HandleDeserialize(ctx context. } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson10_deserializeOpErrorUpdateService(response, &metadata) + return out, metadata, awsAwsjson10_deserializeOpErrorUpdateAccountSettings(response, &metadata) } - output := &UpdateServiceOutput{} + output := &UpdateAccountSettingsOutput{} out.Result = output var buff [1024]byte @@ -8774,7 +8765,7 @@ func (m *awsAwsjson10_deserializeOpUpdateService) HandleDeserialize(ctx context. return out, metadata, err } - err = awsAwsjson10_deserializeOpDocumentUpdateServiceOutput(&output, shape) + err = awsAwsjson10_deserializeOpDocumentUpdateAccountSettingsOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -8788,7 +8779,7 @@ func (m *awsAwsjson10_deserializeOpUpdateService) HandleDeserialize(ctx context. return out, metadata, err } -func awsAwsjson10_deserializeOpErrorUpdateService(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson10_deserializeOpErrorUpdateAccountSettings(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)} @@ -8838,12 +8829,6 @@ func awsAwsjson10_deserializeOpErrorUpdateService(response *smithyhttp.Response, case strings.EqualFold("InternalServerException", errorCode): return awsAwsjson10_deserializeErrorInternalServerException(response, errorBody) - case strings.EqualFold("ResourceNotFoundException", errorCode): - return awsAwsjson10_deserializeErrorResourceNotFoundException(response, errorBody) - - case strings.EqualFold("ServiceQuotaExceededException", errorCode): - return awsAwsjson10_deserializeErrorServiceQuotaExceededException(response, errorBody) - case strings.EqualFold("ThrottlingException", errorCode): return awsAwsjson10_deserializeErrorThrottlingException(response, errorBody) @@ -8860,14 +8845,14 @@ func awsAwsjson10_deserializeOpErrorUpdateService(response *smithyhttp.Response, } } -type awsAwsjson10_deserializeOpUpdateServiceInstance struct { +type awsAwsjson10_deserializeOpUpdateComponent struct { } -func (*awsAwsjson10_deserializeOpUpdateServiceInstance) ID() string { +func (*awsAwsjson10_deserializeOpUpdateComponent) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson10_deserializeOpUpdateServiceInstance) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson10_deserializeOpUpdateComponent) 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) @@ -8881,9 +8866,9 @@ func (m *awsAwsjson10_deserializeOpUpdateServiceInstance) HandleDeserialize(ctx } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson10_deserializeOpErrorUpdateServiceInstance(response, &metadata) + return out, metadata, awsAwsjson10_deserializeOpErrorUpdateComponent(response, &metadata) } - output := &UpdateServiceInstanceOutput{} + output := &UpdateComponentOutput{} out.Result = output var buff [1024]byte @@ -8903,7 +8888,7 @@ func (m *awsAwsjson10_deserializeOpUpdateServiceInstance) HandleDeserialize(ctx return out, metadata, err } - err = awsAwsjson10_deserializeOpDocumentUpdateServiceInstanceOutput(&output, shape) + err = awsAwsjson10_deserializeOpDocumentUpdateComponentOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -8917,7 +8902,7 @@ func (m *awsAwsjson10_deserializeOpUpdateServiceInstance) HandleDeserialize(ctx return out, metadata, err } -func awsAwsjson10_deserializeOpErrorUpdateServiceInstance(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson10_deserializeOpErrorUpdateComponent(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)} @@ -8970,6 +8955,9 @@ func awsAwsjson10_deserializeOpErrorUpdateServiceInstance(response *smithyhttp.R case strings.EqualFold("ResourceNotFoundException", errorCode): return awsAwsjson10_deserializeErrorResourceNotFoundException(response, errorBody) + case strings.EqualFold("ServiceQuotaExceededException", errorCode): + return awsAwsjson10_deserializeErrorServiceQuotaExceededException(response, errorBody) + case strings.EqualFold("ThrottlingException", errorCode): return awsAwsjson10_deserializeErrorThrottlingException(response, errorBody) @@ -8986,14 +8974,14 @@ func awsAwsjson10_deserializeOpErrorUpdateServiceInstance(response *smithyhttp.R } } -type awsAwsjson10_deserializeOpUpdateServicePipeline struct { +type awsAwsjson10_deserializeOpUpdateEnvironment struct { } -func (*awsAwsjson10_deserializeOpUpdateServicePipeline) ID() string { +func (*awsAwsjson10_deserializeOpUpdateEnvironment) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson10_deserializeOpUpdateServicePipeline) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson10_deserializeOpUpdateEnvironment) 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) @@ -9007,9 +8995,9 @@ func (m *awsAwsjson10_deserializeOpUpdateServicePipeline) HandleDeserialize(ctx } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson10_deserializeOpErrorUpdateServicePipeline(response, &metadata) + return out, metadata, awsAwsjson10_deserializeOpErrorUpdateEnvironment(response, &metadata) } - output := &UpdateServicePipelineOutput{} + output := &UpdateEnvironmentOutput{} out.Result = output var buff [1024]byte @@ -9029,7 +9017,7 @@ func (m *awsAwsjson10_deserializeOpUpdateServicePipeline) HandleDeserialize(ctx return out, metadata, err } - err = awsAwsjson10_deserializeOpDocumentUpdateServicePipelineOutput(&output, shape) + err = awsAwsjson10_deserializeOpDocumentUpdateEnvironmentOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -9043,7 +9031,7 @@ func (m *awsAwsjson10_deserializeOpUpdateServicePipeline) HandleDeserialize(ctx return out, metadata, err } -func awsAwsjson10_deserializeOpErrorUpdateServicePipeline(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson10_deserializeOpErrorUpdateEnvironment(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)} @@ -9112,14 +9100,14 @@ func awsAwsjson10_deserializeOpErrorUpdateServicePipeline(response *smithyhttp.R } } -type awsAwsjson10_deserializeOpUpdateServiceTemplate struct { +type awsAwsjson10_deserializeOpUpdateEnvironmentAccountConnection struct { } -func (*awsAwsjson10_deserializeOpUpdateServiceTemplate) ID() string { +func (*awsAwsjson10_deserializeOpUpdateEnvironmentAccountConnection) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson10_deserializeOpUpdateServiceTemplate) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson10_deserializeOpUpdateEnvironmentAccountConnection) 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) @@ -9133,9 +9121,9 @@ func (m *awsAwsjson10_deserializeOpUpdateServiceTemplate) HandleDeserialize(ctx } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson10_deserializeOpErrorUpdateServiceTemplate(response, &metadata) + return out, metadata, awsAwsjson10_deserializeOpErrorUpdateEnvironmentAccountConnection(response, &metadata) } - output := &UpdateServiceTemplateOutput{} + output := &UpdateEnvironmentAccountConnectionOutput{} out.Result = output var buff [1024]byte @@ -9155,7 +9143,7 @@ func (m *awsAwsjson10_deserializeOpUpdateServiceTemplate) HandleDeserialize(ctx return out, metadata, err } - err = awsAwsjson10_deserializeOpDocumentUpdateServiceTemplateOutput(&output, shape) + err = awsAwsjson10_deserializeOpDocumentUpdateEnvironmentAccountConnectionOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -9169,7 +9157,7 @@ func (m *awsAwsjson10_deserializeOpUpdateServiceTemplate) HandleDeserialize(ctx return out, metadata, err } -func awsAwsjson10_deserializeOpErrorUpdateServiceTemplate(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson10_deserializeOpErrorUpdateEnvironmentAccountConnection(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)} @@ -9238,14 +9226,14 @@ func awsAwsjson10_deserializeOpErrorUpdateServiceTemplate(response *smithyhttp.R } } -type awsAwsjson10_deserializeOpUpdateServiceTemplateVersion struct { +type awsAwsjson10_deserializeOpUpdateEnvironmentTemplate struct { } -func (*awsAwsjson10_deserializeOpUpdateServiceTemplateVersion) ID() string { +func (*awsAwsjson10_deserializeOpUpdateEnvironmentTemplate) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson10_deserializeOpUpdateServiceTemplateVersion) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson10_deserializeOpUpdateEnvironmentTemplate) 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) @@ -9259,9 +9247,9 @@ func (m *awsAwsjson10_deserializeOpUpdateServiceTemplateVersion) HandleDeseriali } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson10_deserializeOpErrorUpdateServiceTemplateVersion(response, &metadata) + return out, metadata, awsAwsjson10_deserializeOpErrorUpdateEnvironmentTemplate(response, &metadata) } - output := &UpdateServiceTemplateVersionOutput{} + output := &UpdateEnvironmentTemplateOutput{} out.Result = output var buff [1024]byte @@ -9281,7 +9269,7 @@ func (m *awsAwsjson10_deserializeOpUpdateServiceTemplateVersion) HandleDeseriali return out, metadata, err } - err = awsAwsjson10_deserializeOpDocumentUpdateServiceTemplateVersionOutput(&output, shape) + err = awsAwsjson10_deserializeOpDocumentUpdateEnvironmentTemplateOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -9295,7 +9283,7 @@ func (m *awsAwsjson10_deserializeOpUpdateServiceTemplateVersion) HandleDeseriali return out, metadata, err } -func awsAwsjson10_deserializeOpErrorUpdateServiceTemplateVersion(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson10_deserializeOpErrorUpdateEnvironmentTemplate(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)} @@ -9364,14 +9352,14 @@ func awsAwsjson10_deserializeOpErrorUpdateServiceTemplateVersion(response *smith } } -type awsAwsjson10_deserializeOpUpdateTemplateSyncConfig struct { +type awsAwsjson10_deserializeOpUpdateEnvironmentTemplateVersion struct { } -func (*awsAwsjson10_deserializeOpUpdateTemplateSyncConfig) ID() string { +func (*awsAwsjson10_deserializeOpUpdateEnvironmentTemplateVersion) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson10_deserializeOpUpdateTemplateSyncConfig) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson10_deserializeOpUpdateEnvironmentTemplateVersion) 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) @@ -9385,9 +9373,9 @@ func (m *awsAwsjson10_deserializeOpUpdateTemplateSyncConfig) HandleDeserialize(c } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson10_deserializeOpErrorUpdateTemplateSyncConfig(response, &metadata) + return out, metadata, awsAwsjson10_deserializeOpErrorUpdateEnvironmentTemplateVersion(response, &metadata) } - output := &UpdateTemplateSyncConfigOutput{} + output := &UpdateEnvironmentTemplateVersionOutput{} out.Result = output var buff [1024]byte @@ -9407,7 +9395,7 @@ func (m *awsAwsjson10_deserializeOpUpdateTemplateSyncConfig) HandleDeserialize(c return out, metadata, err } - err = awsAwsjson10_deserializeOpDocumentUpdateTemplateSyncConfigOutput(&output, shape) + err = awsAwsjson10_deserializeOpDocumentUpdateEnvironmentTemplateVersionOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -9421,7 +9409,7 @@ func (m *awsAwsjson10_deserializeOpUpdateTemplateSyncConfig) HandleDeserialize(c return out, metadata, err } -func awsAwsjson10_deserializeOpErrorUpdateTemplateSyncConfig(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson10_deserializeOpErrorUpdateEnvironmentTemplateVersion(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)} @@ -9490,11 +9478,36 @@ func awsAwsjson10_deserializeOpErrorUpdateTemplateSyncConfig(response *smithyhtt } } -func awsAwsjson10_deserializeErrorAccessDeniedException(response *smithyhttp.Response, errorBody *bytes.Reader) error { +type awsAwsjson10_deserializeOpUpdateService struct { +} + +func (*awsAwsjson10_deserializeOpUpdateService) ID() string { + return "OperationDeserializer" +} + +func (m *awsAwsjson10_deserializeOpUpdateService) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( + out middleware.DeserializeOutput, metadata middleware.Metadata, err error, +) { + out, metadata, err = next.HandleDeserialize(ctx, in) + if err != nil { + return out, metadata, err + } + + response, ok := out.RawResponse.(*smithyhttp.Response) + if !ok { + return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} + } + + if response.StatusCode < 200 || response.StatusCode >= 300 { + return out, metadata, awsAwsjson10_deserializeOpErrorUpdateService(response, &metadata) + } + output := &UpdateServiceOutput{} + out.Result = output + var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) - body := io.TeeReader(errorBody, ringBuffer) + body := io.TeeReader(response.Body, ringBuffer) decoder := json.NewDecoder(body) decoder.UseNumber() var shape interface{} @@ -9505,12 +9518,10 @@ func awsAwsjson10_deserializeErrorAccessDeniedException(response *smithyhttp.Res Err: fmt.Errorf("failed to decode response body, %w", err), Snapshot: snapshot.Bytes(), } - return err + return out, metadata, err } - output := &types.AccessDeniedException{} - err := awsAwsjson10_deserializeDocumentAccessDeniedException(&output, shape) - + err = awsAwsjson10_deserializeOpDocumentUpdateServiceOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -9518,34 +9529,34 @@ func awsAwsjson10_deserializeErrorAccessDeniedException(response *smithyhttp.Res Err: fmt.Errorf("failed to decode response body, %w", err), Snapshot: snapshot.Bytes(), } - return err + return out, metadata, err } - errorBody.Seek(0, io.SeekStart) - return output + return out, metadata, err } -func awsAwsjson10_deserializeErrorConflictException(response *smithyhttp.Response, errorBody *bytes.Reader) error { +func awsAwsjson10_deserializeOpErrorUpdateService(response *smithyhttp.Response, metadata *middleware.Metadata) error { + var errorBuffer bytes.Buffer + if _, err := io.Copy(&errorBuffer, response.Body); err != nil { + return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} + } + errorBody := bytes.NewReader(errorBuffer.Bytes()) + + errorCode := "UnknownError" + errorMessage := errorCode + + headerCode := response.Header.Get("X-Amzn-ErrorType") + if len(headerCode) != 0 { + errorCode = restjson.SanitizeErrorCode(headerCode) + } + var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) decoder := json.NewDecoder(body) decoder.UseNumber() - 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 := awsAwsjson10_deserializeDocumentConflictException(&output, shape) - + jsonCode, message, err := restjson.GetErrorInfo(decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -9557,7 +9568,995 @@ func awsAwsjson10_deserializeErrorConflictException(response *smithyhttp.Respons } errorBody.Seek(0, io.SeekStart) - return output + if len(headerCode) == 0 && len(jsonCode) != 0 { + errorCode = restjson.SanitizeErrorCode(jsonCode) + } + if len(message) != 0 { + errorMessage = message + } + + switch { + case strings.EqualFold("AccessDeniedException", errorCode): + return awsAwsjson10_deserializeErrorAccessDeniedException(response, errorBody) + + case strings.EqualFold("ConflictException", errorCode): + return awsAwsjson10_deserializeErrorConflictException(response, errorBody) + + case strings.EqualFold("InternalServerException", errorCode): + return awsAwsjson10_deserializeErrorInternalServerException(response, errorBody) + + case strings.EqualFold("ResourceNotFoundException", errorCode): + return awsAwsjson10_deserializeErrorResourceNotFoundException(response, errorBody) + + case strings.EqualFold("ServiceQuotaExceededException", errorCode): + return awsAwsjson10_deserializeErrorServiceQuotaExceededException(response, errorBody) + + case strings.EqualFold("ThrottlingException", errorCode): + return awsAwsjson10_deserializeErrorThrottlingException(response, errorBody) + + case strings.EqualFold("ValidationException", errorCode): + return awsAwsjson10_deserializeErrorValidationException(response, errorBody) + + default: + genericError := &smithy.GenericAPIError{ + Code: errorCode, + Message: errorMessage, + } + return genericError + + } +} + +type awsAwsjson10_deserializeOpUpdateServiceInstance struct { +} + +func (*awsAwsjson10_deserializeOpUpdateServiceInstance) ID() string { + return "OperationDeserializer" +} + +func (m *awsAwsjson10_deserializeOpUpdateServiceInstance) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( + out middleware.DeserializeOutput, metadata middleware.Metadata, err error, +) { + out, metadata, err = next.HandleDeserialize(ctx, in) + if err != nil { + return out, metadata, err + } + + response, ok := out.RawResponse.(*smithyhttp.Response) + if !ok { + return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} + } + + if response.StatusCode < 200 || response.StatusCode >= 300 { + return out, metadata, awsAwsjson10_deserializeOpErrorUpdateServiceInstance(response, &metadata) + } + output := &UpdateServiceInstanceOutput{} + out.Result = output + + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + + body := io.TeeReader(response.Body, ringBuffer) + decoder := json.NewDecoder(body) + decoder.UseNumber() + var shape interface{} + if err := decoder.Decode(&shape); err != nil && err != io.EOF { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return out, metadata, err + } + + err = awsAwsjson10_deserializeOpDocumentUpdateServiceInstanceOutput(&output, shape) + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return out, metadata, err + } + + return out, metadata, err +} + +func awsAwsjson10_deserializeOpErrorUpdateServiceInstance(response *smithyhttp.Response, metadata *middleware.Metadata) error { + var errorBuffer bytes.Buffer + if _, err := io.Copy(&errorBuffer, response.Body); err != nil { + return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} + } + errorBody := bytes.NewReader(errorBuffer.Bytes()) + + errorCode := "UnknownError" + errorMessage := errorCode + + headerCode := response.Header.Get("X-Amzn-ErrorType") + if len(headerCode) != 0 { + errorCode = restjson.SanitizeErrorCode(headerCode) + } + + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + + body := io.TeeReader(errorBody, ringBuffer) + decoder := json.NewDecoder(body) + decoder.UseNumber() + jsonCode, message, err := restjson.GetErrorInfo(decoder) + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return err + } + + errorBody.Seek(0, io.SeekStart) + if len(headerCode) == 0 && len(jsonCode) != 0 { + errorCode = restjson.SanitizeErrorCode(jsonCode) + } + if len(message) != 0 { + errorMessage = message + } + + switch { + case strings.EqualFold("AccessDeniedException", errorCode): + return awsAwsjson10_deserializeErrorAccessDeniedException(response, errorBody) + + case strings.EqualFold("ConflictException", errorCode): + return awsAwsjson10_deserializeErrorConflictException(response, errorBody) + + case strings.EqualFold("InternalServerException", errorCode): + return awsAwsjson10_deserializeErrorInternalServerException(response, errorBody) + + case strings.EqualFold("ResourceNotFoundException", errorCode): + return awsAwsjson10_deserializeErrorResourceNotFoundException(response, errorBody) + + case strings.EqualFold("ThrottlingException", errorCode): + return awsAwsjson10_deserializeErrorThrottlingException(response, errorBody) + + case strings.EqualFold("ValidationException", errorCode): + return awsAwsjson10_deserializeErrorValidationException(response, errorBody) + + default: + genericError := &smithy.GenericAPIError{ + Code: errorCode, + Message: errorMessage, + } + return genericError + + } +} + +type awsAwsjson10_deserializeOpUpdateServicePipeline struct { +} + +func (*awsAwsjson10_deserializeOpUpdateServicePipeline) ID() string { + return "OperationDeserializer" +} + +func (m *awsAwsjson10_deserializeOpUpdateServicePipeline) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( + out middleware.DeserializeOutput, metadata middleware.Metadata, err error, +) { + out, metadata, err = next.HandleDeserialize(ctx, in) + if err != nil { + return out, metadata, err + } + + response, ok := out.RawResponse.(*smithyhttp.Response) + if !ok { + return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} + } + + if response.StatusCode < 200 || response.StatusCode >= 300 { + return out, metadata, awsAwsjson10_deserializeOpErrorUpdateServicePipeline(response, &metadata) + } + output := &UpdateServicePipelineOutput{} + out.Result = output + + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + + body := io.TeeReader(response.Body, ringBuffer) + decoder := json.NewDecoder(body) + decoder.UseNumber() + var shape interface{} + if err := decoder.Decode(&shape); err != nil && err != io.EOF { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return out, metadata, err + } + + err = awsAwsjson10_deserializeOpDocumentUpdateServicePipelineOutput(&output, shape) + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return out, metadata, err + } + + return out, metadata, err +} + +func awsAwsjson10_deserializeOpErrorUpdateServicePipeline(response *smithyhttp.Response, metadata *middleware.Metadata) error { + var errorBuffer bytes.Buffer + if _, err := io.Copy(&errorBuffer, response.Body); err != nil { + return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} + } + errorBody := bytes.NewReader(errorBuffer.Bytes()) + + errorCode := "UnknownError" + errorMessage := errorCode + + headerCode := response.Header.Get("X-Amzn-ErrorType") + if len(headerCode) != 0 { + errorCode = restjson.SanitizeErrorCode(headerCode) + } + + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + + body := io.TeeReader(errorBody, ringBuffer) + decoder := json.NewDecoder(body) + decoder.UseNumber() + jsonCode, message, err := restjson.GetErrorInfo(decoder) + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return err + } + + errorBody.Seek(0, io.SeekStart) + if len(headerCode) == 0 && len(jsonCode) != 0 { + errorCode = restjson.SanitizeErrorCode(jsonCode) + } + if len(message) != 0 { + errorMessage = message + } + + switch { + case strings.EqualFold("AccessDeniedException", errorCode): + return awsAwsjson10_deserializeErrorAccessDeniedException(response, errorBody) + + case strings.EqualFold("ConflictException", errorCode): + return awsAwsjson10_deserializeErrorConflictException(response, errorBody) + + case strings.EqualFold("InternalServerException", errorCode): + return awsAwsjson10_deserializeErrorInternalServerException(response, errorBody) + + case strings.EqualFold("ResourceNotFoundException", errorCode): + return awsAwsjson10_deserializeErrorResourceNotFoundException(response, errorBody) + + case strings.EqualFold("ThrottlingException", errorCode): + return awsAwsjson10_deserializeErrorThrottlingException(response, errorBody) + + case strings.EqualFold("ValidationException", errorCode): + return awsAwsjson10_deserializeErrorValidationException(response, errorBody) + + default: + genericError := &smithy.GenericAPIError{ + Code: errorCode, + Message: errorMessage, + } + return genericError + + } +} + +type awsAwsjson10_deserializeOpUpdateServiceSyncBlocker struct { +} + +func (*awsAwsjson10_deserializeOpUpdateServiceSyncBlocker) ID() string { + return "OperationDeserializer" +} + +func (m *awsAwsjson10_deserializeOpUpdateServiceSyncBlocker) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( + out middleware.DeserializeOutput, metadata middleware.Metadata, err error, +) { + out, metadata, err = next.HandleDeserialize(ctx, in) + if err != nil { + return out, metadata, err + } + + response, ok := out.RawResponse.(*smithyhttp.Response) + if !ok { + return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} + } + + if response.StatusCode < 200 || response.StatusCode >= 300 { + return out, metadata, awsAwsjson10_deserializeOpErrorUpdateServiceSyncBlocker(response, &metadata) + } + output := &UpdateServiceSyncBlockerOutput{} + out.Result = output + + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + + body := io.TeeReader(response.Body, ringBuffer) + decoder := json.NewDecoder(body) + decoder.UseNumber() + var shape interface{} + if err := decoder.Decode(&shape); err != nil && err != io.EOF { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return out, metadata, err + } + + err = awsAwsjson10_deserializeOpDocumentUpdateServiceSyncBlockerOutput(&output, shape) + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return out, metadata, err + } + + return out, metadata, err +} + +func awsAwsjson10_deserializeOpErrorUpdateServiceSyncBlocker(response *smithyhttp.Response, metadata *middleware.Metadata) error { + var errorBuffer bytes.Buffer + if _, err := io.Copy(&errorBuffer, response.Body); err != nil { + return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} + } + errorBody := bytes.NewReader(errorBuffer.Bytes()) + + errorCode := "UnknownError" + errorMessage := errorCode + + headerCode := response.Header.Get("X-Amzn-ErrorType") + if len(headerCode) != 0 { + errorCode = restjson.SanitizeErrorCode(headerCode) + } + + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + + body := io.TeeReader(errorBody, ringBuffer) + decoder := json.NewDecoder(body) + decoder.UseNumber() + jsonCode, message, err := restjson.GetErrorInfo(decoder) + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return err + } + + errorBody.Seek(0, io.SeekStart) + if len(headerCode) == 0 && len(jsonCode) != 0 { + errorCode = restjson.SanitizeErrorCode(jsonCode) + } + if len(message) != 0 { + errorMessage = message + } + + switch { + case strings.EqualFold("AccessDeniedException", errorCode): + return awsAwsjson10_deserializeErrorAccessDeniedException(response, errorBody) + + case strings.EqualFold("ConflictException", errorCode): + return awsAwsjson10_deserializeErrorConflictException(response, errorBody) + + case strings.EqualFold("InternalServerException", errorCode): + return awsAwsjson10_deserializeErrorInternalServerException(response, errorBody) + + case strings.EqualFold("ResourceNotFoundException", errorCode): + return awsAwsjson10_deserializeErrorResourceNotFoundException(response, errorBody) + + case strings.EqualFold("ThrottlingException", errorCode): + return awsAwsjson10_deserializeErrorThrottlingException(response, errorBody) + + case strings.EqualFold("ValidationException", errorCode): + return awsAwsjson10_deserializeErrorValidationException(response, errorBody) + + default: + genericError := &smithy.GenericAPIError{ + Code: errorCode, + Message: errorMessage, + } + return genericError + + } +} + +type awsAwsjson10_deserializeOpUpdateServiceSyncConfig struct { +} + +func (*awsAwsjson10_deserializeOpUpdateServiceSyncConfig) ID() string { + return "OperationDeserializer" +} + +func (m *awsAwsjson10_deserializeOpUpdateServiceSyncConfig) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( + out middleware.DeserializeOutput, metadata middleware.Metadata, err error, +) { + out, metadata, err = next.HandleDeserialize(ctx, in) + if err != nil { + return out, metadata, err + } + + response, ok := out.RawResponse.(*smithyhttp.Response) + if !ok { + return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} + } + + if response.StatusCode < 200 || response.StatusCode >= 300 { + return out, metadata, awsAwsjson10_deserializeOpErrorUpdateServiceSyncConfig(response, &metadata) + } + output := &UpdateServiceSyncConfigOutput{} + out.Result = output + + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + + body := io.TeeReader(response.Body, ringBuffer) + decoder := json.NewDecoder(body) + decoder.UseNumber() + var shape interface{} + if err := decoder.Decode(&shape); err != nil && err != io.EOF { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return out, metadata, err + } + + err = awsAwsjson10_deserializeOpDocumentUpdateServiceSyncConfigOutput(&output, shape) + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return out, metadata, err + } + + return out, metadata, err +} + +func awsAwsjson10_deserializeOpErrorUpdateServiceSyncConfig(response *smithyhttp.Response, metadata *middleware.Metadata) error { + var errorBuffer bytes.Buffer + if _, err := io.Copy(&errorBuffer, response.Body); err != nil { + return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} + } + errorBody := bytes.NewReader(errorBuffer.Bytes()) + + errorCode := "UnknownError" + errorMessage := errorCode + + headerCode := response.Header.Get("X-Amzn-ErrorType") + if len(headerCode) != 0 { + errorCode = restjson.SanitizeErrorCode(headerCode) + } + + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + + body := io.TeeReader(errorBody, ringBuffer) + decoder := json.NewDecoder(body) + decoder.UseNumber() + jsonCode, message, err := restjson.GetErrorInfo(decoder) + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return err + } + + errorBody.Seek(0, io.SeekStart) + if len(headerCode) == 0 && len(jsonCode) != 0 { + errorCode = restjson.SanitizeErrorCode(jsonCode) + } + if len(message) != 0 { + errorMessage = message + } + + switch { + case strings.EqualFold("AccessDeniedException", errorCode): + return awsAwsjson10_deserializeErrorAccessDeniedException(response, errorBody) + + case strings.EqualFold("ConflictException", errorCode): + return awsAwsjson10_deserializeErrorConflictException(response, errorBody) + + case strings.EqualFold("InternalServerException", errorCode): + return awsAwsjson10_deserializeErrorInternalServerException(response, errorBody) + + case strings.EqualFold("ResourceNotFoundException", errorCode): + return awsAwsjson10_deserializeErrorResourceNotFoundException(response, errorBody) + + case strings.EqualFold("ThrottlingException", errorCode): + return awsAwsjson10_deserializeErrorThrottlingException(response, errorBody) + + case strings.EqualFold("ValidationException", errorCode): + return awsAwsjson10_deserializeErrorValidationException(response, errorBody) + + default: + genericError := &smithy.GenericAPIError{ + Code: errorCode, + Message: errorMessage, + } + return genericError + + } +} + +type awsAwsjson10_deserializeOpUpdateServiceTemplate struct { +} + +func (*awsAwsjson10_deserializeOpUpdateServiceTemplate) ID() string { + return "OperationDeserializer" +} + +func (m *awsAwsjson10_deserializeOpUpdateServiceTemplate) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( + out middleware.DeserializeOutput, metadata middleware.Metadata, err error, +) { + out, metadata, err = next.HandleDeserialize(ctx, in) + if err != nil { + return out, metadata, err + } + + response, ok := out.RawResponse.(*smithyhttp.Response) + if !ok { + return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} + } + + if response.StatusCode < 200 || response.StatusCode >= 300 { + return out, metadata, awsAwsjson10_deserializeOpErrorUpdateServiceTemplate(response, &metadata) + } + output := &UpdateServiceTemplateOutput{} + out.Result = output + + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + + body := io.TeeReader(response.Body, ringBuffer) + decoder := json.NewDecoder(body) + decoder.UseNumber() + var shape interface{} + if err := decoder.Decode(&shape); err != nil && err != io.EOF { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return out, metadata, err + } + + err = awsAwsjson10_deserializeOpDocumentUpdateServiceTemplateOutput(&output, shape) + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return out, metadata, err + } + + return out, metadata, err +} + +func awsAwsjson10_deserializeOpErrorUpdateServiceTemplate(response *smithyhttp.Response, metadata *middleware.Metadata) error { + var errorBuffer bytes.Buffer + if _, err := io.Copy(&errorBuffer, response.Body); err != nil { + return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} + } + errorBody := bytes.NewReader(errorBuffer.Bytes()) + + errorCode := "UnknownError" + errorMessage := errorCode + + headerCode := response.Header.Get("X-Amzn-ErrorType") + if len(headerCode) != 0 { + errorCode = restjson.SanitizeErrorCode(headerCode) + } + + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + + body := io.TeeReader(errorBody, ringBuffer) + decoder := json.NewDecoder(body) + decoder.UseNumber() + jsonCode, message, err := restjson.GetErrorInfo(decoder) + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return err + } + + errorBody.Seek(0, io.SeekStart) + if len(headerCode) == 0 && len(jsonCode) != 0 { + errorCode = restjson.SanitizeErrorCode(jsonCode) + } + if len(message) != 0 { + errorMessage = message + } + + switch { + case strings.EqualFold("AccessDeniedException", errorCode): + return awsAwsjson10_deserializeErrorAccessDeniedException(response, errorBody) + + case strings.EqualFold("ConflictException", errorCode): + return awsAwsjson10_deserializeErrorConflictException(response, errorBody) + + case strings.EqualFold("InternalServerException", errorCode): + return awsAwsjson10_deserializeErrorInternalServerException(response, errorBody) + + case strings.EqualFold("ResourceNotFoundException", errorCode): + return awsAwsjson10_deserializeErrorResourceNotFoundException(response, errorBody) + + case strings.EqualFold("ThrottlingException", errorCode): + return awsAwsjson10_deserializeErrorThrottlingException(response, errorBody) + + case strings.EqualFold("ValidationException", errorCode): + return awsAwsjson10_deserializeErrorValidationException(response, errorBody) + + default: + genericError := &smithy.GenericAPIError{ + Code: errorCode, + Message: errorMessage, + } + return genericError + + } +} + +type awsAwsjson10_deserializeOpUpdateServiceTemplateVersion struct { +} + +func (*awsAwsjson10_deserializeOpUpdateServiceTemplateVersion) ID() string { + return "OperationDeserializer" +} + +func (m *awsAwsjson10_deserializeOpUpdateServiceTemplateVersion) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( + out middleware.DeserializeOutput, metadata middleware.Metadata, err error, +) { + out, metadata, err = next.HandleDeserialize(ctx, in) + if err != nil { + return out, metadata, err + } + + response, ok := out.RawResponse.(*smithyhttp.Response) + if !ok { + return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} + } + + if response.StatusCode < 200 || response.StatusCode >= 300 { + return out, metadata, awsAwsjson10_deserializeOpErrorUpdateServiceTemplateVersion(response, &metadata) + } + output := &UpdateServiceTemplateVersionOutput{} + out.Result = output + + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + + body := io.TeeReader(response.Body, ringBuffer) + decoder := json.NewDecoder(body) + decoder.UseNumber() + var shape interface{} + if err := decoder.Decode(&shape); err != nil && err != io.EOF { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return out, metadata, err + } + + err = awsAwsjson10_deserializeOpDocumentUpdateServiceTemplateVersionOutput(&output, shape) + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return out, metadata, err + } + + return out, metadata, err +} + +func awsAwsjson10_deserializeOpErrorUpdateServiceTemplateVersion(response *smithyhttp.Response, metadata *middleware.Metadata) error { + var errorBuffer bytes.Buffer + if _, err := io.Copy(&errorBuffer, response.Body); err != nil { + return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} + } + errorBody := bytes.NewReader(errorBuffer.Bytes()) + + errorCode := "UnknownError" + errorMessage := errorCode + + headerCode := response.Header.Get("X-Amzn-ErrorType") + if len(headerCode) != 0 { + errorCode = restjson.SanitizeErrorCode(headerCode) + } + + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + + body := io.TeeReader(errorBody, ringBuffer) + decoder := json.NewDecoder(body) + decoder.UseNumber() + jsonCode, message, err := restjson.GetErrorInfo(decoder) + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return err + } + + errorBody.Seek(0, io.SeekStart) + if len(headerCode) == 0 && len(jsonCode) != 0 { + errorCode = restjson.SanitizeErrorCode(jsonCode) + } + if len(message) != 0 { + errorMessage = message + } + + switch { + case strings.EqualFold("AccessDeniedException", errorCode): + return awsAwsjson10_deserializeErrorAccessDeniedException(response, errorBody) + + case strings.EqualFold("ConflictException", errorCode): + return awsAwsjson10_deserializeErrorConflictException(response, errorBody) + + case strings.EqualFold("InternalServerException", errorCode): + return awsAwsjson10_deserializeErrorInternalServerException(response, errorBody) + + case strings.EqualFold("ResourceNotFoundException", errorCode): + return awsAwsjson10_deserializeErrorResourceNotFoundException(response, errorBody) + + case strings.EqualFold("ThrottlingException", errorCode): + return awsAwsjson10_deserializeErrorThrottlingException(response, errorBody) + + case strings.EqualFold("ValidationException", errorCode): + return awsAwsjson10_deserializeErrorValidationException(response, errorBody) + + default: + genericError := &smithy.GenericAPIError{ + Code: errorCode, + Message: errorMessage, + } + return genericError + + } +} + +type awsAwsjson10_deserializeOpUpdateTemplateSyncConfig struct { +} + +func (*awsAwsjson10_deserializeOpUpdateTemplateSyncConfig) ID() string { + return "OperationDeserializer" +} + +func (m *awsAwsjson10_deserializeOpUpdateTemplateSyncConfig) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( + out middleware.DeserializeOutput, metadata middleware.Metadata, err error, +) { + out, metadata, err = next.HandleDeserialize(ctx, in) + if err != nil { + return out, metadata, err + } + + response, ok := out.RawResponse.(*smithyhttp.Response) + if !ok { + return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} + } + + if response.StatusCode < 200 || response.StatusCode >= 300 { + return out, metadata, awsAwsjson10_deserializeOpErrorUpdateTemplateSyncConfig(response, &metadata) + } + output := &UpdateTemplateSyncConfigOutput{} + out.Result = output + + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + + body := io.TeeReader(response.Body, ringBuffer) + decoder := json.NewDecoder(body) + decoder.UseNumber() + var shape interface{} + if err := decoder.Decode(&shape); err != nil && err != io.EOF { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return out, metadata, err + } + + err = awsAwsjson10_deserializeOpDocumentUpdateTemplateSyncConfigOutput(&output, shape) + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return out, metadata, err + } + + return out, metadata, err +} + +func awsAwsjson10_deserializeOpErrorUpdateTemplateSyncConfig(response *smithyhttp.Response, metadata *middleware.Metadata) error { + var errorBuffer bytes.Buffer + if _, err := io.Copy(&errorBuffer, response.Body); err != nil { + return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} + } + errorBody := bytes.NewReader(errorBuffer.Bytes()) + + errorCode := "UnknownError" + errorMessage := errorCode + + headerCode := response.Header.Get("X-Amzn-ErrorType") + if len(headerCode) != 0 { + errorCode = restjson.SanitizeErrorCode(headerCode) + } + + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + + body := io.TeeReader(errorBody, ringBuffer) + decoder := json.NewDecoder(body) + decoder.UseNumber() + jsonCode, message, err := restjson.GetErrorInfo(decoder) + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return err + } + + errorBody.Seek(0, io.SeekStart) + if len(headerCode) == 0 && len(jsonCode) != 0 { + errorCode = restjson.SanitizeErrorCode(jsonCode) + } + if len(message) != 0 { + errorMessage = message + } + + switch { + case strings.EqualFold("AccessDeniedException", errorCode): + return awsAwsjson10_deserializeErrorAccessDeniedException(response, errorBody) + + case strings.EqualFold("ConflictException", errorCode): + return awsAwsjson10_deserializeErrorConflictException(response, errorBody) + + case strings.EqualFold("InternalServerException", errorCode): + return awsAwsjson10_deserializeErrorInternalServerException(response, errorBody) + + case strings.EqualFold("ResourceNotFoundException", errorCode): + return awsAwsjson10_deserializeErrorResourceNotFoundException(response, errorBody) + + case strings.EqualFold("ThrottlingException", errorCode): + return awsAwsjson10_deserializeErrorThrottlingException(response, errorBody) + + case strings.EqualFold("ValidationException", errorCode): + return awsAwsjson10_deserializeErrorValidationException(response, errorBody) + + default: + genericError := &smithy.GenericAPIError{ + Code: errorCode, + Message: errorMessage, + } + return genericError + + } +} + +func awsAwsjson10_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 := awsAwsjson10_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 awsAwsjson10_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 := awsAwsjson10_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 awsAwsjson10_deserializeErrorInternalServerException(response *smithyhttp.Response, errorBody *bytes.Reader) error { @@ -9995,6 +10994,15 @@ func awsAwsjson10_deserializeDocumentComponent(v **types.Component, value interf sv.EnvironmentName = ptr.String(jtv) } + case "lastClientRequestToken": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected String to be of type string, got %T instead", value) + } + sv.LastClientRequestToken = ptr.String(jtv) + } + case "lastDeploymentAttemptedAt": if value != nil { switch jtv := value.(type) { @@ -11778,6 +12786,40 @@ func awsAwsjson10_deserializeDocumentInternalServerException(v **types.InternalS return nil } +func awsAwsjson10_deserializeDocumentLatestSyncBlockers(v *[]types.SyncBlocker, 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.SyncBlocker + if *v == nil { + cv = []types.SyncBlocker{} + } else { + cv = *v + } + + for _, value := range shape { + var col types.SyncBlocker + destAddr := &col + if err := awsAwsjson10_deserializeDocumentSyncBlocker(&destAddr, value); err != nil { + return err + } + col = *destAddr + cv = append(cv, col) + + } + *v = cv + return nil +} + func awsAwsjson10_deserializeDocumentOutput(v **types.Output, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) @@ -12127,6 +13169,15 @@ func awsAwsjson10_deserializeDocumentRepositorySummary(v **types.RepositorySumma sv.Arn = ptr.String(jtv) } + case "connectionArn": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected Arn to be of type string, got %T instead", value) + } + sv.ConnectionArn = ptr.String(jtv) + } + case "name": if value != nil { jtv, ok := value.(string) @@ -13090,6 +14141,15 @@ func awsAwsjson10_deserializeDocumentServiceInstance(v **types.ServiceInstance, sv.EnvironmentName = ptr.String(jtv) } + case "lastClientRequestToken": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected String to be of type string, got %T instead", value) + } + sv.LastClientRequestToken = ptr.String(jtv) + } + case "lastDeploymentAttemptedAt": if value != nil { switch jtv := value.(type) { @@ -13698,17 +14758,147 @@ func awsAwsjson10_deserializeDocumentServiceSummaryList(v *[]types.ServiceSummar cv = *v } - for _, value := range shape { - var col types.ServiceSummary - destAddr := &col - if err := awsAwsjson10_deserializeDocumentServiceSummary(&destAddr, value); err != nil { - return err + for _, value := range shape { + var col types.ServiceSummary + destAddr := &col + if err := awsAwsjson10_deserializeDocumentServiceSummary(&destAddr, value); err != nil { + return err + } + col = *destAddr + cv = append(cv, col) + + } + *v = cv + return nil +} + +func awsAwsjson10_deserializeDocumentServiceSyncBlockerSummary(v **types.ServiceSyncBlockerSummary, 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.ServiceSyncBlockerSummary + if *v == nil { + sv = &types.ServiceSyncBlockerSummary{} + } else { + sv = *v + } + + for key, value := range shape { + switch key { + case "latestBlockers": + if err := awsAwsjson10_deserializeDocumentLatestSyncBlockers(&sv.LatestBlockers, value); err != nil { + return err + } + + case "serviceInstanceName": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected String to be of type string, got %T instead", value) + } + sv.ServiceInstanceName = 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) + } + + default: + _, _ = key, value + + } + } + *v = sv + return nil +} + +func awsAwsjson10_deserializeDocumentServiceSyncConfig(v **types.ServiceSyncConfig, 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.ServiceSyncConfig + if *v == nil { + sv = &types.ServiceSyncConfig{} + } else { + sv = *v + } + + for key, value := range shape { + switch key { + case "branch": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected GitBranchName to be of type string, got %T instead", value) + } + sv.Branch = ptr.String(jtv) + } + + case "filePath": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected OpsFilePath to be of type string, got %T instead", value) + } + sv.FilePath = ptr.String(jtv) + } + + case "repositoryName": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected RepositoryName to be of type string, got %T instead", value) + } + sv.RepositoryName = ptr.String(jtv) + } + + case "repositoryProvider": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected RepositoryProvider to be of type string, got %T instead", value) + } + sv.RepositoryProvider = types.RepositoryProvider(jtv) + } + + case "serviceName": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value) + } + sv.ServiceName = ptr.String(jtv) + } + + default: + _, _ = key, value + } - col = *destAddr - cv = append(cv, col) - } - *v = cv + *v = sv return nil } @@ -14348,6 +15538,202 @@ func awsAwsjson10_deserializeDocumentServiceTemplateVersionSummaryList(v *[]type return nil } +func awsAwsjson10_deserializeDocumentSyncBlocker(v **types.SyncBlocker, 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.SyncBlocker + if *v == nil { + sv = &types.SyncBlocker{} + } else { + sv = *v + } + + for key, value := range shape { + switch key { + case "contexts": + if err := awsAwsjson10_deserializeDocumentSyncBlockerContexts(&sv.Contexts, 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 "createdReason": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected String to be of type string, got %T instead", value) + } + sv.CreatedReason = ptr.String(jtv) + } + + 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 "resolvedAt": + if value != nil { + switch jtv := value.(type) { + case json.Number: + f64, err := jtv.Float64() + if err != nil { + return err + } + sv.ResolvedAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) + + default: + return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value) + + } + } + + case "resolvedReason": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected String to be of type string, got %T instead", value) + } + sv.ResolvedReason = ptr.String(jtv) + } + + case "status": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected BlockerStatus to be of type string, got %T instead", value) + } + sv.Status = types.BlockerStatus(jtv) + } + + case "type": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected BlockerType to be of type string, got %T instead", value) + } + sv.Type = types.BlockerType(jtv) + } + + default: + _, _ = key, value + + } + } + *v = sv + return nil +} + +func awsAwsjson10_deserializeDocumentSyncBlockerContext(v **types.SyncBlockerContext, 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.SyncBlockerContext + if *v == nil { + sv = &types.SyncBlockerContext{} + } 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 String 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 String to be of type string, got %T instead", value) + } + sv.Value = ptr.String(jtv) + } + + default: + _, _ = key, value + + } + } + *v = sv + return nil +} + +func awsAwsjson10_deserializeDocumentSyncBlockerContexts(v *[]types.SyncBlockerContext, 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.SyncBlockerContext + if *v == nil { + cv = []types.SyncBlockerContext{} + } else { + cv = *v + } + + for _, value := range shape { + var col types.SyncBlockerContext + destAddr := &col + if err := awsAwsjson10_deserializeDocumentSyncBlockerContext(&destAddr, value); err != nil { + return err + } + col = *destAddr + cv = append(cv, col) + + } + *v = cv + return nil +} + func awsAwsjson10_deserializeDocumentTag(v **types.Tag, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) @@ -14861,17 +16247,89 @@ func awsAwsjson10_deserializeOpDocumentCreateEnvironmentOutput(v **CreateEnviron return fmt.Errorf("unexpected JSON type %v", value) } - var sv *CreateEnvironmentOutput + var sv *CreateEnvironmentOutput + if *v == nil { + sv = &CreateEnvironmentOutput{} + } else { + sv = *v + } + + for key, value := range shape { + switch key { + case "environment": + if err := awsAwsjson10_deserializeDocumentEnvironment(&sv.Environment, value); err != nil { + return err + } + + default: + _, _ = key, value + + } + } + *v = sv + return nil +} + +func awsAwsjson10_deserializeOpDocumentCreateEnvironmentTemplateOutput(v **CreateEnvironmentTemplateOutput, 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 *CreateEnvironmentTemplateOutput + if *v == nil { + sv = &CreateEnvironmentTemplateOutput{} + } else { + sv = *v + } + + for key, value := range shape { + switch key { + case "environmentTemplate": + if err := awsAwsjson10_deserializeDocumentEnvironmentTemplate(&sv.EnvironmentTemplate, value); err != nil { + return err + } + + default: + _, _ = key, value + + } + } + *v = sv + return nil +} + +func awsAwsjson10_deserializeOpDocumentCreateEnvironmentTemplateVersionOutput(v **CreateEnvironmentTemplateVersionOutput, 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 *CreateEnvironmentTemplateVersionOutput if *v == nil { - sv = &CreateEnvironmentOutput{} + sv = &CreateEnvironmentTemplateVersionOutput{} } else { sv = *v } for key, value := range shape { switch key { - case "environment": - if err := awsAwsjson10_deserializeDocumentEnvironment(&sv.Environment, value); err != nil { + case "environmentTemplateVersion": + if err := awsAwsjson10_deserializeDocumentEnvironmentTemplateVersion(&sv.EnvironmentTemplateVersion, value); err != nil { return err } @@ -14884,7 +16342,7 @@ func awsAwsjson10_deserializeOpDocumentCreateEnvironmentOutput(v **CreateEnviron return nil } -func awsAwsjson10_deserializeOpDocumentCreateEnvironmentTemplateOutput(v **CreateEnvironmentTemplateOutput, value interface{}) error { +func awsAwsjson10_deserializeOpDocumentCreateRepositoryOutput(v **CreateRepositoryOutput, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -14897,17 +16355,17 @@ func awsAwsjson10_deserializeOpDocumentCreateEnvironmentTemplateOutput(v **Creat return fmt.Errorf("unexpected JSON type %v", value) } - var sv *CreateEnvironmentTemplateOutput + var sv *CreateRepositoryOutput if *v == nil { - sv = &CreateEnvironmentTemplateOutput{} + sv = &CreateRepositoryOutput{} } else { sv = *v } for key, value := range shape { switch key { - case "environmentTemplate": - if err := awsAwsjson10_deserializeDocumentEnvironmentTemplate(&sv.EnvironmentTemplate, value); err != nil { + case "repository": + if err := awsAwsjson10_deserializeDocumentRepository(&sv.Repository, value); err != nil { return err } @@ -14920,7 +16378,7 @@ func awsAwsjson10_deserializeOpDocumentCreateEnvironmentTemplateOutput(v **Creat return nil } -func awsAwsjson10_deserializeOpDocumentCreateEnvironmentTemplateVersionOutput(v **CreateEnvironmentTemplateVersionOutput, value interface{}) error { +func awsAwsjson10_deserializeOpDocumentCreateServiceInstanceOutput(v **CreateServiceInstanceOutput, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -14933,17 +16391,17 @@ func awsAwsjson10_deserializeOpDocumentCreateEnvironmentTemplateVersionOutput(v return fmt.Errorf("unexpected JSON type %v", value) } - var sv *CreateEnvironmentTemplateVersionOutput + var sv *CreateServiceInstanceOutput if *v == nil { - sv = &CreateEnvironmentTemplateVersionOutput{} + sv = &CreateServiceInstanceOutput{} } else { sv = *v } for key, value := range shape { switch key { - case "environmentTemplateVersion": - if err := awsAwsjson10_deserializeDocumentEnvironmentTemplateVersion(&sv.EnvironmentTemplateVersion, value); err != nil { + case "serviceInstance": + if err := awsAwsjson10_deserializeDocumentServiceInstance(&sv.ServiceInstance, value); err != nil { return err } @@ -14956,7 +16414,7 @@ func awsAwsjson10_deserializeOpDocumentCreateEnvironmentTemplateVersionOutput(v return nil } -func awsAwsjson10_deserializeOpDocumentCreateRepositoryOutput(v **CreateRepositoryOutput, value interface{}) error { +func awsAwsjson10_deserializeOpDocumentCreateServiceOutput(v **CreateServiceOutput, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -14969,17 +16427,17 @@ func awsAwsjson10_deserializeOpDocumentCreateRepositoryOutput(v **CreateReposito return fmt.Errorf("unexpected JSON type %v", value) } - var sv *CreateRepositoryOutput + var sv *CreateServiceOutput if *v == nil { - sv = &CreateRepositoryOutput{} + sv = &CreateServiceOutput{} } else { sv = *v } for key, value := range shape { switch key { - case "repository": - if err := awsAwsjson10_deserializeDocumentRepository(&sv.Repository, value); err != nil { + case "service": + if err := awsAwsjson10_deserializeDocumentService(&sv.Service, value); err != nil { return err } @@ -14992,7 +16450,7 @@ func awsAwsjson10_deserializeOpDocumentCreateRepositoryOutput(v **CreateReposito return nil } -func awsAwsjson10_deserializeOpDocumentCreateServiceOutput(v **CreateServiceOutput, value interface{}) error { +func awsAwsjson10_deserializeOpDocumentCreateServiceSyncConfigOutput(v **CreateServiceSyncConfigOutput, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -15005,17 +16463,17 @@ func awsAwsjson10_deserializeOpDocumentCreateServiceOutput(v **CreateServiceOutp return fmt.Errorf("unexpected JSON type %v", value) } - var sv *CreateServiceOutput + var sv *CreateServiceSyncConfigOutput if *v == nil { - sv = &CreateServiceOutput{} + sv = &CreateServiceSyncConfigOutput{} } else { sv = *v } for key, value := range shape { switch key { - case "service": - if err := awsAwsjson10_deserializeDocumentService(&sv.Service, value); err != nil { + case "serviceSyncConfig": + if err := awsAwsjson10_deserializeDocumentServiceSyncConfig(&sv.ServiceSyncConfig, value); err != nil { return err } @@ -15388,6 +16846,42 @@ func awsAwsjson10_deserializeOpDocumentDeleteServiceOutput(v **DeleteServiceOutp return nil } +func awsAwsjson10_deserializeOpDocumentDeleteServiceSyncConfigOutput(v **DeleteServiceSyncConfigOutput, 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 *DeleteServiceSyncConfigOutput + if *v == nil { + sv = &DeleteServiceSyncConfigOutput{} + } else { + sv = *v + } + + for key, value := range shape { + switch key { + case "serviceSyncConfig": + if err := awsAwsjson10_deserializeDocumentServiceSyncConfig(&sv.ServiceSyncConfig, value); err != nil { + return err + } + + default: + _, _ = key, value + + } + } + *v = sv + return nil +} + func awsAwsjson10_deserializeOpDocumentDeleteServiceTemplateOutput(v **DeleteServiceTemplateOutput, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) @@ -15856,6 +17350,52 @@ func awsAwsjson10_deserializeOpDocumentGetServiceInstanceOutput(v **GetServiceIn return nil } +func awsAwsjson10_deserializeOpDocumentGetServiceInstanceSyncStatusOutput(v **GetServiceInstanceSyncStatusOutput, 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 *GetServiceInstanceSyncStatusOutput + if *v == nil { + sv = &GetServiceInstanceSyncStatusOutput{} + } else { + sv = *v + } + + for key, value := range shape { + switch key { + case "desiredState": + if err := awsAwsjson10_deserializeDocumentRevision(&sv.DesiredState, value); err != nil { + return err + } + + case "latestSuccessfulSync": + if err := awsAwsjson10_deserializeDocumentResourceSyncAttempt(&sv.LatestSuccessfulSync, value); err != nil { + return err + } + + case "latestSync": + if err := awsAwsjson10_deserializeDocumentResourceSyncAttempt(&sv.LatestSync, value); err != nil { + return err + } + + default: + _, _ = key, value + + } + } + *v = sv + return nil +} + func awsAwsjson10_deserializeOpDocumentGetServiceOutput(v **GetServiceOutput, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) @@ -15892,6 +17432,78 @@ func awsAwsjson10_deserializeOpDocumentGetServiceOutput(v **GetServiceOutput, va return nil } +func awsAwsjson10_deserializeOpDocumentGetServiceSyncBlockerSummaryOutput(v **GetServiceSyncBlockerSummaryOutput, 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 *GetServiceSyncBlockerSummaryOutput + if *v == nil { + sv = &GetServiceSyncBlockerSummaryOutput{} + } else { + sv = *v + } + + for key, value := range shape { + switch key { + case "serviceSyncBlockerSummary": + if err := awsAwsjson10_deserializeDocumentServiceSyncBlockerSummary(&sv.ServiceSyncBlockerSummary, value); err != nil { + return err + } + + default: + _, _ = key, value + + } + } + *v = sv + return nil +} + +func awsAwsjson10_deserializeOpDocumentGetServiceSyncConfigOutput(v **GetServiceSyncConfigOutput, 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 *GetServiceSyncConfigOutput + if *v == nil { + sv = &GetServiceSyncConfigOutput{} + } else { + sv = *v + } + + for key, value := range shape { + switch key { + case "serviceSyncConfig": + if err := awsAwsjson10_deserializeDocumentServiceSyncConfig(&sv.ServiceSyncConfig, value); err != nil { + return err + } + + default: + _, _ = key, value + + } + } + *v = sv + return nil +} + func awsAwsjson10_deserializeOpDocumentGetServiceTemplateOutput(v **GetServiceTemplateOutput, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) @@ -17399,6 +19011,96 @@ func awsAwsjson10_deserializeOpDocumentUpdateServicePipelineOutput(v **UpdateSer return nil } +func awsAwsjson10_deserializeOpDocumentUpdateServiceSyncBlockerOutput(v **UpdateServiceSyncBlockerOutput, 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 *UpdateServiceSyncBlockerOutput + if *v == nil { + sv = &UpdateServiceSyncBlockerOutput{} + } else { + sv = *v + } + + for key, value := range shape { + switch key { + case "serviceInstanceName": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value) + } + sv.ServiceInstanceName = ptr.String(jtv) + } + + case "serviceName": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value) + } + sv.ServiceName = ptr.String(jtv) + } + + case "serviceSyncBlocker": + if err := awsAwsjson10_deserializeDocumentSyncBlocker(&sv.ServiceSyncBlocker, value); err != nil { + return err + } + + default: + _, _ = key, value + + } + } + *v = sv + return nil +} + +func awsAwsjson10_deserializeOpDocumentUpdateServiceSyncConfigOutput(v **UpdateServiceSyncConfigOutput, 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 *UpdateServiceSyncConfigOutput + if *v == nil { + sv = &UpdateServiceSyncConfigOutput{} + } else { + sv = *v + } + + for key, value := range shape { + switch key { + case "serviceSyncConfig": + if err := awsAwsjson10_deserializeDocumentServiceSyncConfig(&sv.ServiceSyncConfig, value); err != nil { + return err + } + + default: + _, _ = key, value + + } + } + *v = sv + return nil +} + func awsAwsjson10_deserializeOpDocumentUpdateServiceTemplateOutput(v **UpdateServiceTemplateOutput, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) diff --git a/service/proton/generated.json b/service/proton/generated.json index ca7cb4c0f31..2550baba8bd 100644 --- a/service/proton/generated.json +++ b/service/proton/generated.json @@ -21,6 +21,8 @@ "api_op_CreateEnvironmentTemplateVersion.go", "api_op_CreateRepository.go", "api_op_CreateService.go", + "api_op_CreateServiceInstance.go", + "api_op_CreateServiceSyncConfig.go", "api_op_CreateServiceTemplate.go", "api_op_CreateServiceTemplateVersion.go", "api_op_CreateTemplateSyncConfig.go", @@ -31,6 +33,7 @@ "api_op_DeleteEnvironmentTemplateVersion.go", "api_op_DeleteRepository.go", "api_op_DeleteService.go", + "api_op_DeleteServiceSyncConfig.go", "api_op_DeleteServiceTemplate.go", "api_op_DeleteServiceTemplateVersion.go", "api_op_DeleteTemplateSyncConfig.go", @@ -45,6 +48,9 @@ "api_op_GetResourcesSummary.go", "api_op_GetService.go", "api_op_GetServiceInstance.go", + "api_op_GetServiceInstanceSyncStatus.go", + "api_op_GetServiceSyncBlockerSummary.go", + "api_op_GetServiceSyncConfig.go", "api_op_GetServiceTemplate.go", "api_op_GetServiceTemplateVersion.go", "api_op_GetTemplateSyncConfig.go", @@ -82,6 +88,8 @@ "api_op_UpdateService.go", "api_op_UpdateServiceInstance.go", "api_op_UpdateServicePipeline.go", + "api_op_UpdateServiceSyncBlocker.go", + "api_op_UpdateServiceSyncConfig.go", "api_op_UpdateServiceTemplate.go", "api_op_UpdateServiceTemplateVersion.go", "api_op_UpdateTemplateSyncConfig.go", diff --git a/service/proton/serializers.go b/service/proton/serializers.go index bbcaa1570f2..9c7f47d3db9 100644 --- a/service/proton/serializers.go +++ b/service/proton/serializers.go @@ -675,6 +675,116 @@ func (m *awsAwsjson10_serializeOpCreateService) HandleSerialize(ctx context.Cont return next.HandleSerialize(ctx, in) } +type awsAwsjson10_serializeOpCreateServiceInstance struct { +} + +func (*awsAwsjson10_serializeOpCreateServiceInstance) ID() string { + return "OperationSerializer" +} + +func (m *awsAwsjson10_serializeOpCreateServiceInstance) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( + out middleware.SerializeOutput, metadata middleware.Metadata, err error, +) { + request, ok := in.Request.(*smithyhttp.Request) + if !ok { + return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} + } + + input, ok := in.Parameters.(*CreateServiceInstanceInput) + _ = input + if !ok { + return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} + } + + operationPath := "/" + if len(request.Request.URL.Path) == 0 { + request.Request.URL.Path = operationPath + } else { + request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath) + if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' { + request.Request.URL.Path += "/" + } + } + request.Request.Method = "POST" + httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) + if err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.0") + httpBindingEncoder.SetHeader("X-Amz-Target").String("AwsProton20200720.CreateServiceInstance") + + jsonEncoder := smithyjson.NewEncoder() + if err := awsAwsjson10_serializeOpDocumentCreateServiceInstanceInput(input, jsonEncoder.Value); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + in.Request = request + + return next.HandleSerialize(ctx, in) +} + +type awsAwsjson10_serializeOpCreateServiceSyncConfig struct { +} + +func (*awsAwsjson10_serializeOpCreateServiceSyncConfig) ID() string { + return "OperationSerializer" +} + +func (m *awsAwsjson10_serializeOpCreateServiceSyncConfig) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( + out middleware.SerializeOutput, metadata middleware.Metadata, err error, +) { + request, ok := in.Request.(*smithyhttp.Request) + if !ok { + return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} + } + + input, ok := in.Parameters.(*CreateServiceSyncConfigInput) + _ = input + if !ok { + return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} + } + + operationPath := "/" + if len(request.Request.URL.Path) == 0 { + request.Request.URL.Path = operationPath + } else { + request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath) + if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' { + request.Request.URL.Path += "/" + } + } + request.Request.Method = "POST" + httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) + if err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.0") + httpBindingEncoder.SetHeader("X-Amz-Target").String("AwsProton20200720.CreateServiceSyncConfig") + + jsonEncoder := smithyjson.NewEncoder() + if err := awsAwsjson10_serializeOpDocumentCreateServiceSyncConfigInput(input, jsonEncoder.Value); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + in.Request = request + + return next.HandleSerialize(ctx, in) +} + type awsAwsjson10_serializeOpCreateServiceTemplate struct { } @@ -1225,6 +1335,61 @@ func (m *awsAwsjson10_serializeOpDeleteService) HandleSerialize(ctx context.Cont return next.HandleSerialize(ctx, in) } +type awsAwsjson10_serializeOpDeleteServiceSyncConfig struct { +} + +func (*awsAwsjson10_serializeOpDeleteServiceSyncConfig) ID() string { + return "OperationSerializer" +} + +func (m *awsAwsjson10_serializeOpDeleteServiceSyncConfig) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( + out middleware.SerializeOutput, metadata middleware.Metadata, err error, +) { + request, ok := in.Request.(*smithyhttp.Request) + if !ok { + return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} + } + + input, ok := in.Parameters.(*DeleteServiceSyncConfigInput) + _ = input + if !ok { + return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} + } + + operationPath := "/" + if len(request.Request.URL.Path) == 0 { + request.Request.URL.Path = operationPath + } else { + request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath) + if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' { + request.Request.URL.Path += "/" + } + } + request.Request.Method = "POST" + httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) + if err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.0") + httpBindingEncoder.SetHeader("X-Amz-Target").String("AwsProton20200720.DeleteServiceSyncConfig") + + jsonEncoder := smithyjson.NewEncoder() + if err := awsAwsjson10_serializeOpDocumentDeleteServiceSyncConfigInput(input, jsonEncoder.Value); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + in.Request = request + + return next.HandleSerialize(ctx, in) +} + type awsAwsjson10_serializeOpDeleteServiceTemplate struct { } @@ -1995,6 +2160,171 @@ func (m *awsAwsjson10_serializeOpGetServiceInstance) HandleSerialize(ctx context return next.HandleSerialize(ctx, in) } +type awsAwsjson10_serializeOpGetServiceInstanceSyncStatus struct { +} + +func (*awsAwsjson10_serializeOpGetServiceInstanceSyncStatus) ID() string { + return "OperationSerializer" +} + +func (m *awsAwsjson10_serializeOpGetServiceInstanceSyncStatus) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( + out middleware.SerializeOutput, metadata middleware.Metadata, err error, +) { + request, ok := in.Request.(*smithyhttp.Request) + if !ok { + return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} + } + + input, ok := in.Parameters.(*GetServiceInstanceSyncStatusInput) + _ = input + if !ok { + return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} + } + + operationPath := "/" + if len(request.Request.URL.Path) == 0 { + request.Request.URL.Path = operationPath + } else { + request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath) + if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' { + request.Request.URL.Path += "/" + } + } + request.Request.Method = "POST" + httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) + if err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.0") + httpBindingEncoder.SetHeader("X-Amz-Target").String("AwsProton20200720.GetServiceInstanceSyncStatus") + + jsonEncoder := smithyjson.NewEncoder() + if err := awsAwsjson10_serializeOpDocumentGetServiceInstanceSyncStatusInput(input, jsonEncoder.Value); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + in.Request = request + + return next.HandleSerialize(ctx, in) +} + +type awsAwsjson10_serializeOpGetServiceSyncBlockerSummary struct { +} + +func (*awsAwsjson10_serializeOpGetServiceSyncBlockerSummary) ID() string { + return "OperationSerializer" +} + +func (m *awsAwsjson10_serializeOpGetServiceSyncBlockerSummary) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( + out middleware.SerializeOutput, metadata middleware.Metadata, err error, +) { + request, ok := in.Request.(*smithyhttp.Request) + if !ok { + return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} + } + + input, ok := in.Parameters.(*GetServiceSyncBlockerSummaryInput) + _ = input + if !ok { + return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} + } + + operationPath := "/" + if len(request.Request.URL.Path) == 0 { + request.Request.URL.Path = operationPath + } else { + request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath) + if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' { + request.Request.URL.Path += "/" + } + } + request.Request.Method = "POST" + httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) + if err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.0") + httpBindingEncoder.SetHeader("X-Amz-Target").String("AwsProton20200720.GetServiceSyncBlockerSummary") + + jsonEncoder := smithyjson.NewEncoder() + if err := awsAwsjson10_serializeOpDocumentGetServiceSyncBlockerSummaryInput(input, jsonEncoder.Value); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + in.Request = request + + return next.HandleSerialize(ctx, in) +} + +type awsAwsjson10_serializeOpGetServiceSyncConfig struct { +} + +func (*awsAwsjson10_serializeOpGetServiceSyncConfig) ID() string { + return "OperationSerializer" +} + +func (m *awsAwsjson10_serializeOpGetServiceSyncConfig) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( + out middleware.SerializeOutput, metadata middleware.Metadata, err error, +) { + request, ok := in.Request.(*smithyhttp.Request) + if !ok { + return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} + } + + input, ok := in.Parameters.(*GetServiceSyncConfigInput) + _ = input + if !ok { + return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} + } + + operationPath := "/" + if len(request.Request.URL.Path) == 0 { + request.Request.URL.Path = operationPath + } else { + request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath) + if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' { + request.Request.URL.Path += "/" + } + } + request.Request.Method = "POST" + httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) + if err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.0") + httpBindingEncoder.SetHeader("X-Amz-Target").String("AwsProton20200720.GetServiceSyncConfig") + + jsonEncoder := smithyjson.NewEncoder() + if err := awsAwsjson10_serializeOpDocumentGetServiceSyncConfigInput(input, jsonEncoder.Value); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + in.Request = request + + return next.HandleSerialize(ctx, in) +} + type awsAwsjson10_serializeOpGetServiceTemplate struct { } @@ -3629,7 +3959,117 @@ func (m *awsAwsjson10_serializeOpUpdateComponent) HandleSerialize(ctx context.Co httpBindingEncoder.SetHeader("X-Amz-Target").String("AwsProton20200720.UpdateComponent") jsonEncoder := smithyjson.NewEncoder() - if err := awsAwsjson10_serializeOpDocumentUpdateComponentInput(input, jsonEncoder.Value); err != nil { + if err := awsAwsjson10_serializeOpDocumentUpdateComponentInput(input, jsonEncoder.Value); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + in.Request = request + + return next.HandleSerialize(ctx, in) +} + +type awsAwsjson10_serializeOpUpdateEnvironment struct { +} + +func (*awsAwsjson10_serializeOpUpdateEnvironment) ID() string { + return "OperationSerializer" +} + +func (m *awsAwsjson10_serializeOpUpdateEnvironment) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( + out middleware.SerializeOutput, metadata middleware.Metadata, err error, +) { + request, ok := in.Request.(*smithyhttp.Request) + if !ok { + return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} + } + + input, ok := in.Parameters.(*UpdateEnvironmentInput) + _ = input + if !ok { + return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} + } + + operationPath := "/" + if len(request.Request.URL.Path) == 0 { + request.Request.URL.Path = operationPath + } else { + request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath) + if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' { + request.Request.URL.Path += "/" + } + } + request.Request.Method = "POST" + httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) + if err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.0") + httpBindingEncoder.SetHeader("X-Amz-Target").String("AwsProton20200720.UpdateEnvironment") + + jsonEncoder := smithyjson.NewEncoder() + if err := awsAwsjson10_serializeOpDocumentUpdateEnvironmentInput(input, jsonEncoder.Value); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + in.Request = request + + return next.HandleSerialize(ctx, in) +} + +type awsAwsjson10_serializeOpUpdateEnvironmentAccountConnection struct { +} + +func (*awsAwsjson10_serializeOpUpdateEnvironmentAccountConnection) ID() string { + return "OperationSerializer" +} + +func (m *awsAwsjson10_serializeOpUpdateEnvironmentAccountConnection) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( + out middleware.SerializeOutput, metadata middleware.Metadata, err error, +) { + request, ok := in.Request.(*smithyhttp.Request) + if !ok { + return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} + } + + input, ok := in.Parameters.(*UpdateEnvironmentAccountConnectionInput) + _ = input + if !ok { + return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} + } + + operationPath := "/" + if len(request.Request.URL.Path) == 0 { + request.Request.URL.Path = operationPath + } else { + request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath) + if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' { + request.Request.URL.Path += "/" + } + } + request.Request.Method = "POST" + httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) + if err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.0") + httpBindingEncoder.SetHeader("X-Amz-Target").String("AwsProton20200720.UpdateEnvironmentAccountConnection") + + jsonEncoder := smithyjson.NewEncoder() + if err := awsAwsjson10_serializeOpDocumentUpdateEnvironmentAccountConnectionInput(input, jsonEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -3645,14 +4085,14 @@ func (m *awsAwsjson10_serializeOpUpdateComponent) HandleSerialize(ctx context.Co return next.HandleSerialize(ctx, in) } -type awsAwsjson10_serializeOpUpdateEnvironment struct { +type awsAwsjson10_serializeOpUpdateEnvironmentTemplate struct { } -func (*awsAwsjson10_serializeOpUpdateEnvironment) ID() string { +func (*awsAwsjson10_serializeOpUpdateEnvironmentTemplate) ID() string { return "OperationSerializer" } -func (m *awsAwsjson10_serializeOpUpdateEnvironment) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsAwsjson10_serializeOpUpdateEnvironmentTemplate) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { request, ok := in.Request.(*smithyhttp.Request) @@ -3660,7 +4100,7 @@ func (m *awsAwsjson10_serializeOpUpdateEnvironment) HandleSerialize(ctx context. return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*UpdateEnvironmentInput) + input, ok := in.Parameters.(*UpdateEnvironmentTemplateInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -3681,10 +4121,10 @@ func (m *awsAwsjson10_serializeOpUpdateEnvironment) HandleSerialize(ctx context. return out, metadata, &smithy.SerializationError{Err: err} } httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.0") - httpBindingEncoder.SetHeader("X-Amz-Target").String("AwsProton20200720.UpdateEnvironment") + httpBindingEncoder.SetHeader("X-Amz-Target").String("AwsProton20200720.UpdateEnvironmentTemplate") jsonEncoder := smithyjson.NewEncoder() - if err := awsAwsjson10_serializeOpDocumentUpdateEnvironmentInput(input, jsonEncoder.Value); err != nil { + if err := awsAwsjson10_serializeOpDocumentUpdateEnvironmentTemplateInput(input, jsonEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -3700,14 +4140,14 @@ func (m *awsAwsjson10_serializeOpUpdateEnvironment) HandleSerialize(ctx context. return next.HandleSerialize(ctx, in) } -type awsAwsjson10_serializeOpUpdateEnvironmentAccountConnection struct { +type awsAwsjson10_serializeOpUpdateEnvironmentTemplateVersion struct { } -func (*awsAwsjson10_serializeOpUpdateEnvironmentAccountConnection) ID() string { +func (*awsAwsjson10_serializeOpUpdateEnvironmentTemplateVersion) ID() string { return "OperationSerializer" } -func (m *awsAwsjson10_serializeOpUpdateEnvironmentAccountConnection) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsAwsjson10_serializeOpUpdateEnvironmentTemplateVersion) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { request, ok := in.Request.(*smithyhttp.Request) @@ -3715,7 +4155,7 @@ func (m *awsAwsjson10_serializeOpUpdateEnvironmentAccountConnection) HandleSeria return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*UpdateEnvironmentAccountConnectionInput) + input, ok := in.Parameters.(*UpdateEnvironmentTemplateVersionInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -3736,10 +4176,10 @@ func (m *awsAwsjson10_serializeOpUpdateEnvironmentAccountConnection) HandleSeria return out, metadata, &smithy.SerializationError{Err: err} } httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.0") - httpBindingEncoder.SetHeader("X-Amz-Target").String("AwsProton20200720.UpdateEnvironmentAccountConnection") + httpBindingEncoder.SetHeader("X-Amz-Target").String("AwsProton20200720.UpdateEnvironmentTemplateVersion") jsonEncoder := smithyjson.NewEncoder() - if err := awsAwsjson10_serializeOpDocumentUpdateEnvironmentAccountConnectionInput(input, jsonEncoder.Value); err != nil { + if err := awsAwsjson10_serializeOpDocumentUpdateEnvironmentTemplateVersionInput(input, jsonEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -3755,14 +4195,14 @@ func (m *awsAwsjson10_serializeOpUpdateEnvironmentAccountConnection) HandleSeria return next.HandleSerialize(ctx, in) } -type awsAwsjson10_serializeOpUpdateEnvironmentTemplate struct { +type awsAwsjson10_serializeOpUpdateService struct { } -func (*awsAwsjson10_serializeOpUpdateEnvironmentTemplate) ID() string { +func (*awsAwsjson10_serializeOpUpdateService) ID() string { return "OperationSerializer" } -func (m *awsAwsjson10_serializeOpUpdateEnvironmentTemplate) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsAwsjson10_serializeOpUpdateService) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { request, ok := in.Request.(*smithyhttp.Request) @@ -3770,7 +4210,7 @@ func (m *awsAwsjson10_serializeOpUpdateEnvironmentTemplate) HandleSerialize(ctx return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*UpdateEnvironmentTemplateInput) + input, ok := in.Parameters.(*UpdateServiceInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -3791,10 +4231,10 @@ func (m *awsAwsjson10_serializeOpUpdateEnvironmentTemplate) HandleSerialize(ctx return out, metadata, &smithy.SerializationError{Err: err} } httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.0") - httpBindingEncoder.SetHeader("X-Amz-Target").String("AwsProton20200720.UpdateEnvironmentTemplate") + httpBindingEncoder.SetHeader("X-Amz-Target").String("AwsProton20200720.UpdateService") jsonEncoder := smithyjson.NewEncoder() - if err := awsAwsjson10_serializeOpDocumentUpdateEnvironmentTemplateInput(input, jsonEncoder.Value); err != nil { + if err := awsAwsjson10_serializeOpDocumentUpdateServiceInput(input, jsonEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -3810,14 +4250,14 @@ func (m *awsAwsjson10_serializeOpUpdateEnvironmentTemplate) HandleSerialize(ctx return next.HandleSerialize(ctx, in) } -type awsAwsjson10_serializeOpUpdateEnvironmentTemplateVersion struct { +type awsAwsjson10_serializeOpUpdateServiceInstance struct { } -func (*awsAwsjson10_serializeOpUpdateEnvironmentTemplateVersion) ID() string { +func (*awsAwsjson10_serializeOpUpdateServiceInstance) ID() string { return "OperationSerializer" } -func (m *awsAwsjson10_serializeOpUpdateEnvironmentTemplateVersion) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsAwsjson10_serializeOpUpdateServiceInstance) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { request, ok := in.Request.(*smithyhttp.Request) @@ -3825,7 +4265,7 @@ func (m *awsAwsjson10_serializeOpUpdateEnvironmentTemplateVersion) HandleSeriali return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*UpdateEnvironmentTemplateVersionInput) + input, ok := in.Parameters.(*UpdateServiceInstanceInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -3846,10 +4286,10 @@ func (m *awsAwsjson10_serializeOpUpdateEnvironmentTemplateVersion) HandleSeriali return out, metadata, &smithy.SerializationError{Err: err} } httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.0") - httpBindingEncoder.SetHeader("X-Amz-Target").String("AwsProton20200720.UpdateEnvironmentTemplateVersion") + httpBindingEncoder.SetHeader("X-Amz-Target").String("AwsProton20200720.UpdateServiceInstance") jsonEncoder := smithyjson.NewEncoder() - if err := awsAwsjson10_serializeOpDocumentUpdateEnvironmentTemplateVersionInput(input, jsonEncoder.Value); err != nil { + if err := awsAwsjson10_serializeOpDocumentUpdateServiceInstanceInput(input, jsonEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -3865,14 +4305,14 @@ func (m *awsAwsjson10_serializeOpUpdateEnvironmentTemplateVersion) HandleSeriali return next.HandleSerialize(ctx, in) } -type awsAwsjson10_serializeOpUpdateService struct { +type awsAwsjson10_serializeOpUpdateServicePipeline struct { } -func (*awsAwsjson10_serializeOpUpdateService) ID() string { +func (*awsAwsjson10_serializeOpUpdateServicePipeline) ID() string { return "OperationSerializer" } -func (m *awsAwsjson10_serializeOpUpdateService) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsAwsjson10_serializeOpUpdateServicePipeline) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { request, ok := in.Request.(*smithyhttp.Request) @@ -3880,7 +4320,7 @@ func (m *awsAwsjson10_serializeOpUpdateService) HandleSerialize(ctx context.Cont return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*UpdateServiceInput) + input, ok := in.Parameters.(*UpdateServicePipelineInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -3901,10 +4341,10 @@ func (m *awsAwsjson10_serializeOpUpdateService) HandleSerialize(ctx context.Cont return out, metadata, &smithy.SerializationError{Err: err} } httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.0") - httpBindingEncoder.SetHeader("X-Amz-Target").String("AwsProton20200720.UpdateService") + httpBindingEncoder.SetHeader("X-Amz-Target").String("AwsProton20200720.UpdateServicePipeline") jsonEncoder := smithyjson.NewEncoder() - if err := awsAwsjson10_serializeOpDocumentUpdateServiceInput(input, jsonEncoder.Value); err != nil { + if err := awsAwsjson10_serializeOpDocumentUpdateServicePipelineInput(input, jsonEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -3920,14 +4360,14 @@ func (m *awsAwsjson10_serializeOpUpdateService) HandleSerialize(ctx context.Cont return next.HandleSerialize(ctx, in) } -type awsAwsjson10_serializeOpUpdateServiceInstance struct { +type awsAwsjson10_serializeOpUpdateServiceSyncBlocker struct { } -func (*awsAwsjson10_serializeOpUpdateServiceInstance) ID() string { +func (*awsAwsjson10_serializeOpUpdateServiceSyncBlocker) ID() string { return "OperationSerializer" } -func (m *awsAwsjson10_serializeOpUpdateServiceInstance) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsAwsjson10_serializeOpUpdateServiceSyncBlocker) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { request, ok := in.Request.(*smithyhttp.Request) @@ -3935,7 +4375,7 @@ func (m *awsAwsjson10_serializeOpUpdateServiceInstance) HandleSerialize(ctx cont return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*UpdateServiceInstanceInput) + input, ok := in.Parameters.(*UpdateServiceSyncBlockerInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -3956,10 +4396,10 @@ func (m *awsAwsjson10_serializeOpUpdateServiceInstance) HandleSerialize(ctx cont return out, metadata, &smithy.SerializationError{Err: err} } httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.0") - httpBindingEncoder.SetHeader("X-Amz-Target").String("AwsProton20200720.UpdateServiceInstance") + httpBindingEncoder.SetHeader("X-Amz-Target").String("AwsProton20200720.UpdateServiceSyncBlocker") jsonEncoder := smithyjson.NewEncoder() - if err := awsAwsjson10_serializeOpDocumentUpdateServiceInstanceInput(input, jsonEncoder.Value); err != nil { + if err := awsAwsjson10_serializeOpDocumentUpdateServiceSyncBlockerInput(input, jsonEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -3975,14 +4415,14 @@ func (m *awsAwsjson10_serializeOpUpdateServiceInstance) HandleSerialize(ctx cont return next.HandleSerialize(ctx, in) } -type awsAwsjson10_serializeOpUpdateServicePipeline struct { +type awsAwsjson10_serializeOpUpdateServiceSyncConfig struct { } -func (*awsAwsjson10_serializeOpUpdateServicePipeline) ID() string { +func (*awsAwsjson10_serializeOpUpdateServiceSyncConfig) ID() string { return "OperationSerializer" } -func (m *awsAwsjson10_serializeOpUpdateServicePipeline) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsAwsjson10_serializeOpUpdateServiceSyncConfig) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { request, ok := in.Request.(*smithyhttp.Request) @@ -3990,7 +4430,7 @@ func (m *awsAwsjson10_serializeOpUpdateServicePipeline) HandleSerialize(ctx cont return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*UpdateServicePipelineInput) + input, ok := in.Parameters.(*UpdateServiceSyncConfigInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -4011,10 +4451,10 @@ func (m *awsAwsjson10_serializeOpUpdateServicePipeline) HandleSerialize(ctx cont return out, metadata, &smithy.SerializationError{Err: err} } httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.0") - httpBindingEncoder.SetHeader("X-Amz-Target").String("AwsProton20200720.UpdateServicePipeline") + httpBindingEncoder.SetHeader("X-Amz-Target").String("AwsProton20200720.UpdateServiceSyncConfig") jsonEncoder := smithyjson.NewEncoder() - if err := awsAwsjson10_serializeOpDocumentUpdateServicePipelineInput(input, jsonEncoder.Value); err != nil { + if err := awsAwsjson10_serializeOpDocumentUpdateServiceSyncConfigInput(input, jsonEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -4503,6 +4943,11 @@ func awsAwsjson10_serializeOpDocumentCreateComponentInput(v *CreateComponentInpu object := value.Object() defer object.Close() + if v.ClientToken != nil { + ok := object.Key("clientToken") + ok.String(*v.ClientToken) + } + if v.Description != nil { ok := object.Key("description") ok.String(*v.Description) @@ -4841,6 +5286,82 @@ func awsAwsjson10_serializeOpDocumentCreateServiceInput(v *CreateServiceInput, v return nil } +func awsAwsjson10_serializeOpDocumentCreateServiceInstanceInput(v *CreateServiceInstanceInput, value smithyjson.Value) error { + object := value.Object() + defer object.Close() + + if v.ClientToken != nil { + ok := object.Key("clientToken") + ok.String(*v.ClientToken) + } + + if v.Name != nil { + ok := object.Key("name") + ok.String(*v.Name) + } + + if v.ServiceName != nil { + ok := object.Key("serviceName") + ok.String(*v.ServiceName) + } + + if v.Spec != nil { + ok := object.Key("spec") + ok.String(*v.Spec) + } + + if v.Tags != nil { + ok := object.Key("tags") + if err := awsAwsjson10_serializeDocumentTagList(v.Tags, ok); err != nil { + return err + } + } + + if v.TemplateMajorVersion != nil { + ok := object.Key("templateMajorVersion") + ok.String(*v.TemplateMajorVersion) + } + + if v.TemplateMinorVersion != nil { + ok := object.Key("templateMinorVersion") + ok.String(*v.TemplateMinorVersion) + } + + return nil +} + +func awsAwsjson10_serializeOpDocumentCreateServiceSyncConfigInput(v *CreateServiceSyncConfigInput, value smithyjson.Value) error { + object := value.Object() + defer object.Close() + + if v.Branch != nil { + ok := object.Key("branch") + ok.String(*v.Branch) + } + + if v.FilePath != nil { + ok := object.Key("filePath") + ok.String(*v.FilePath) + } + + if v.RepositoryName != nil { + ok := object.Key("repositoryName") + ok.String(*v.RepositoryName) + } + + if len(v.RepositoryProvider) > 0 { + ok := object.Key("repositoryProvider") + ok.String(string(v.RepositoryProvider)) + } + + if v.ServiceName != nil { + ok := object.Key("serviceName") + ok.String(*v.ServiceName) + } + + return nil +} + func awsAwsjson10_serializeOpDocumentCreateServiceTemplateInput(v *CreateServiceTemplateInput, value smithyjson.Value) error { object := value.Object() defer object.Close() @@ -5071,6 +5592,18 @@ func awsAwsjson10_serializeOpDocumentDeleteServiceInput(v *DeleteServiceInput, v return nil } +func awsAwsjson10_serializeOpDocumentDeleteServiceSyncConfigInput(v *DeleteServiceSyncConfigInput, value smithyjson.Value) error { + object := value.Object() + defer object.Close() + + if v.ServiceName != nil { + ok := object.Key("serviceName") + ok.String(*v.ServiceName) + } + + return nil +} + func awsAwsjson10_serializeOpDocumentDeleteServiceTemplateInput(v *DeleteServiceTemplateInput, value smithyjson.Value) error { object := value.Object() defer object.Close() @@ -5279,6 +5812,52 @@ func awsAwsjson10_serializeOpDocumentGetServiceInstanceInput(v *GetServiceInstan return nil } +func awsAwsjson10_serializeOpDocumentGetServiceInstanceSyncStatusInput(v *GetServiceInstanceSyncStatusInput, value smithyjson.Value) error { + object := value.Object() + defer object.Close() + + if v.ServiceInstanceName != nil { + ok := object.Key("serviceInstanceName") + ok.String(*v.ServiceInstanceName) + } + + if v.ServiceName != nil { + ok := object.Key("serviceName") + ok.String(*v.ServiceName) + } + + return nil +} + +func awsAwsjson10_serializeOpDocumentGetServiceSyncBlockerSummaryInput(v *GetServiceSyncBlockerSummaryInput, value smithyjson.Value) error { + object := value.Object() + defer object.Close() + + if v.ServiceInstanceName != nil { + ok := object.Key("serviceInstanceName") + ok.String(*v.ServiceInstanceName) + } + + if v.ServiceName != nil { + ok := object.Key("serviceName") + ok.String(*v.ServiceName) + } + + return nil +} + +func awsAwsjson10_serializeOpDocumentGetServiceSyncConfigInput(v *GetServiceSyncConfigInput, value smithyjson.Value) error { + object := value.Object() + defer object.Close() + + if v.ServiceName != nil { + ok := object.Key("serviceName") + ok.String(*v.ServiceName) + } + + return nil +} + func awsAwsjson10_serializeOpDocumentGetServiceTemplateInput(v *GetServiceTemplateInput, value smithyjson.Value) error { object := value.Object() defer object.Close() @@ -5915,6 +6494,11 @@ func awsAwsjson10_serializeOpDocumentUpdateComponentInput(v *UpdateComponentInpu object := value.Object() defer object.Close() + if v.ClientToken != nil { + ok := object.Key("clientToken") + ok.String(*v.ClientToken) + } + if len(v.DeploymentType) > 0 { ok := object.Key("deploymentType") ok.String(string(v.DeploymentType)) @@ -6124,6 +6708,11 @@ func awsAwsjson10_serializeOpDocumentUpdateServiceInstanceInput(v *UpdateService object := value.Object() defer object.Close() + if v.ClientToken != nil { + ok := object.Key("clientToken") + ok.String(*v.ClientToken) + } + if len(v.DeploymentType) > 0 { ok := object.Key("deploymentType") ok.String(string(v.DeploymentType)) @@ -6189,6 +6778,55 @@ func awsAwsjson10_serializeOpDocumentUpdateServicePipelineInput(v *UpdateService return nil } +func awsAwsjson10_serializeOpDocumentUpdateServiceSyncBlockerInput(v *UpdateServiceSyncBlockerInput, value smithyjson.Value) error { + object := value.Object() + defer object.Close() + + if v.Id != nil { + ok := object.Key("id") + ok.String(*v.Id) + } + + if v.ResolvedReason != nil { + ok := object.Key("resolvedReason") + ok.String(*v.ResolvedReason) + } + + return nil +} + +func awsAwsjson10_serializeOpDocumentUpdateServiceSyncConfigInput(v *UpdateServiceSyncConfigInput, value smithyjson.Value) error { + object := value.Object() + defer object.Close() + + if v.Branch != nil { + ok := object.Key("branch") + ok.String(*v.Branch) + } + + if v.FilePath != nil { + ok := object.Key("filePath") + ok.String(*v.FilePath) + } + + if v.RepositoryName != nil { + ok := object.Key("repositoryName") + ok.String(*v.RepositoryName) + } + + if len(v.RepositoryProvider) > 0 { + ok := object.Key("repositoryProvider") + ok.String(string(v.RepositoryProvider)) + } + + if v.ServiceName != nil { + ok := object.Key("serviceName") + ok.String(*v.ServiceName) + } + + return nil +} + func awsAwsjson10_serializeOpDocumentUpdateServiceTemplateInput(v *UpdateServiceTemplateInput, value smithyjson.Value) error { object := value.Object() defer object.Close() diff --git a/service/proton/types/enums.go b/service/proton/types/enums.go index 352790c3781..42a62152017 100644 --- a/service/proton/types/enums.go +++ b/service/proton/types/enums.go @@ -2,6 +2,40 @@ package types +type BlockerStatus string + +// Enum values for BlockerStatus +const ( + BlockerStatusActive BlockerStatus = "ACTIVE" + BlockerStatusResolved BlockerStatus = "RESOLVED" +) + +// Values returns all known values for BlockerStatus. Note that this can be +// expanded in the future, and so it is only as up to date as the client. The +// ordering of this slice is not guaranteed to be stable across updates. +func (BlockerStatus) Values() []BlockerStatus { + return []BlockerStatus{ + "ACTIVE", + "RESOLVED", + } +} + +type BlockerType string + +// Enum values for BlockerType +const ( + BlockerTypeAutomated BlockerType = "AUTOMATED" +) + +// Values returns all known values for BlockerType. Note that this can be expanded +// in the future, and so it is only as up to date as the client. The ordering of +// this slice is not guaranteed to be stable across updates. +func (BlockerType) Values() []BlockerType { + return []BlockerType{ + "AUTOMATED", + } +} + type ComponentDeploymentUpdateType string // Enum values for ComponentDeploymentUpdateType @@ -386,7 +420,10 @@ type SyncType string // Enum values for SyncType const ( + // Syncs environment and service templates to Proton. SyncTypeTemplateSync SyncType = "TEMPLATE_SYNC" + // Syncs services and service instances to Proton. + SyncTypeServiceSync SyncType = "SERVICE_SYNC" ) // Values returns all known values for SyncType. Note that this can be expanded in @@ -395,6 +432,7 @@ const ( func (SyncType) Values() []SyncType { return []SyncType{ "TEMPLATE_SYNC", + "SERVICE_SYNC", } } diff --git a/service/proton/types/types.go b/service/proton/types/types.go index e875c0c8502..529d23963d2 100644 --- a/service/proton/types/types.go +++ b/service/proton/types/types.go @@ -104,6 +104,9 @@ type Component struct { // A description of the component. Description *string + // The last token the client requested. + LastClientRequestToken *string + // The time when a deployment of the component was last attempted. LastDeploymentAttemptedAt *time.Time @@ -194,6 +197,7 @@ type CountsSummary struct { Components *ResourceCountsSummary // The total number of environment templates in the Amazon Web Services account. + // The environmentTemplates object will only contain total members. EnvironmentTemplates *ResourceCountsSummary // The staleness counts for Proton environments in the Amazon Web Services account. @@ -304,8 +308,8 @@ type Environment struct { // The linked repository that you use to host your rendered infrastructure // templates for self-managed provisioning. A linked repository is a repository - // that has been registered with Proton. For more information, see - // CreateRepository. + // that has been registered with Proton. For more information, see CreateRepository + // (https://docs.aws.amazon.com/proton/latest/APIReference/API_CreateRepository.html). ProvisioningRepository *RepositoryBranch // The environment spec. @@ -870,6 +874,12 @@ type RepositorySummary struct { // This member is required. Arn *string + // The Amazon Resource Name (ARN) of the of your connection that connects Proton to + // your repository. + // + // This member is required. + ConnectionArn *string + // The repository name. // // This member is required. @@ -1217,6 +1227,9 @@ type ServiceInstance struct { // The message associated with the service instance deployment status. DeploymentStatusMessage *string + // The last client request token received. + LastClientRequestToken *string + // The service spec that was used to create the service instance. // // This value conforms to the media type: application/yaml @@ -1387,6 +1400,67 @@ type ServiceSummary struct { noSmithyDocumentSerde } +// If a service instance is manually updated, Proton wants to prevent accidentally +// overriding a manual change. A blocker is created because of the manual update or +// deletion of a service instance. The summary describes the blocker as being +// active or resolved. +type ServiceSyncBlockerSummary struct { + + // The name of the service that you want to get the sync blocker summary for. If + // given a service instance name and a service name, it will return the blockers + // only applying to the instance that is blocked. If given only a service name, it + // will return the blockers that apply to all of the instances. In order to get the + // blockers for a single instance, you will need to make two distinct calls, one to + // get the sync blocker summary for the service and the other to get the sync + // blocker for the service instance. + // + // This member is required. + ServiceName *string + + // The latest active blockers for the synced service. + LatestBlockers []SyncBlocker + + // The name of the service instance that you want sync your service configuration + // with. + ServiceInstanceName *string + + noSmithyDocumentSerde +} + +// Detailed data of the service sync configuration. +type ServiceSyncConfig struct { + + // The name of the code repository branch that holds the service code Proton will + // sync with. + // + // This member is required. + Branch *string + + // The file path to the service sync configuration file. + // + // This member is required. + FilePath *string + + // The name of the code repository that holds the service code Proton will sync + // with. + // + // This member is required. + RepositoryName *string + + // The name of the repository provider that holds the repository Proton will sync + // with. + // + // This member is required. + RepositoryProvider RepositoryProvider + + // The name of the service that the service instance is added to. + // + // This member is required. + ServiceName *string + + noSmithyDocumentSerde +} + // Detailed data of an Proton service template resource. type ServiceTemplate struct { @@ -1589,6 +1663,62 @@ type ServiceTemplateVersionSummary struct { noSmithyDocumentSerde } +// Detailed data of the sync blocker. +type SyncBlocker struct { + + // The time when the sync blocker was created. + // + // This member is required. + CreatedAt *time.Time + + // The reason why the sync blocker was created. + // + // This member is required. + CreatedReason *string + + // The ID of the sync blocker. + // + // This member is required. + Id *string + + // The status of the sync blocker. + // + // This member is required. + Status BlockerStatus + + // The type of the sync blocker. + // + // This member is required. + Type BlockerType + + // The contexts for the sync blocker. + Contexts []SyncBlockerContext + + // The time the sync blocker was resolved. + ResolvedAt *time.Time + + // The reason the sync blocker was resolved. + ResolvedReason *string + + noSmithyDocumentSerde +} + +// Detailed data of the context of the sync blocker. +type SyncBlockerContext struct { + + // The key for the sync blocker context. + // + // This member is required. + Key *string + + // The value of the sync blocker context. + // + // This member is required. + Value *string + + noSmithyDocumentSerde +} + // A description of a resource tag. type Tag struct { diff --git a/service/proton/validators.go b/service/proton/validators.go index cf2c78f14f0..0b9bf5ca0ba 100644 --- a/service/proton/validators.go +++ b/service/proton/validators.go @@ -250,6 +250,46 @@ func (m *validateOpCreateService) HandleInitialize(ctx context.Context, in middl return next.HandleInitialize(ctx, in) } +type validateOpCreateServiceInstance struct { +} + +func (*validateOpCreateServiceInstance) ID() string { + return "OperationInputValidation" +} + +func (m *validateOpCreateServiceInstance) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + input, ok := in.Parameters.(*CreateServiceInstanceInput) + if !ok { + return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) + } + if err := validateOpCreateServiceInstanceInput(input); err != nil { + return out, metadata, err + } + return next.HandleInitialize(ctx, in) +} + +type validateOpCreateServiceSyncConfig struct { +} + +func (*validateOpCreateServiceSyncConfig) ID() string { + return "OperationInputValidation" +} + +func (m *validateOpCreateServiceSyncConfig) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + input, ok := in.Parameters.(*CreateServiceSyncConfigInput) + if !ok { + return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) + } + if err := validateOpCreateServiceSyncConfigInput(input); err != nil { + return out, metadata, err + } + return next.HandleInitialize(ctx, in) +} + type validateOpCreateServiceTemplate struct { } @@ -450,6 +490,26 @@ func (m *validateOpDeleteService) HandleInitialize(ctx context.Context, in middl return next.HandleInitialize(ctx, in) } +type validateOpDeleteServiceSyncConfig struct { +} + +func (*validateOpDeleteServiceSyncConfig) ID() string { + return "OperationInputValidation" +} + +func (m *validateOpDeleteServiceSyncConfig) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + input, ok := in.Parameters.(*DeleteServiceSyncConfigInput) + if !ok { + return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) + } + if err := validateOpDeleteServiceSyncConfigInput(input); err != nil { + return out, metadata, err + } + return next.HandleInitialize(ctx, in) +} + type validateOpDeleteServiceTemplate struct { } @@ -690,6 +750,66 @@ func (m *validateOpGetServiceInstance) HandleInitialize(ctx context.Context, in return next.HandleInitialize(ctx, in) } +type validateOpGetServiceInstanceSyncStatus struct { +} + +func (*validateOpGetServiceInstanceSyncStatus) ID() string { + return "OperationInputValidation" +} + +func (m *validateOpGetServiceInstanceSyncStatus) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + input, ok := in.Parameters.(*GetServiceInstanceSyncStatusInput) + if !ok { + return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) + } + if err := validateOpGetServiceInstanceSyncStatusInput(input); err != nil { + return out, metadata, err + } + return next.HandleInitialize(ctx, in) +} + +type validateOpGetServiceSyncBlockerSummary struct { +} + +func (*validateOpGetServiceSyncBlockerSummary) ID() string { + return "OperationInputValidation" +} + +func (m *validateOpGetServiceSyncBlockerSummary) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + input, ok := in.Parameters.(*GetServiceSyncBlockerSummaryInput) + if !ok { + return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) + } + if err := validateOpGetServiceSyncBlockerSummaryInput(input); err != nil { + return out, metadata, err + } + return next.HandleInitialize(ctx, in) +} + +type validateOpGetServiceSyncConfig struct { +} + +func (*validateOpGetServiceSyncConfig) ID() string { + return "OperationInputValidation" +} + +func (m *validateOpGetServiceSyncConfig) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + input, ok := in.Parameters.(*GetServiceSyncConfigInput) + if !ok { + return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) + } + if err := validateOpGetServiceSyncConfigInput(input); err != nil { + return out, metadata, err + } + return next.HandleInitialize(ctx, in) +} + type validateOpGetServiceTemplate struct { } @@ -1310,6 +1430,46 @@ func (m *validateOpUpdateServicePipeline) HandleInitialize(ctx context.Context, return next.HandleInitialize(ctx, in) } +type validateOpUpdateServiceSyncBlocker struct { +} + +func (*validateOpUpdateServiceSyncBlocker) ID() string { + return "OperationInputValidation" +} + +func (m *validateOpUpdateServiceSyncBlocker) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + input, ok := in.Parameters.(*UpdateServiceSyncBlockerInput) + if !ok { + return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) + } + if err := validateOpUpdateServiceSyncBlockerInput(input); err != nil { + return out, metadata, err + } + return next.HandleInitialize(ctx, in) +} + +type validateOpUpdateServiceSyncConfig struct { +} + +func (*validateOpUpdateServiceSyncConfig) ID() string { + return "OperationInputValidation" +} + +func (m *validateOpUpdateServiceSyncConfig) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + input, ok := in.Parameters.(*UpdateServiceSyncConfigInput) + if !ok { + return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) + } + if err := validateOpUpdateServiceSyncConfigInput(input); err != nil { + return out, metadata, err + } + return next.HandleInitialize(ctx, in) +} + type validateOpUpdateServiceTemplate struct { } @@ -1418,6 +1578,14 @@ func addOpCreateServiceValidationMiddleware(stack *middleware.Stack) error { return stack.Initialize.Add(&validateOpCreateService{}, middleware.After) } +func addOpCreateServiceInstanceValidationMiddleware(stack *middleware.Stack) error { + return stack.Initialize.Add(&validateOpCreateServiceInstance{}, middleware.After) +} + +func addOpCreateServiceSyncConfigValidationMiddleware(stack *middleware.Stack) error { + return stack.Initialize.Add(&validateOpCreateServiceSyncConfig{}, middleware.After) +} + func addOpCreateServiceTemplateValidationMiddleware(stack *middleware.Stack) error { return stack.Initialize.Add(&validateOpCreateServiceTemplate{}, middleware.After) } @@ -1458,6 +1626,10 @@ func addOpDeleteServiceValidationMiddleware(stack *middleware.Stack) error { return stack.Initialize.Add(&validateOpDeleteService{}, middleware.After) } +func addOpDeleteServiceSyncConfigValidationMiddleware(stack *middleware.Stack) error { + return stack.Initialize.Add(&validateOpDeleteServiceSyncConfig{}, middleware.After) +} + func addOpDeleteServiceTemplateValidationMiddleware(stack *middleware.Stack) error { return stack.Initialize.Add(&validateOpDeleteServiceTemplate{}, middleware.After) } @@ -1506,6 +1678,18 @@ func addOpGetServiceInstanceValidationMiddleware(stack *middleware.Stack) error return stack.Initialize.Add(&validateOpGetServiceInstance{}, middleware.After) } +func addOpGetServiceInstanceSyncStatusValidationMiddleware(stack *middleware.Stack) error { + return stack.Initialize.Add(&validateOpGetServiceInstanceSyncStatus{}, middleware.After) +} + +func addOpGetServiceSyncBlockerSummaryValidationMiddleware(stack *middleware.Stack) error { + return stack.Initialize.Add(&validateOpGetServiceSyncBlockerSummary{}, middleware.After) +} + +func addOpGetServiceSyncConfigValidationMiddleware(stack *middleware.Stack) error { + return stack.Initialize.Add(&validateOpGetServiceSyncConfig{}, middleware.After) +} + func addOpGetServiceTemplateValidationMiddleware(stack *middleware.Stack) error { return stack.Initialize.Add(&validateOpGetServiceTemplate{}, middleware.After) } @@ -1630,6 +1814,14 @@ func addOpUpdateServicePipelineValidationMiddleware(stack *middleware.Stack) err return stack.Initialize.Add(&validateOpUpdateServicePipeline{}, middleware.After) } +func addOpUpdateServiceSyncBlockerValidationMiddleware(stack *middleware.Stack) error { + return stack.Initialize.Add(&validateOpUpdateServiceSyncBlocker{}, middleware.After) +} + +func addOpUpdateServiceSyncConfigValidationMiddleware(stack *middleware.Stack) error { + return stack.Initialize.Add(&validateOpUpdateServiceSyncConfig{}, middleware.After) +} + func addOpUpdateServiceTemplateValidationMiddleware(stack *middleware.Stack) error { return stack.Initialize.Add(&validateOpUpdateServiceTemplate{}, middleware.After) } @@ -2068,6 +2260,59 @@ func validateOpCreateServiceInput(v *CreateServiceInput) error { } } +func validateOpCreateServiceInstanceInput(v *CreateServiceInstanceInput) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "CreateServiceInstanceInput"} + if v.Name == nil { + invalidParams.Add(smithy.NewErrParamRequired("Name")) + } + if v.ServiceName == nil { + invalidParams.Add(smithy.NewErrParamRequired("ServiceName")) + } + if v.Spec == nil { + invalidParams.Add(smithy.NewErrParamRequired("Spec")) + } + if v.Tags != nil { + if err := validateTagList(v.Tags); err != nil { + invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError)) + } + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + +func validateOpCreateServiceSyncConfigInput(v *CreateServiceSyncConfigInput) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "CreateServiceSyncConfigInput"} + if v.ServiceName == nil { + invalidParams.Add(smithy.NewErrParamRequired("ServiceName")) + } + if len(v.RepositoryProvider) == 0 { + invalidParams.Add(smithy.NewErrParamRequired("RepositoryProvider")) + } + if v.RepositoryName == nil { + invalidParams.Add(smithy.NewErrParamRequired("RepositoryName")) + } + if v.Branch == nil { + invalidParams.Add(smithy.NewErrParamRequired("Branch")) + } + if v.FilePath == nil { + invalidParams.Add(smithy.NewErrParamRequired("FilePath")) + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + func validateOpCreateServiceTemplateInput(v *CreateServiceTemplateInput) error { if v == nil { return nil @@ -2263,6 +2508,21 @@ func validateOpDeleteServiceInput(v *DeleteServiceInput) error { } } +func validateOpDeleteServiceSyncConfigInput(v *DeleteServiceSyncConfigInput) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "DeleteServiceSyncConfigInput"} + if v.ServiceName == nil { + invalidParams.Add(smithy.NewErrParamRequired("ServiceName")) + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + func validateOpDeleteServiceTemplateInput(v *DeleteServiceTemplateInput) error { if v == nil { return nil @@ -2473,6 +2733,54 @@ func validateOpGetServiceInstanceInput(v *GetServiceInstanceInput) error { } } +func validateOpGetServiceInstanceSyncStatusInput(v *GetServiceInstanceSyncStatusInput) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "GetServiceInstanceSyncStatusInput"} + if v.ServiceName == nil { + invalidParams.Add(smithy.NewErrParamRequired("ServiceName")) + } + if v.ServiceInstanceName == nil { + invalidParams.Add(smithy.NewErrParamRequired("ServiceInstanceName")) + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + +func validateOpGetServiceSyncBlockerSummaryInput(v *GetServiceSyncBlockerSummaryInput) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "GetServiceSyncBlockerSummaryInput"} + if v.ServiceName == nil { + invalidParams.Add(smithy.NewErrParamRequired("ServiceName")) + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + +func validateOpGetServiceSyncConfigInput(v *GetServiceSyncConfigInput) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "GetServiceSyncConfigInput"} + if v.ServiceName == nil { + invalidParams.Add(smithy.NewErrParamRequired("ServiceName")) + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + func validateOpGetServiceTemplateInput(v *GetServiceTemplateInput) error { if v == nil { return nil @@ -3008,6 +3316,51 @@ func validateOpUpdateServicePipelineInput(v *UpdateServicePipelineInput) error { } } +func validateOpUpdateServiceSyncBlockerInput(v *UpdateServiceSyncBlockerInput) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "UpdateServiceSyncBlockerInput"} + if v.Id == nil { + invalidParams.Add(smithy.NewErrParamRequired("Id")) + } + if v.ResolvedReason == nil { + invalidParams.Add(smithy.NewErrParamRequired("ResolvedReason")) + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + +func validateOpUpdateServiceSyncConfigInput(v *UpdateServiceSyncConfigInput) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "UpdateServiceSyncConfigInput"} + if v.ServiceName == nil { + invalidParams.Add(smithy.NewErrParamRequired("ServiceName")) + } + if len(v.RepositoryProvider) == 0 { + invalidParams.Add(smithy.NewErrParamRequired("RepositoryProvider")) + } + if v.RepositoryName == nil { + invalidParams.Add(smithy.NewErrParamRequired("RepositoryName")) + } + if v.Branch == nil { + invalidParams.Add(smithy.NewErrParamRequired("Branch")) + } + if v.FilePath == nil { + invalidParams.Add(smithy.NewErrParamRequired("FilePath")) + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + func validateOpUpdateServiceTemplateInput(v *UpdateServiceTemplateInput) error { if v == nil { return nil diff --git a/service/rds/api_op_CreateDBInstance.go b/service/rds/api_op_CreateDBInstance.go index 89301c2c062..11e353c79a2 100644 --- a/service/rds/api_op_CreateDBInstance.go +++ b/service/rds/api_op_CreateDBInstance.go @@ -78,20 +78,24 @@ type CreateDBInstanceInput struct { // * aurora-postgresql // // * - // custom-oracle-ee (for RDS Custom for Oracle instances) + // custom-oracle-ee (for RDS Custom for Oracle DB instances) // - // * custom-sqlserver-ee - // (for RDS Custom for SQL Server instances) + // * + // custom-oracle-ee-cdb (for RDS Custom for Oracle DB instances) // - // * custom-sqlserver-se (for RDS Custom - // for SQL Server instances) + // * + // custom-sqlserver-ee (for RDS Custom for SQL Server DB instances) // - // * custom-sqlserver-web (for RDS Custom for SQL Server - // instances) + // * + // custom-sqlserver-se (for RDS Custom for SQL Server DB instances) + // + // * + // custom-sqlserver-web (for RDS Custom for SQL Server DB instances) // // * mariadb // - // * mysql + // * + // mysql // // * oracle-ee // @@ -99,10 +103,10 @@ type CreateDBInstanceInput struct { // // * oracle-se2 // - // * - // oracle-se2-cdb + // * oracle-se2-cdb // - // * postgres + // * + // postgres // // * sqlserver-ee // @@ -110,8 +114,7 @@ type CreateDBInstanceInput struct { // // * sqlserver-ex // - // * - // sqlserver-web + // * sqlserver-web // // This member is required. Engine *string diff --git a/service/rds/api_op_CreateDBInstanceReadReplica.go b/service/rds/api_op_CreateDBInstanceReadReplica.go index c82c84c6fce..35f376b6810 100644 --- a/service/rds/api_op_CreateDBInstanceReadReplica.go +++ b/service/rds/api_op_CreateDBInstanceReadReplica.go @@ -119,28 +119,24 @@ type CreateDBInstanceReadReplicaInput struct { // in the VPC associated with the DB subnet group. If no DB subnet group is // specified, then the new DB instance isn't created in a VPC. Constraints: // - // * Can - // only be specified if the source DB instance identifier specifies a DB instance - // in another Amazon Web Services Region. + // * If + // supplied, must match the name of an existing DBSubnetGroup. // - // * If supplied, must match the name of an - // existing DBSubnetGroup. + // * The specified DB + // subnet group must be in the same Amazon Web Services Region in which the + // operation is running. // - // * The specified DB subnet group must be in the same - // Amazon Web Services Region in which the operation is running. + // * All read replicas in one Amazon Web Services Region + // that are created from the same source DB instance must either:> // - // * All read - // replicas in one Amazon Web Services Region that are created from the same source - // DB instance must either:> + // * Specify DB + // subnet groups from the same VPC. All these read replicas are created in the same + // VPC. // - // * Specify DB subnet groups from the same VPC. All - // these read replicas are created in the same VPC. + // * Not specify a DB subnet group. All these read replicas are created + // outside of any VPC. // - // * Not specify a DB subnet - // group. All these read replicas are created outside of any VPC. - // - // Example: - // mydbsubnetgroup + // Example: mydbsubnetgroup DBSubnetGroupName *string // A value that indicates whether the DB instance has deletion protection enabled. diff --git a/service/rds/api_op_CreateGlobalCluster.go b/service/rds/api_op_CreateGlobalCluster.go index 68ef360f1ae..1ca44fddce7 100644 --- a/service/rds/api_op_CreateGlobalCluster.go +++ b/service/rds/api_op_CreateGlobalCluster.go @@ -52,7 +52,8 @@ type CreateGlobalClusterInput struct { // The engine version of the Aurora global database. EngineVersion *string - // The cluster identifier of the new global database cluster. + // The cluster identifier of the new global database cluster. This parameter is + // stored as a lowercase string. GlobalClusterIdentifier *string // The Amazon Resource Name (ARN) to use as the primary cluster of the global diff --git a/service/rds/api_op_DeleteCustomDBEngineVersion.go b/service/rds/api_op_DeleteCustomDBEngineVersion.go index 8531038a3dc..927eca869b4 100644 --- a/service/rds/api_op_DeleteCustomDBEngineVersion.go +++ b/service/rds/api_op_DeleteCustomDBEngineVersion.go @@ -49,7 +49,8 @@ func (c *Client) DeleteCustomDBEngineVersion(ctx context.Context, params *Delete type DeleteCustomDBEngineVersionInput struct { - // The database engine. The only supported engine is custom-oracle-ee. + // The database engine. The only supported engines are custom-oracle-ee and + // custom-oracle-ee-cdb. // // This member is required. Engine *string diff --git a/service/rds/api_op_DescribeDBClusters.go b/service/rds/api_op_DescribeDBClusters.go index a3d78c4dd4b..f9479c64ac7 100644 --- a/service/rds/api_op_DescribeDBClusters.go +++ b/service/rds/api_op_DescribeDBClusters.go @@ -63,12 +63,17 @@ type DescribeDBClustersInput struct { // Resource Names (ARNs). The results list only includes information about the DB // clusters identified by these ARNs. // - // * domain - Accepts Active Directory - // directory IDs. The results list only includes information about the DB clusters - // associated with these domains. + // * db-cluster-resource-id - Accepts DB + // cluster resource identifiers. The results list will only include information + // about the DB clusters identified by these DB cluster resource identifiers. // - // * engine - Accepts engine names. The results - // list only includes information about the DB clusters for these engines. + // * + // domain - Accepts Active Directory directory IDs. The results list only includes + // information about the DB clusters associated with these domains. + // + // * engine - + // Accepts engine names. The results list only includes information about the DB + // clusters for these engines. Filters []types.Filter // Optional Boolean parameter that specifies whether the output includes diff --git a/service/rds/api_op_ModifyCustomDBEngineVersion.go b/service/rds/api_op_ModifyCustomDBEngineVersion.go index fc42535fe3c..630d3b84004 100644 --- a/service/rds/api_op_ModifyCustomDBEngineVersion.go +++ b/service/rds/api_op_ModifyCustomDBEngineVersion.go @@ -39,7 +39,8 @@ func (c *Client) ModifyCustomDBEngineVersion(ctx context.Context, params *Modify type ModifyCustomDBEngineVersionInput struct { - // The DB engine. The only supported value is custom-oracle-ee. + // The DB engine. The only supported values are custom-oracle-ee and + // custom-oracle-ee-cdb. // // This member is required. Engine *string diff --git a/service/rds/api_op_ModifyDBCluster.go b/service/rds/api_op_ModifyDBCluster.go index c5c11c2762c..f7863ba7ac7 100644 --- a/service/rds/api_op_ModifyDBCluster.go +++ b/service/rds/api_op_ModifyDBCluster.go @@ -58,14 +58,11 @@ type ModifyDBClusterInput struct { // modifications are asynchronously applied as soon as possible, regardless of the // PreferredMaintenanceWindow setting for the DB cluster. If this parameter is // disabled, changes to the DB cluster are applied during the next maintenance - // window. The ApplyImmediately parameter only affects the - // EnableIAMDatabaseAuthentication, MasterUserPassword, and NewDBClusterIdentifier - // values. If the ApplyImmediately parameter is disabled, then changes to the - // EnableIAMDatabaseAuthentication, MasterUserPassword, and NewDBClusterIdentifier - // values are applied during the next maintenance window. All other changes are - // applied immediately, regardless of the value of the ApplyImmediately parameter. - // By default, this parameter is disabled. Valid for: Aurora DB clusters and - // Multi-AZ DB clusters + // window. Most modifications can be applied immediately or during the next + // scheduled maintenance window. Some modifications, such as turning on deletion + // protection and changing the master password, are applied immediately—regardless + // of when you choose to apply them. By default, this parameter is disabled. Valid + // for: Aurora DB clusters and Multi-AZ DB clusters ApplyImmediately bool // A value that indicates whether minor engine upgrades are applied automatically diff --git a/service/sagemaker/internal/endpoints/endpoints.go b/service/sagemaker/internal/endpoints/endpoints.go index 2f289521c3a..db2bd09c2e9 100644 --- a/service/sagemaker/internal/endpoints/endpoints.go +++ b/service/sagemaker/internal/endpoints/endpoints.go @@ -153,6 +153,9 @@ var defaultPartitions = endpoints.Partitions{ endpoints.EndpointKey{ Region: "ap-south-1", }: endpoints.Endpoint{}, + endpoints.EndpointKey{ + Region: "ap-south-2", + }: endpoints.Endpoint{}, endpoints.EndpointKey{ Region: "ap-southeast-1", }: endpoints.Endpoint{},