From 9fbc0e483128ded9336cdd440f9f8b98f7037277 Mon Sep 17 00:00:00 2001 From: AWS SDK for Go v2 automation user Date: Wed, 25 Jan 2023 19:22:08 +0000 Subject: [PATCH] Regenerated Clients --- .../2c3d9e2d692149a3ac2644b02a8d640f.json | 8 + .../30844940f95b4d2da31ad087e5832d96.json | 8 + .../414237f07e234a4fb9150af8a4728c6b.json | 8 + .../486b2eb6f9f641ff94aeba4f59f2c741.json | 8 + .../7134df7d26554a659be0c82c5a1446ce.json | 8 + .../c30d8f56471e4164860303ef9c85e458.json | 8 + .../d0c8d93412794eac970f96ec6408d94e.json | 8 + .../eb2e97ae7b504975a1cc2c13820f4bda.json | 8 + service/ec2/api_op_AllocateIpamPoolCidr.go | 4 +- .../api_op_AssociateIpamResourceDiscovery.go | 178 + service/ec2/api_op_CreateIpamPool.go | 11 + .../ec2/api_op_CreateIpamResourceDiscovery.go | 173 + .../ec2/api_op_DeleteIpamResourceDiscovery.go | 129 + .../api_op_DescribeIpamResourceDiscoveries.go | 232 + ...scribeIpamResourceDiscoveryAssociations.go | 234 + ...pi_op_DisassociateIpamResourceDiscovery.go | 129 + .../ec2/api_op_GetIpamDiscoveredAccounts.go | 243 + .../api_op_GetIpamDiscoveredResourceCidrs.go | 245 + service/ec2/api_op_GetIpamResourceCidrs.go | 6 +- .../ec2/api_op_ModifyIpamResourceDiscovery.go | 141 + service/ec2/api_op_MoveByoipCidrToIpam.go | 4 +- service/ec2/api_op_ProvisionIpamPoolCidr.go | 52 +- service/ec2/deserializers.go | 4811 ++++++++++++----- service/ec2/generated.json | 9 + service/ec2/serializers.go | 1077 +++- service/ec2/types/enums.go | 134 + service/ec2/types/types.go | 313 +- service/ec2/validators.go | 243 + service/m2/api_op_GetBatchJobExecution.go | 6 + service/m2/deserializers.go | 167 + service/m2/types/types.go | 6 + .../internal/endpoints/endpoints.go | 9 + service/polly/types/enums.go | 10 + .../api_op_CreateWorkgroup.go | 10 +- .../api_op_RestoreTableFromSnapshot.go | 2 + .../api_op_UpdateNamespace.go | 17 +- .../api_op_UpdateWorkgroup.go | 15 +- service/redshiftserverless/types/types.go | 19 +- service/sagemaker/deserializers.go | 107 + .../sagemaker/internal/endpoints/endpoints.go | 3 + service/sagemaker/serializers.go | 10 + service/sagemaker/types/types.go | 31 +- service/sagemaker/validators.go | 3 - service/sts/api_op_AssumeRole.go | 11 +- service/sts/api_op_GetFederationToken.go | 15 +- 45 files changed, 7445 insertions(+), 1428 deletions(-) create mode 100644 .changelog/2c3d9e2d692149a3ac2644b02a8d640f.json create mode 100644 .changelog/30844940f95b4d2da31ad087e5832d96.json create mode 100644 .changelog/414237f07e234a4fb9150af8a4728c6b.json create mode 100644 .changelog/486b2eb6f9f641ff94aeba4f59f2c741.json create mode 100644 .changelog/7134df7d26554a659be0c82c5a1446ce.json create mode 100644 .changelog/c30d8f56471e4164860303ef9c85e458.json create mode 100644 .changelog/d0c8d93412794eac970f96ec6408d94e.json create mode 100644 .changelog/eb2e97ae7b504975a1cc2c13820f4bda.json create mode 100644 service/ec2/api_op_AssociateIpamResourceDiscovery.go create mode 100644 service/ec2/api_op_CreateIpamResourceDiscovery.go create mode 100644 service/ec2/api_op_DeleteIpamResourceDiscovery.go create mode 100644 service/ec2/api_op_DescribeIpamResourceDiscoveries.go create mode 100644 service/ec2/api_op_DescribeIpamResourceDiscoveryAssociations.go create mode 100644 service/ec2/api_op_DisassociateIpamResourceDiscovery.go create mode 100644 service/ec2/api_op_GetIpamDiscoveredAccounts.go create mode 100644 service/ec2/api_op_GetIpamDiscoveredResourceCidrs.go create mode 100644 service/ec2/api_op_ModifyIpamResourceDiscovery.go diff --git a/.changelog/2c3d9e2d692149a3ac2644b02a8d640f.json b/.changelog/2c3d9e2d692149a3ac2644b02a8d640f.json new file mode 100644 index 00000000000..0c45f31d640 --- /dev/null +++ b/.changelog/2c3d9e2d692149a3ac2644b02a8d640f.json @@ -0,0 +1,8 @@ +{ + "id": "2c3d9e2d-6921-49a3-ac26-44b02a8d640f", + "type": "feature", + "description": "Add additional endpoint tests for S3 Control. Fix missing endpoint parameters for PutBucketVersioning and GetBucketVersioning. Prior to this fix, those operations may have resulted in an invalid endpoint being resolved.", + "modules": [ + "service/s3control" + ] +} \ No newline at end of file diff --git a/.changelog/30844940f95b4d2da31ad087e5832d96.json b/.changelog/30844940f95b4d2da31ad087e5832d96.json new file mode 100644 index 00000000000..ff0a4749967 --- /dev/null +++ b/.changelog/30844940f95b4d2da31ad087e5832d96.json @@ -0,0 +1,8 @@ +{ + "id": "30844940-f95b-4d2d-a31a-d087e5832d96", + "type": "feature", + "description": "Enabled FIPS aws-us-gov endpoints in SDK.", + "modules": [ + "service/cloudformation" + ] +} \ No newline at end of file diff --git a/.changelog/414237f07e234a4fb9150af8a4728c6b.json b/.changelog/414237f07e234a4fb9150af8a4728c6b.json new file mode 100644 index 00000000000..861520e808c --- /dev/null +++ b/.changelog/414237f07e234a4fb9150af8a4728c6b.json @@ -0,0 +1,8 @@ +{ + "id": "414237f0-7e23-4a4f-b915-0af8a4728c6b", + "type": "feature", + "description": "Add 5 new neural voices - Sergio (es-ES), Andres (es-MX), Remi (fr-FR), Adriano (it-IT) and Thiago (pt-BR).", + "modules": [ + "service/polly" + ] +} \ No newline at end of file diff --git a/.changelog/486b2eb6f9f641ff94aeba4f59f2c741.json b/.changelog/486b2eb6f9f641ff94aeba4f59f2c741.json new file mode 100644 index 00000000000..92298c59925 --- /dev/null +++ b/.changelog/486b2eb6f9f641ff94aeba4f59f2c741.json @@ -0,0 +1,8 @@ +{ + "id": "486b2eb6-f9f6-41ff-94ae-ba4f59f2c741", + "type": "feature", + "description": "Add returnCode, batchJobIdentifier in GetBatchJobExecution response, for user to view the batch job execution result \u0026 unique identifier from engine. Also removed unused headers from REST APIs", + "modules": [ + "service/m2" + ] +} \ No newline at end of file diff --git a/.changelog/7134df7d26554a659be0c82c5a1446ce.json b/.changelog/7134df7d26554a659be0c82c5a1446ce.json new file mode 100644 index 00000000000..20894c2049e --- /dev/null +++ b/.changelog/7134df7d26554a659be0c82c5a1446ce.json @@ -0,0 +1,8 @@ +{ + "id": "7134df7d-2655-4a65-9be0-c82c5a1446ce", + "type": "documentation", + "description": "Doc only change to update wording in a key topic", + "modules": [ + "service/sts" + ] +} \ No newline at end of file diff --git a/.changelog/c30d8f56471e4164860303ef9c85e458.json b/.changelog/c30d8f56471e4164860303ef9c85e458.json new file mode 100644 index 00000000000..4f1e9e9b702 --- /dev/null +++ b/.changelog/c30d8f56471e4164860303ef9c85e458.json @@ -0,0 +1,8 @@ +{ + "id": "c30d8f56-471e-4164-8603-03ef9c85e458", + "type": "feature", + "description": "This release adds new functionality that allows customers to provision IPv6 CIDR blocks through Amazon VPC IP Address Manager (IPAM) as well as allowing customers to utilize IPAM Resource Discovery APIs.", + "modules": [ + "service/ec2" + ] +} \ No newline at end of file diff --git a/.changelog/d0c8d93412794eac970f96ec6408d94e.json b/.changelog/d0c8d93412794eac970f96ec6408d94e.json new file mode 100644 index 00000000000..8b787d7a4a7 --- /dev/null +++ b/.changelog/d0c8d93412794eac970f96ec6408d94e.json @@ -0,0 +1,8 @@ +{ + "id": "d0c8d934-1279-4eac-970f-96ec6408d94e", + "type": "feature", + "description": "SageMaker Inference Recommender now decouples from Model Registry and could accept Model Name to invoke inference recommendations job; Inference Recommender now provides CPU/Memory Utilization metrics data in recommendation output.", + "modules": [ + "service/sagemaker" + ] +} \ No newline at end of file diff --git a/.changelog/eb2e97ae7b504975a1cc2c13820f4bda.json b/.changelog/eb2e97ae7b504975a1cc2c13820f4bda.json new file mode 100644 index 00000000000..1bc953422c5 --- /dev/null +++ b/.changelog/eb2e97ae7b504975a1cc2c13820f4bda.json @@ -0,0 +1,8 @@ +{ + "id": "eb2e97ae-7b50-4975-a1cc-2c13820f4bda", + "type": "documentation", + "description": "Added query monitoring rules as possible parameters for create and update workgroup operations.", + "modules": [ + "service/redshiftserverless" + ] +} \ No newline at end of file diff --git a/service/ec2/api_op_AllocateIpamPoolCidr.go b/service/ec2/api_op_AllocateIpamPoolCidr.go index 4e9979a8e79..f0eb955692f 100644 --- a/service/ec2/api_op_AllocateIpamPoolCidr.go +++ b/service/ec2/api_op_AllocateIpamPoolCidr.go @@ -13,8 +13,8 @@ import ( ) // Allocate a CIDR from an IPAM pool. In IPAM, an allocation is a CIDR assignment -// from an IPAM pool to another resource or IPAM pool. For more information, see -// Allocate CIDRs +// from an IPAM pool to another IPAM pool or to a resource. For more information, +// see Allocate CIDRs // (https://docs.aws.amazon.com/vpc/latest/ipam/allocate-cidrs-ipam.html) in the // Amazon VPC IPAM User Guide. func (c *Client) AllocateIpamPoolCidr(ctx context.Context, params *AllocateIpamPoolCidrInput, optFns ...func(*Options)) (*AllocateIpamPoolCidrOutput, error) { diff --git a/service/ec2/api_op_AssociateIpamResourceDiscovery.go b/service/ec2/api_op_AssociateIpamResourceDiscovery.go new file mode 100644 index 00000000000..a00ac280189 --- /dev/null +++ b/service/ec2/api_op_AssociateIpamResourceDiscovery.go @@ -0,0 +1,178 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package ec2 + +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/ec2/types" + "github.com/aws/smithy-go/middleware" + smithyhttp "github.com/aws/smithy-go/transport/http" +) + +// Associates an IPAM resource discovery with an Amazon VPC IPAM. A resource +// discovery is an IPAM component that enables IPAM Service to manage and monitor +// resources that belong to the owning account. +func (c *Client) AssociateIpamResourceDiscovery(ctx context.Context, params *AssociateIpamResourceDiscoveryInput, optFns ...func(*Options)) (*AssociateIpamResourceDiscoveryOutput, error) { + if params == nil { + params = &AssociateIpamResourceDiscoveryInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "AssociateIpamResourceDiscovery", params, optFns, c.addOperationAssociateIpamResourceDiscoveryMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*AssociateIpamResourceDiscoveryOutput) + out.ResultMetadata = metadata + return out, nil +} + +type AssociateIpamResourceDiscoveryInput struct { + + // An IPAM ID. + // + // This member is required. + IpamId *string + + // A resource discovery ID. + // + // This member is required. + IpamResourceDiscoveryId *string + + // A client token. + ClientToken *string + + // A check for whether you have the required permissions for the action without + // actually making the request and provides an error response. If you have the + // required permissions, the error response is DryRunOperation. Otherwise, it is + // UnauthorizedOperation. + DryRun *bool + + // Tag specifications. + TagSpecifications []types.TagSpecification + + noSmithyDocumentSerde +} + +type AssociateIpamResourceDiscoveryOutput struct { + + // A resource discovery association. An associated resource discovery is a resource + // discovery that has been associated with an IPAM. + IpamResourceDiscoveryAssociation *types.IpamResourceDiscoveryAssociation + + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (c *Client) addOperationAssociateIpamResourceDiscoveryMiddlewares(stack *middleware.Stack, options Options) (err error) { + err = stack.Serialize.Add(&awsEc2query_serializeOpAssociateIpamResourceDiscovery{}, middleware.After) + if err != nil { + return err + } + err = stack.Deserialize.Add(&awsEc2query_deserializeOpAssociateIpamResourceDiscovery{}, 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_opAssociateIpamResourceDiscoveryMiddleware(stack, options); err != nil { + return err + } + if err = addOpAssociateIpamResourceDiscoveryValidationMiddleware(stack); err != nil { + return err + } + if err = stack.Initialize.Add(newServiceMetadataMiddleware_opAssociateIpamResourceDiscovery(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_initializeOpAssociateIpamResourceDiscovery struct { + tokenProvider IdempotencyTokenProvider +} + +func (*idempotencyToken_initializeOpAssociateIpamResourceDiscovery) ID() string { + return "OperationIdempotencyTokenAutoFill" +} + +func (m *idempotencyToken_initializeOpAssociateIpamResourceDiscovery) 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.(*AssociateIpamResourceDiscoveryInput) + if !ok { + return out, metadata, fmt.Errorf("expected middleware input to be of type *AssociateIpamResourceDiscoveryInput ") + } + + 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_opAssociateIpamResourceDiscoveryMiddleware(stack *middleware.Stack, cfg Options) error { + return stack.Initialize.Add(&idempotencyToken_initializeOpAssociateIpamResourceDiscovery{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before) +} + +func newServiceMetadataMiddleware_opAssociateIpamResourceDiscovery(region string) *awsmiddleware.RegisterServiceMetadata { + return &awsmiddleware.RegisterServiceMetadata{ + Region: region, + ServiceID: ServiceID, + SigningName: "ec2", + OperationName: "AssociateIpamResourceDiscovery", + } +} diff --git a/service/ec2/api_op_CreateIpamPool.go b/service/ec2/api_op_CreateIpamPool.go index d0e7fb6f522..51e5bfe0e0f 100644 --- a/service/ec2/api_op_CreateIpamPool.go +++ b/service/ec2/api_op_CreateIpamPool.go @@ -111,6 +111,17 @@ type CreateIpamPoolInput struct { // Web Services Region, such as us-east-1. Locale *string + // The IP address source for pools in the public scope. Only used for provisioning + // IP address CIDRs to pools in the public scope. Default is byoip. For more + // information, see Create IPv6 pools + // (https://docs.aws.amazon.com/vpc/latest/ipam/intro-create-ipv6-pools.html) in + // the Amazon VPC IPAM User Guide. By default, you can add only one Amazon-provided + // IPv6 CIDR block to a top-level IPv6 pool if PublicIpSource is amazon. For + // information on increasing the default limit, see Quotas for your IPAM + // (https://docs.aws.amazon.com/vpc/latest/ipam/quotas-ipam.html) in the Amazon VPC + // IPAM User Guide. + PublicIpSource types.IpamPoolPublicIpSource + // Determines if the pool is publicly advertisable. This option is not available // for pools with AddressFamily set to ipv4. PubliclyAdvertisable *bool diff --git a/service/ec2/api_op_CreateIpamResourceDiscovery.go b/service/ec2/api_op_CreateIpamResourceDiscovery.go new file mode 100644 index 00000000000..341abf82c75 --- /dev/null +++ b/service/ec2/api_op_CreateIpamResourceDiscovery.go @@ -0,0 +1,173 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package ec2 + +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/ec2/types" + "github.com/aws/smithy-go/middleware" + smithyhttp "github.com/aws/smithy-go/transport/http" +) + +// Creates an IPAM resource discovery. A resource discovery is an IPAM component +// that enables IPAM Service to manage and monitor resources that belong to the +// owning account. +func (c *Client) CreateIpamResourceDiscovery(ctx context.Context, params *CreateIpamResourceDiscoveryInput, optFns ...func(*Options)) (*CreateIpamResourceDiscoveryOutput, error) { + if params == nil { + params = &CreateIpamResourceDiscoveryInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "CreateIpamResourceDiscovery", params, optFns, c.addOperationCreateIpamResourceDiscoveryMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*CreateIpamResourceDiscoveryOutput) + out.ResultMetadata = metadata + return out, nil +} + +type CreateIpamResourceDiscoveryInput struct { + + // A client token for the IPAM resource discovery. + ClientToken *string + + // A description for the IPAM resource discovery. + Description *string + + // A check for whether you have the required permissions for the action without + // actually making the request and provides an error response. If you have the + // required permissions, the error response is DryRunOperation. Otherwise, it is + // UnauthorizedOperation. + DryRun *bool + + // Operating Regions for the IPAM resource discovery. Operating Regions are Amazon + // Web Services Regions where the IPAM is allowed to manage IP address CIDRs. IPAM + // only discovers and monitors resources in the Amazon Web Services Regions you + // select as operating Regions. + OperatingRegions []types.AddIpamOperatingRegion + + // Tag specifications for the IPAM resource discovery. + TagSpecifications []types.TagSpecification + + noSmithyDocumentSerde +} + +type CreateIpamResourceDiscoveryOutput struct { + + // An IPAM resource discovery. + IpamResourceDiscovery *types.IpamResourceDiscovery + + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (c *Client) addOperationCreateIpamResourceDiscoveryMiddlewares(stack *middleware.Stack, options Options) (err error) { + err = stack.Serialize.Add(&awsEc2query_serializeOpCreateIpamResourceDiscovery{}, middleware.After) + if err != nil { + return err + } + err = stack.Deserialize.Add(&awsEc2query_deserializeOpCreateIpamResourceDiscovery{}, 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_opCreateIpamResourceDiscoveryMiddleware(stack, options); err != nil { + return err + } + if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateIpamResourceDiscovery(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_initializeOpCreateIpamResourceDiscovery struct { + tokenProvider IdempotencyTokenProvider +} + +func (*idempotencyToken_initializeOpCreateIpamResourceDiscovery) ID() string { + return "OperationIdempotencyTokenAutoFill" +} + +func (m *idempotencyToken_initializeOpCreateIpamResourceDiscovery) 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.(*CreateIpamResourceDiscoveryInput) + if !ok { + return out, metadata, fmt.Errorf("expected middleware input to be of type *CreateIpamResourceDiscoveryInput ") + } + + 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_opCreateIpamResourceDiscoveryMiddleware(stack *middleware.Stack, cfg Options) error { + return stack.Initialize.Add(&idempotencyToken_initializeOpCreateIpamResourceDiscovery{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before) +} + +func newServiceMetadataMiddleware_opCreateIpamResourceDiscovery(region string) *awsmiddleware.RegisterServiceMetadata { + return &awsmiddleware.RegisterServiceMetadata{ + Region: region, + ServiceID: ServiceID, + SigningName: "ec2", + OperationName: "CreateIpamResourceDiscovery", + } +} diff --git a/service/ec2/api_op_DeleteIpamResourceDiscovery.go b/service/ec2/api_op_DeleteIpamResourceDiscovery.go new file mode 100644 index 00000000000..21b6ed234be --- /dev/null +++ b/service/ec2/api_op_DeleteIpamResourceDiscovery.go @@ -0,0 +1,129 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package ec2 + +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/ec2/types" + "github.com/aws/smithy-go/middleware" + smithyhttp "github.com/aws/smithy-go/transport/http" +) + +// Deletes an IPAM resource discovery. A resource discovery is an IPAM component +// that enables IPAM Service to manage and monitor resources that belong to the +// owning account. +func (c *Client) DeleteIpamResourceDiscovery(ctx context.Context, params *DeleteIpamResourceDiscoveryInput, optFns ...func(*Options)) (*DeleteIpamResourceDiscoveryOutput, error) { + if params == nil { + params = &DeleteIpamResourceDiscoveryInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "DeleteIpamResourceDiscovery", params, optFns, c.addOperationDeleteIpamResourceDiscoveryMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*DeleteIpamResourceDiscoveryOutput) + out.ResultMetadata = metadata + return out, nil +} + +type DeleteIpamResourceDiscoveryInput struct { + + // The IPAM resource discovery ID. + // + // This member is required. + IpamResourceDiscoveryId *string + + // A check for whether you have the required permissions for the action without + // actually making the request and provides an error response. If you have the + // required permissions, the error response is DryRunOperation. Otherwise, it is + // UnauthorizedOperation. + DryRun *bool + + noSmithyDocumentSerde +} + +type DeleteIpamResourceDiscoveryOutput struct { + + // The IPAM resource discovery. + IpamResourceDiscovery *types.IpamResourceDiscovery + + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (c *Client) addOperationDeleteIpamResourceDiscoveryMiddlewares(stack *middleware.Stack, options Options) (err error) { + err = stack.Serialize.Add(&awsEc2query_serializeOpDeleteIpamResourceDiscovery{}, middleware.After) + if err != nil { + return err + } + err = stack.Deserialize.Add(&awsEc2query_deserializeOpDeleteIpamResourceDiscovery{}, 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 = addOpDeleteIpamResourceDiscoveryValidationMiddleware(stack); err != nil { + return err + } + if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteIpamResourceDiscovery(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_opDeleteIpamResourceDiscovery(region string) *awsmiddleware.RegisterServiceMetadata { + return &awsmiddleware.RegisterServiceMetadata{ + Region: region, + ServiceID: ServiceID, + SigningName: "ec2", + OperationName: "DeleteIpamResourceDiscovery", + } +} diff --git a/service/ec2/api_op_DescribeIpamResourceDiscoveries.go b/service/ec2/api_op_DescribeIpamResourceDiscoveries.go new file mode 100644 index 00000000000..bd61251c6e3 --- /dev/null +++ b/service/ec2/api_op_DescribeIpamResourceDiscoveries.go @@ -0,0 +1,232 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package ec2 + +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/ec2/types" + "github.com/aws/smithy-go/middleware" + smithyhttp "github.com/aws/smithy-go/transport/http" +) + +// Describes IPAM resource discoveries. A resource discovery is an IPAM component +// that enables IPAM Service to manage and monitor resources that belong to the +// owning account. +func (c *Client) DescribeIpamResourceDiscoveries(ctx context.Context, params *DescribeIpamResourceDiscoveriesInput, optFns ...func(*Options)) (*DescribeIpamResourceDiscoveriesOutput, error) { + if params == nil { + params = &DescribeIpamResourceDiscoveriesInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "DescribeIpamResourceDiscoveries", params, optFns, c.addOperationDescribeIpamResourceDiscoveriesMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*DescribeIpamResourceDiscoveriesOutput) + out.ResultMetadata = metadata + return out, nil +} + +type DescribeIpamResourceDiscoveriesInput struct { + + // A check for whether you have the required permissions for the action without + // actually making the request and provides an error response. If you have the + // required permissions, the error response is DryRunOperation. Otherwise, it is + // UnauthorizedOperation. + DryRun *bool + + // The resource discovery filters. + Filters []types.Filter + + // The IPAM resource discovery IDs. + IpamResourceDiscoveryIds []string + + // The maximum number of resource discoveries to return in one page of results. + MaxResults *int32 + + // Specify the pagination token from a previous request to retrieve the next page + // of results. + NextToken *string + + noSmithyDocumentSerde +} + +type DescribeIpamResourceDiscoveriesOutput struct { + + // The resource discoveries. + IpamResourceDiscoveries []types.IpamResourceDiscovery + + // Specify the pagination token from a previous request to retrieve the next page + // of results. + NextToken *string + + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (c *Client) addOperationDescribeIpamResourceDiscoveriesMiddlewares(stack *middleware.Stack, options Options) (err error) { + err = stack.Serialize.Add(&awsEc2query_serializeOpDescribeIpamResourceDiscoveries{}, middleware.After) + if err != nil { + return err + } + err = stack.Deserialize.Add(&awsEc2query_deserializeOpDescribeIpamResourceDiscoveries{}, middleware.After) + if err != nil { + return err + } + if err = addSetLoggerMiddleware(stack, options); err != nil { + return err + } + if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil { + return err + } + if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil { + return err + } + if err = addResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil { + return err + } + if err = addRetryMiddlewares(stack, options); err != nil { + return err + } + if err = addHTTPSignerV4Middleware(stack, options); err != nil { + return err + } + if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil { + return err + } + if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil { + return err + } + if err = addClientUserAgent(stack); err != nil { + return err + } + if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil { + return err + } + if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { + return err + } + if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeIpamResourceDiscoveries(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 +} + +// DescribeIpamResourceDiscoveriesAPIClient is a client that implements the +// DescribeIpamResourceDiscoveries operation. +type DescribeIpamResourceDiscoveriesAPIClient interface { + DescribeIpamResourceDiscoveries(context.Context, *DescribeIpamResourceDiscoveriesInput, ...func(*Options)) (*DescribeIpamResourceDiscoveriesOutput, error) +} + +var _ DescribeIpamResourceDiscoveriesAPIClient = (*Client)(nil) + +// DescribeIpamResourceDiscoveriesPaginatorOptions is the paginator options for +// DescribeIpamResourceDiscoveries +type DescribeIpamResourceDiscoveriesPaginatorOptions struct { + // The maximum number of resource discoveries to return in one page of results. + Limit int32 + + // Set to true if pagination should stop if the service returns a pagination token + // that matches the most recent token provided to the service. + StopOnDuplicateToken bool +} + +// DescribeIpamResourceDiscoveriesPaginator is a paginator for +// DescribeIpamResourceDiscoveries +type DescribeIpamResourceDiscoveriesPaginator struct { + options DescribeIpamResourceDiscoveriesPaginatorOptions + client DescribeIpamResourceDiscoveriesAPIClient + params *DescribeIpamResourceDiscoveriesInput + nextToken *string + firstPage bool +} + +// NewDescribeIpamResourceDiscoveriesPaginator returns a new +// DescribeIpamResourceDiscoveriesPaginator +func NewDescribeIpamResourceDiscoveriesPaginator(client DescribeIpamResourceDiscoveriesAPIClient, params *DescribeIpamResourceDiscoveriesInput, optFns ...func(*DescribeIpamResourceDiscoveriesPaginatorOptions)) *DescribeIpamResourceDiscoveriesPaginator { + if params == nil { + params = &DescribeIpamResourceDiscoveriesInput{} + } + + options := DescribeIpamResourceDiscoveriesPaginatorOptions{} + if params.MaxResults != nil { + options.Limit = *params.MaxResults + } + + for _, fn := range optFns { + fn(&options) + } + + return &DescribeIpamResourceDiscoveriesPaginator{ + options: options, + client: client, + params: params, + firstPage: true, + nextToken: params.NextToken, + } +} + +// HasMorePages returns a boolean indicating whether more pages are available +func (p *DescribeIpamResourceDiscoveriesPaginator) HasMorePages() bool { + return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0) +} + +// NextPage retrieves the next DescribeIpamResourceDiscoveries page. +func (p *DescribeIpamResourceDiscoveriesPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*DescribeIpamResourceDiscoveriesOutput, error) { + if !p.HasMorePages() { + return nil, fmt.Errorf("no more pages available") + } + + params := *p.params + params.NextToken = p.nextToken + + var limit *int32 + if p.options.Limit > 0 { + limit = &p.options.Limit + } + params.MaxResults = limit + + result, err := p.client.DescribeIpamResourceDiscoveries(ctx, ¶ms, optFns...) + if err != nil { + return nil, err + } + p.firstPage = false + + prevToken := p.nextToken + p.nextToken = result.NextToken + + if p.options.StopOnDuplicateToken && + prevToken != nil && + p.nextToken != nil && + *prevToken == *p.nextToken { + p.nextToken = nil + } + + return result, nil +} + +func newServiceMetadataMiddleware_opDescribeIpamResourceDiscoveries(region string) *awsmiddleware.RegisterServiceMetadata { + return &awsmiddleware.RegisterServiceMetadata{ + Region: region, + ServiceID: ServiceID, + SigningName: "ec2", + OperationName: "DescribeIpamResourceDiscoveries", + } +} diff --git a/service/ec2/api_op_DescribeIpamResourceDiscoveryAssociations.go b/service/ec2/api_op_DescribeIpamResourceDiscoveryAssociations.go new file mode 100644 index 00000000000..6815b089287 --- /dev/null +++ b/service/ec2/api_op_DescribeIpamResourceDiscoveryAssociations.go @@ -0,0 +1,234 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package ec2 + +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/ec2/types" + "github.com/aws/smithy-go/middleware" + smithyhttp "github.com/aws/smithy-go/transport/http" +) + +// Describes resource discovery association with an Amazon VPC IPAM. An associated +// resource discovery is a resource discovery that has been associated with an +// IPAM.. +func (c *Client) DescribeIpamResourceDiscoveryAssociations(ctx context.Context, params *DescribeIpamResourceDiscoveryAssociationsInput, optFns ...func(*Options)) (*DescribeIpamResourceDiscoveryAssociationsOutput, error) { + if params == nil { + params = &DescribeIpamResourceDiscoveryAssociationsInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "DescribeIpamResourceDiscoveryAssociations", params, optFns, c.addOperationDescribeIpamResourceDiscoveryAssociationsMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*DescribeIpamResourceDiscoveryAssociationsOutput) + out.ResultMetadata = metadata + return out, nil +} + +type DescribeIpamResourceDiscoveryAssociationsInput struct { + + // A check for whether you have the required permissions for the action without + // actually making the request and provides an error response. If you have the + // required permissions, the error response is DryRunOperation. Otherwise, it is + // UnauthorizedOperation. + DryRun *bool + + // The resource discovery association filters. + Filters []types.Filter + + // The resource discovery association IDs. + IpamResourceDiscoveryAssociationIds []string + + // The maximum number of resource discovery associations to return in one page of + // results. + MaxResults *int32 + + // Specify the pagination token from a previous request to retrieve the next page + // of results. + NextToken *string + + noSmithyDocumentSerde +} + +type DescribeIpamResourceDiscoveryAssociationsOutput struct { + + // The resource discovery associations. + IpamResourceDiscoveryAssociations []types.IpamResourceDiscoveryAssociation + + // Specify the pagination token from a previous request to retrieve the next page + // of results. + NextToken *string + + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (c *Client) addOperationDescribeIpamResourceDiscoveryAssociationsMiddlewares(stack *middleware.Stack, options Options) (err error) { + err = stack.Serialize.Add(&awsEc2query_serializeOpDescribeIpamResourceDiscoveryAssociations{}, middleware.After) + if err != nil { + return err + } + err = stack.Deserialize.Add(&awsEc2query_deserializeOpDescribeIpamResourceDiscoveryAssociations{}, middleware.After) + if err != nil { + return err + } + if err = addSetLoggerMiddleware(stack, options); err != nil { + return err + } + if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil { + return err + } + if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil { + return err + } + if err = addResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil { + return err + } + if err = addRetryMiddlewares(stack, options); err != nil { + return err + } + if err = addHTTPSignerV4Middleware(stack, options); err != nil { + return err + } + if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil { + return err + } + if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil { + return err + } + if err = addClientUserAgent(stack); err != nil { + return err + } + if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil { + return err + } + if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { + return err + } + if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeIpamResourceDiscoveryAssociations(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 +} + +// DescribeIpamResourceDiscoveryAssociationsAPIClient is a client that implements +// the DescribeIpamResourceDiscoveryAssociations operation. +type DescribeIpamResourceDiscoveryAssociationsAPIClient interface { + DescribeIpamResourceDiscoveryAssociations(context.Context, *DescribeIpamResourceDiscoveryAssociationsInput, ...func(*Options)) (*DescribeIpamResourceDiscoveryAssociationsOutput, error) +} + +var _ DescribeIpamResourceDiscoveryAssociationsAPIClient = (*Client)(nil) + +// DescribeIpamResourceDiscoveryAssociationsPaginatorOptions is the paginator +// options for DescribeIpamResourceDiscoveryAssociations +type DescribeIpamResourceDiscoveryAssociationsPaginatorOptions struct { + // The maximum number of resource discovery associations to return in one page of + // results. + Limit int32 + + // Set to true if pagination should stop if the service returns a pagination token + // that matches the most recent token provided to the service. + StopOnDuplicateToken bool +} + +// DescribeIpamResourceDiscoveryAssociationsPaginator is a paginator for +// DescribeIpamResourceDiscoveryAssociations +type DescribeIpamResourceDiscoveryAssociationsPaginator struct { + options DescribeIpamResourceDiscoveryAssociationsPaginatorOptions + client DescribeIpamResourceDiscoveryAssociationsAPIClient + params *DescribeIpamResourceDiscoveryAssociationsInput + nextToken *string + firstPage bool +} + +// NewDescribeIpamResourceDiscoveryAssociationsPaginator returns a new +// DescribeIpamResourceDiscoveryAssociationsPaginator +func NewDescribeIpamResourceDiscoveryAssociationsPaginator(client DescribeIpamResourceDiscoveryAssociationsAPIClient, params *DescribeIpamResourceDiscoveryAssociationsInput, optFns ...func(*DescribeIpamResourceDiscoveryAssociationsPaginatorOptions)) *DescribeIpamResourceDiscoveryAssociationsPaginator { + if params == nil { + params = &DescribeIpamResourceDiscoveryAssociationsInput{} + } + + options := DescribeIpamResourceDiscoveryAssociationsPaginatorOptions{} + if params.MaxResults != nil { + options.Limit = *params.MaxResults + } + + for _, fn := range optFns { + fn(&options) + } + + return &DescribeIpamResourceDiscoveryAssociationsPaginator{ + options: options, + client: client, + params: params, + firstPage: true, + nextToken: params.NextToken, + } +} + +// HasMorePages returns a boolean indicating whether more pages are available +func (p *DescribeIpamResourceDiscoveryAssociationsPaginator) HasMorePages() bool { + return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0) +} + +// NextPage retrieves the next DescribeIpamResourceDiscoveryAssociations page. +func (p *DescribeIpamResourceDiscoveryAssociationsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*DescribeIpamResourceDiscoveryAssociationsOutput, error) { + if !p.HasMorePages() { + return nil, fmt.Errorf("no more pages available") + } + + params := *p.params + params.NextToken = p.nextToken + + var limit *int32 + if p.options.Limit > 0 { + limit = &p.options.Limit + } + params.MaxResults = limit + + result, err := p.client.DescribeIpamResourceDiscoveryAssociations(ctx, ¶ms, optFns...) + if err != nil { + return nil, err + } + p.firstPage = false + + prevToken := p.nextToken + p.nextToken = result.NextToken + + if p.options.StopOnDuplicateToken && + prevToken != nil && + p.nextToken != nil && + *prevToken == *p.nextToken { + p.nextToken = nil + } + + return result, nil +} + +func newServiceMetadataMiddleware_opDescribeIpamResourceDiscoveryAssociations(region string) *awsmiddleware.RegisterServiceMetadata { + return &awsmiddleware.RegisterServiceMetadata{ + Region: region, + ServiceID: ServiceID, + SigningName: "ec2", + OperationName: "DescribeIpamResourceDiscoveryAssociations", + } +} diff --git a/service/ec2/api_op_DisassociateIpamResourceDiscovery.go b/service/ec2/api_op_DisassociateIpamResourceDiscovery.go new file mode 100644 index 00000000000..f4b9ae2e030 --- /dev/null +++ b/service/ec2/api_op_DisassociateIpamResourceDiscovery.go @@ -0,0 +1,129 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package ec2 + +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/ec2/types" + "github.com/aws/smithy-go/middleware" + smithyhttp "github.com/aws/smithy-go/transport/http" +) + +// Disassociates a resource discovery from an Amazon VPC IPAM. A resource discovery +// is an IPAM component that enables IPAM Service to manage and monitor resources +// that belong to the owning account. +func (c *Client) DisassociateIpamResourceDiscovery(ctx context.Context, params *DisassociateIpamResourceDiscoveryInput, optFns ...func(*Options)) (*DisassociateIpamResourceDiscoveryOutput, error) { + if params == nil { + params = &DisassociateIpamResourceDiscoveryInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "DisassociateIpamResourceDiscovery", params, optFns, c.addOperationDisassociateIpamResourceDiscoveryMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*DisassociateIpamResourceDiscoveryOutput) + out.ResultMetadata = metadata + return out, nil +} + +type DisassociateIpamResourceDiscoveryInput struct { + + // A resource discovery association ID. + // + // This member is required. + IpamResourceDiscoveryAssociationId *string + + // A check for whether you have the required permissions for the action without + // actually making the request and provides an error response. If you have the + // required permissions, the error response is DryRunOperation. Otherwise, it is + // UnauthorizedOperation. + DryRun *bool + + noSmithyDocumentSerde +} + +type DisassociateIpamResourceDiscoveryOutput struct { + + // A resource discovery association. + IpamResourceDiscoveryAssociation *types.IpamResourceDiscoveryAssociation + + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (c *Client) addOperationDisassociateIpamResourceDiscoveryMiddlewares(stack *middleware.Stack, options Options) (err error) { + err = stack.Serialize.Add(&awsEc2query_serializeOpDisassociateIpamResourceDiscovery{}, middleware.After) + if err != nil { + return err + } + err = stack.Deserialize.Add(&awsEc2query_deserializeOpDisassociateIpamResourceDiscovery{}, 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 = addOpDisassociateIpamResourceDiscoveryValidationMiddleware(stack); err != nil { + return err + } + if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDisassociateIpamResourceDiscovery(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_opDisassociateIpamResourceDiscovery(region string) *awsmiddleware.RegisterServiceMetadata { + return &awsmiddleware.RegisterServiceMetadata{ + Region: region, + ServiceID: ServiceID, + SigningName: "ec2", + OperationName: "DisassociateIpamResourceDiscovery", + } +} diff --git a/service/ec2/api_op_GetIpamDiscoveredAccounts.go b/service/ec2/api_op_GetIpamDiscoveredAccounts.go new file mode 100644 index 00000000000..7f671b1cb5d --- /dev/null +++ b/service/ec2/api_op_GetIpamDiscoveredAccounts.go @@ -0,0 +1,243 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package ec2 + +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/ec2/types" + "github.com/aws/smithy-go/middleware" + smithyhttp "github.com/aws/smithy-go/transport/http" +) + +// Gets IPAM discovered accounts. A discovered account is an Amazon Web Services +// account that is monitored under a resource discovery. If you have integrated +// IPAM with Amazon Web Services Organizations, all accounts in the organization +// are discovered accounts. Only the IPAM account can get all discovered accounts +// in the organization. +func (c *Client) GetIpamDiscoveredAccounts(ctx context.Context, params *GetIpamDiscoveredAccountsInput, optFns ...func(*Options)) (*GetIpamDiscoveredAccountsOutput, error) { + if params == nil { + params = &GetIpamDiscoveredAccountsInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "GetIpamDiscoveredAccounts", params, optFns, c.addOperationGetIpamDiscoveredAccountsMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*GetIpamDiscoveredAccountsOutput) + out.ResultMetadata = metadata + return out, nil +} + +type GetIpamDiscoveredAccountsInput struct { + + // The Amazon Web Services Region that the account information is returned from. + // + // This member is required. + DiscoveryRegion *string + + // A resource discovery ID. + // + // This member is required. + IpamResourceDiscoveryId *string + + // A check for whether you have the required permissions for the action without + // actually making the request and provides an error response. If you have the + // required permissions, the error response is DryRunOperation. Otherwise, it is + // UnauthorizedOperation. + DryRun *bool + + // Discovered account filters. + Filters []types.Filter + + // The maximum number of discovered accounts to return in one page of results. + MaxResults *int32 + + // Specify the pagination token from a previous request to retrieve the next page + // of results. + NextToken *string + + noSmithyDocumentSerde +} + +type GetIpamDiscoveredAccountsOutput struct { + + // Discovered accounts. + IpamDiscoveredAccounts []types.IpamDiscoveredAccount + + // Specify the pagination token from a previous request to retrieve the next page + // of results. + NextToken *string + + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (c *Client) addOperationGetIpamDiscoveredAccountsMiddlewares(stack *middleware.Stack, options Options) (err error) { + err = stack.Serialize.Add(&awsEc2query_serializeOpGetIpamDiscoveredAccounts{}, middleware.After) + if err != nil { + return err + } + err = stack.Deserialize.Add(&awsEc2query_deserializeOpGetIpamDiscoveredAccounts{}, 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 = addOpGetIpamDiscoveredAccountsValidationMiddleware(stack); err != nil { + return err + } + if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetIpamDiscoveredAccounts(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 +} + +// GetIpamDiscoveredAccountsAPIClient is a client that implements the +// GetIpamDiscoveredAccounts operation. +type GetIpamDiscoveredAccountsAPIClient interface { + GetIpamDiscoveredAccounts(context.Context, *GetIpamDiscoveredAccountsInput, ...func(*Options)) (*GetIpamDiscoveredAccountsOutput, error) +} + +var _ GetIpamDiscoveredAccountsAPIClient = (*Client)(nil) + +// GetIpamDiscoveredAccountsPaginatorOptions is the paginator options for +// GetIpamDiscoveredAccounts +type GetIpamDiscoveredAccountsPaginatorOptions struct { + // The maximum number of discovered accounts to return in one page of results. + Limit int32 + + // Set to true if pagination should stop if the service returns a pagination token + // that matches the most recent token provided to the service. + StopOnDuplicateToken bool +} + +// GetIpamDiscoveredAccountsPaginator is a paginator for GetIpamDiscoveredAccounts +type GetIpamDiscoveredAccountsPaginator struct { + options GetIpamDiscoveredAccountsPaginatorOptions + client GetIpamDiscoveredAccountsAPIClient + params *GetIpamDiscoveredAccountsInput + nextToken *string + firstPage bool +} + +// NewGetIpamDiscoveredAccountsPaginator returns a new +// GetIpamDiscoveredAccountsPaginator +func NewGetIpamDiscoveredAccountsPaginator(client GetIpamDiscoveredAccountsAPIClient, params *GetIpamDiscoveredAccountsInput, optFns ...func(*GetIpamDiscoveredAccountsPaginatorOptions)) *GetIpamDiscoveredAccountsPaginator { + if params == nil { + params = &GetIpamDiscoveredAccountsInput{} + } + + options := GetIpamDiscoveredAccountsPaginatorOptions{} + if params.MaxResults != nil { + options.Limit = *params.MaxResults + } + + for _, fn := range optFns { + fn(&options) + } + + return &GetIpamDiscoveredAccountsPaginator{ + options: options, + client: client, + params: params, + firstPage: true, + nextToken: params.NextToken, + } +} + +// HasMorePages returns a boolean indicating whether more pages are available +func (p *GetIpamDiscoveredAccountsPaginator) HasMorePages() bool { + return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0) +} + +// NextPage retrieves the next GetIpamDiscoveredAccounts page. +func (p *GetIpamDiscoveredAccountsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*GetIpamDiscoveredAccountsOutput, error) { + if !p.HasMorePages() { + return nil, fmt.Errorf("no more pages available") + } + + params := *p.params + params.NextToken = p.nextToken + + var limit *int32 + if p.options.Limit > 0 { + limit = &p.options.Limit + } + params.MaxResults = limit + + result, err := p.client.GetIpamDiscoveredAccounts(ctx, ¶ms, optFns...) + if err != nil { + return nil, err + } + p.firstPage = false + + prevToken := p.nextToken + p.nextToken = result.NextToken + + if p.options.StopOnDuplicateToken && + prevToken != nil && + p.nextToken != nil && + *prevToken == *p.nextToken { + p.nextToken = nil + } + + return result, nil +} + +func newServiceMetadataMiddleware_opGetIpamDiscoveredAccounts(region string) *awsmiddleware.RegisterServiceMetadata { + return &awsmiddleware.RegisterServiceMetadata{ + Region: region, + ServiceID: ServiceID, + SigningName: "ec2", + OperationName: "GetIpamDiscoveredAccounts", + } +} diff --git a/service/ec2/api_op_GetIpamDiscoveredResourceCidrs.go b/service/ec2/api_op_GetIpamDiscoveredResourceCidrs.go new file mode 100644 index 00000000000..579fda50083 --- /dev/null +++ b/service/ec2/api_op_GetIpamDiscoveredResourceCidrs.go @@ -0,0 +1,245 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package ec2 + +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/ec2/types" + "github.com/aws/smithy-go/middleware" + smithyhttp "github.com/aws/smithy-go/transport/http" +) + +// Returns the resource CIDRs that are monitored as part of a resource discovery. A +// discovered resource is a resource CIDR monitored under a resource discovery. The +// following resources can be discovered: VPCs, Public IPv4 pools, VPC subnets, and +// Elastic IP addresses. +func (c *Client) GetIpamDiscoveredResourceCidrs(ctx context.Context, params *GetIpamDiscoveredResourceCidrsInput, optFns ...func(*Options)) (*GetIpamDiscoveredResourceCidrsOutput, error) { + if params == nil { + params = &GetIpamDiscoveredResourceCidrsInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "GetIpamDiscoveredResourceCidrs", params, optFns, c.addOperationGetIpamDiscoveredResourceCidrsMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*GetIpamDiscoveredResourceCidrsOutput) + out.ResultMetadata = metadata + return out, nil +} + +type GetIpamDiscoveredResourceCidrsInput struct { + + // A resource discovery ID. + // + // This member is required. + IpamResourceDiscoveryId *string + + // A resource Region. + // + // This member is required. + ResourceRegion *string + + // A check for whether you have the required permissions for the action without + // actually making the request and provides an error response. If you have the + // required permissions, the error response is DryRunOperation. Otherwise, it is + // UnauthorizedOperation. + DryRun *bool + + // Filters. + Filters []types.Filter + + // The maximum number of discovered resource CIDRs to return in one page of + // results. + MaxResults *int32 + + // Specify the pagination token from a previous request to retrieve the next page + // of results. + NextToken *string + + noSmithyDocumentSerde +} + +type GetIpamDiscoveredResourceCidrsOutput struct { + + // Discovered resource CIDRs. + IpamDiscoveredResourceCidrs []types.IpamDiscoveredResourceCidr + + // Specify the pagination token from a previous request to retrieve the next page + // of results. + NextToken *string + + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (c *Client) addOperationGetIpamDiscoveredResourceCidrsMiddlewares(stack *middleware.Stack, options Options) (err error) { + err = stack.Serialize.Add(&awsEc2query_serializeOpGetIpamDiscoveredResourceCidrs{}, middleware.After) + if err != nil { + return err + } + err = stack.Deserialize.Add(&awsEc2query_deserializeOpGetIpamDiscoveredResourceCidrs{}, 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 = addOpGetIpamDiscoveredResourceCidrsValidationMiddleware(stack); err != nil { + return err + } + if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetIpamDiscoveredResourceCidrs(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 +} + +// GetIpamDiscoveredResourceCidrsAPIClient is a client that implements the +// GetIpamDiscoveredResourceCidrs operation. +type GetIpamDiscoveredResourceCidrsAPIClient interface { + GetIpamDiscoveredResourceCidrs(context.Context, *GetIpamDiscoveredResourceCidrsInput, ...func(*Options)) (*GetIpamDiscoveredResourceCidrsOutput, error) +} + +var _ GetIpamDiscoveredResourceCidrsAPIClient = (*Client)(nil) + +// GetIpamDiscoveredResourceCidrsPaginatorOptions is the paginator options for +// GetIpamDiscoveredResourceCidrs +type GetIpamDiscoveredResourceCidrsPaginatorOptions struct { + // The maximum number of discovered resource CIDRs to return in one page of + // results. + Limit int32 + + // Set to true if pagination should stop if the service returns a pagination token + // that matches the most recent token provided to the service. + StopOnDuplicateToken bool +} + +// GetIpamDiscoveredResourceCidrsPaginator is a paginator for +// GetIpamDiscoveredResourceCidrs +type GetIpamDiscoveredResourceCidrsPaginator struct { + options GetIpamDiscoveredResourceCidrsPaginatorOptions + client GetIpamDiscoveredResourceCidrsAPIClient + params *GetIpamDiscoveredResourceCidrsInput + nextToken *string + firstPage bool +} + +// NewGetIpamDiscoveredResourceCidrsPaginator returns a new +// GetIpamDiscoveredResourceCidrsPaginator +func NewGetIpamDiscoveredResourceCidrsPaginator(client GetIpamDiscoveredResourceCidrsAPIClient, params *GetIpamDiscoveredResourceCidrsInput, optFns ...func(*GetIpamDiscoveredResourceCidrsPaginatorOptions)) *GetIpamDiscoveredResourceCidrsPaginator { + if params == nil { + params = &GetIpamDiscoveredResourceCidrsInput{} + } + + options := GetIpamDiscoveredResourceCidrsPaginatorOptions{} + if params.MaxResults != nil { + options.Limit = *params.MaxResults + } + + for _, fn := range optFns { + fn(&options) + } + + return &GetIpamDiscoveredResourceCidrsPaginator{ + options: options, + client: client, + params: params, + firstPage: true, + nextToken: params.NextToken, + } +} + +// HasMorePages returns a boolean indicating whether more pages are available +func (p *GetIpamDiscoveredResourceCidrsPaginator) HasMorePages() bool { + return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0) +} + +// NextPage retrieves the next GetIpamDiscoveredResourceCidrs page. +func (p *GetIpamDiscoveredResourceCidrsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*GetIpamDiscoveredResourceCidrsOutput, error) { + if !p.HasMorePages() { + return nil, fmt.Errorf("no more pages available") + } + + params := *p.params + params.NextToken = p.nextToken + + var limit *int32 + if p.options.Limit > 0 { + limit = &p.options.Limit + } + params.MaxResults = limit + + result, err := p.client.GetIpamDiscoveredResourceCidrs(ctx, ¶ms, optFns...) + if err != nil { + return nil, err + } + p.firstPage = false + + prevToken := p.nextToken + p.nextToken = result.NextToken + + if p.options.StopOnDuplicateToken && + prevToken != nil && + p.nextToken != nil && + *prevToken == *p.nextToken { + p.nextToken = nil + } + + return result, nil +} + +func newServiceMetadataMiddleware_opGetIpamDiscoveredResourceCidrs(region string) *awsmiddleware.RegisterServiceMetadata { + return &awsmiddleware.RegisterServiceMetadata{ + Region: region, + ServiceID: ServiceID, + SigningName: "ec2", + OperationName: "GetIpamDiscoveredResourceCidrs", + } +} diff --git a/service/ec2/api_op_GetIpamResourceCidrs.go b/service/ec2/api_op_GetIpamResourceCidrs.go index 3f63cc2a356..b56d62828b2 100644 --- a/service/ec2/api_op_GetIpamResourceCidrs.go +++ b/service/ec2/api_op_GetIpamResourceCidrs.go @@ -12,7 +12,11 @@ import ( smithyhttp "github.com/aws/smithy-go/transport/http" ) -// Get information about the resources in a scope. +// Returns resource CIDRs managed by IPAM in a given scope. If an IPAM is +// associated with more than one resource discovery, the resource CIDRs across all +// of the resource discoveries is returned. A resource discovery is an IPAM +// component that enables IPAM Service to manage and monitor resources that belong +// to the owning account. func (c *Client) GetIpamResourceCidrs(ctx context.Context, params *GetIpamResourceCidrsInput, optFns ...func(*Options)) (*GetIpamResourceCidrsOutput, error) { if params == nil { params = &GetIpamResourceCidrsInput{} diff --git a/service/ec2/api_op_ModifyIpamResourceDiscovery.go b/service/ec2/api_op_ModifyIpamResourceDiscovery.go new file mode 100644 index 00000000000..a72027e9801 --- /dev/null +++ b/service/ec2/api_op_ModifyIpamResourceDiscovery.go @@ -0,0 +1,141 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package ec2 + +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/ec2/types" + "github.com/aws/smithy-go/middleware" + smithyhttp "github.com/aws/smithy-go/transport/http" +) + +// Modifies a resource discovery. A resource discovery is an IPAM component that +// enables IPAM Service to manage and monitor resources that belong to the owning +// account. +func (c *Client) ModifyIpamResourceDiscovery(ctx context.Context, params *ModifyIpamResourceDiscoveryInput, optFns ...func(*Options)) (*ModifyIpamResourceDiscoveryOutput, error) { + if params == nil { + params = &ModifyIpamResourceDiscoveryInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "ModifyIpamResourceDiscovery", params, optFns, c.addOperationModifyIpamResourceDiscoveryMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*ModifyIpamResourceDiscoveryOutput) + out.ResultMetadata = metadata + return out, nil +} + +type ModifyIpamResourceDiscoveryInput struct { + + // A resource discovery ID. + // + // This member is required. + IpamResourceDiscoveryId *string + + // Add operating Regions to the resource discovery. Operating Regions are Amazon + // Web Services Regions where the IPAM is allowed to manage IP address CIDRs. IPAM + // only discovers and monitors resources in the Amazon Web Services Regions you + // select as operating Regions. + AddOperatingRegions []types.AddIpamOperatingRegion + + // A resource discovery description. + Description *string + + // A check for whether you have the required permissions for the action without + // actually making the request and provides an error response. If you have the + // required permissions, the error response is DryRunOperation. Otherwise, it is + // UnauthorizedOperation. + DryRun *bool + + // Remove operating Regions. + RemoveOperatingRegions []types.RemoveIpamOperatingRegion + + noSmithyDocumentSerde +} + +type ModifyIpamResourceDiscoveryOutput struct { + + // A resource discovery. + IpamResourceDiscovery *types.IpamResourceDiscovery + + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (c *Client) addOperationModifyIpamResourceDiscoveryMiddlewares(stack *middleware.Stack, options Options) (err error) { + err = stack.Serialize.Add(&awsEc2query_serializeOpModifyIpamResourceDiscovery{}, middleware.After) + if err != nil { + return err + } + err = stack.Deserialize.Add(&awsEc2query_deserializeOpModifyIpamResourceDiscovery{}, 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 = addOpModifyIpamResourceDiscoveryValidationMiddleware(stack); err != nil { + return err + } + if err = stack.Initialize.Add(newServiceMetadataMiddleware_opModifyIpamResourceDiscovery(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_opModifyIpamResourceDiscovery(region string) *awsmiddleware.RegisterServiceMetadata { + return &awsmiddleware.RegisterServiceMetadata{ + Region: region, + ServiceID: ServiceID, + SigningName: "ec2", + OperationName: "ModifyIpamResourceDiscovery", + } +} diff --git a/service/ec2/api_op_MoveByoipCidrToIpam.go b/service/ec2/api_op_MoveByoipCidrToIpam.go index e9a9bbc0a18..70f7b63d593 100644 --- a/service/ec2/api_op_MoveByoipCidrToIpam.go +++ b/service/ec2/api_op_MoveByoipCidrToIpam.go @@ -11,8 +11,8 @@ import ( smithyhttp "github.com/aws/smithy-go/transport/http" ) -// Move an BYOIP IPv4 CIDR to IPAM from a public IPv4 pool. If you already have an -// IPv4 BYOIP CIDR with Amazon Web Services, you can move the CIDR to IPAM from a +// Move a BYOIPv4 CIDR to IPAM from a public IPv4 pool. If you already have a +// BYOIPv4 CIDR with Amazon Web Services, you can move the CIDR to IPAM from a // public IPv4 pool. You cannot move an IPv6 CIDR to IPAM. If you are bringing a // new IP address to Amazon Web Services for the first time, complete the steps in // Tutorial: BYOIP address CIDRs to IPAM diff --git a/service/ec2/api_op_ProvisionIpamPoolCidr.go b/service/ec2/api_op_ProvisionIpamPoolCidr.go index 66043a08311..dfa3a41e6a0 100644 --- a/service/ec2/api_op_ProvisionIpamPoolCidr.go +++ b/service/ec2/api_op_ProvisionIpamPoolCidr.go @@ -4,6 +4,7 @@ package ec2 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/ec2/types" @@ -38,19 +39,32 @@ type ProvisionIpamPoolCidrInput struct { // This member is required. IpamPoolId *string - // The CIDR you want to assign to the IPAM pool. + // The CIDR you want to assign to the IPAM pool. Either "NetmaskLength" or "Cidr" + // is required. This value will be null if you specify "NetmaskLength" and will be + // filled in during the provisioning process. Cidr *string // A signed document that proves that you are authorized to bring a specified IP // address range to Amazon using BYOIP. This option applies to public pools only. CidrAuthorizationContext *types.IpamCidrAuthorizationContext + // A unique, case-sensitive identifier that you provide to ensure the idempotency + // of the request. For more information, see Ensuring Idempotency + // (https://docs.aws.amazon.com/AWSEC2/latest/APIReference/Run_Instance_Idempotency.html). + ClientToken *string + // A check for whether you have the required permissions for the action without // actually making the request and provides an error response. If you have the // required permissions, the error response is DryRunOperation. Otherwise, it is // UnauthorizedOperation. DryRun *bool + // The netmask length of the CIDR you'd like to provision to a pool. Can be used + // for provisioning Amazon-provided IPv6 CIDRs to top-level pools and for + // provisioning CIDRs to pools with source pools. Cannot be used to provision BYOIP + // CIDRs to top-level pools. Either "NetmaskLength" or "Cidr" is required. + NetmaskLength *int32 + noSmithyDocumentSerde } @@ -110,6 +124,9 @@ func (c *Client) addOperationProvisionIpamPoolCidrMiddlewares(stack *middleware. if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addIdempotencyToken_opProvisionIpamPoolCidrMiddleware(stack, options); err != nil { + return err + } if err = addOpProvisionIpamPoolCidrValidationMiddleware(stack); err != nil { return err } @@ -128,6 +145,39 @@ func (c *Client) addOperationProvisionIpamPoolCidrMiddlewares(stack *middleware. return nil } +type idempotencyToken_initializeOpProvisionIpamPoolCidr struct { + tokenProvider IdempotencyTokenProvider +} + +func (*idempotencyToken_initializeOpProvisionIpamPoolCidr) ID() string { + return "OperationIdempotencyTokenAutoFill" +} + +func (m *idempotencyToken_initializeOpProvisionIpamPoolCidr) 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.(*ProvisionIpamPoolCidrInput) + if !ok { + return out, metadata, fmt.Errorf("expected middleware input to be of type *ProvisionIpamPoolCidrInput ") + } + + 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_opProvisionIpamPoolCidrMiddleware(stack *middleware.Stack, cfg Options) error { + return stack.Initialize.Add(&idempotencyToken_initializeOpProvisionIpamPoolCidr{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before) +} + func newServiceMetadataMiddleware_opProvisionIpamPoolCidr(region string) *awsmiddleware.RegisterServiceMetadata { return &awsmiddleware.RegisterServiceMetadata{ Region: region, diff --git a/service/ec2/deserializers.go b/service/ec2/deserializers.go index 03b2f69bfbc..ec5491cc5b8 100644 --- a/service/ec2/deserializers.go +++ b/service/ec2/deserializers.go @@ -1821,6 +1821,97 @@ func awsEc2query_deserializeOpErrorAssociateInstanceEventWindow(response *smithy } } +type awsEc2query_deserializeOpAssociateIpamResourceDiscovery struct { +} + +func (*awsEc2query_deserializeOpAssociateIpamResourceDiscovery) ID() string { + return "OperationDeserializer" +} + +func (m *awsEc2query_deserializeOpAssociateIpamResourceDiscovery) HandleDeserialize(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, awsEc2query_deserializeOpErrorAssociateIpamResourceDiscovery(response, &metadata) + } + output := &AssociateIpamResourceDiscoveryOutput{} + out.Result = output + + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + body := io.TeeReader(response.Body, ringBuffer) + rootDecoder := xml.NewDecoder(body) + t, err := smithyxml.FetchRootElement(rootDecoder) + if err == io.EOF { + return out, metadata, nil + } + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + return out, metadata, &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + } + + decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) + err = awsEc2query_deserializeOpDocumentAssociateIpamResourceDiscoveryOutput(&output, decoder) + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return out, metadata, err + } + + return out, metadata, err +} + +func awsEc2query_deserializeOpErrorAssociateIpamResourceDiscovery(response *smithyhttp.Response, metadata *middleware.Metadata) error { + var errorBuffer bytes.Buffer + if _, err := io.Copy(&errorBuffer, response.Body); err != nil { + return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} + } + errorBody := bytes.NewReader(errorBuffer.Bytes()) + + errorCode := "UnknownError" + errorMessage := errorCode + + errorComponents, err := ec2query.GetErrorResponseComponents(errorBody) + if err != nil { + return err + } + awsmiddleware.SetRequestIDMetadata(metadata, errorComponents.RequestID) + if len(errorComponents.Code) != 0 { + errorCode = errorComponents.Code + } + if len(errorComponents.Message) != 0 { + errorMessage = errorComponents.Message + } + errorBody.Seek(0, io.SeekStart) + switch { + default: + genericError := &smithy.GenericAPIError{ + Code: errorCode, + Message: errorMessage, + } + return genericError + + } +} + type awsEc2query_deserializeOpAssociateRouteTable struct { } @@ -6484,6 +6575,97 @@ func awsEc2query_deserializeOpErrorCreateIpamPool(response *smithyhttp.Response, } } +type awsEc2query_deserializeOpCreateIpamResourceDiscovery struct { +} + +func (*awsEc2query_deserializeOpCreateIpamResourceDiscovery) ID() string { + return "OperationDeserializer" +} + +func (m *awsEc2query_deserializeOpCreateIpamResourceDiscovery) HandleDeserialize(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, awsEc2query_deserializeOpErrorCreateIpamResourceDiscovery(response, &metadata) + } + output := &CreateIpamResourceDiscoveryOutput{} + out.Result = output + + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + body := io.TeeReader(response.Body, ringBuffer) + rootDecoder := xml.NewDecoder(body) + t, err := smithyxml.FetchRootElement(rootDecoder) + if err == io.EOF { + return out, metadata, nil + } + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + return out, metadata, &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + } + + decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) + err = awsEc2query_deserializeOpDocumentCreateIpamResourceDiscoveryOutput(&output, decoder) + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return out, metadata, err + } + + return out, metadata, err +} + +func awsEc2query_deserializeOpErrorCreateIpamResourceDiscovery(response *smithyhttp.Response, metadata *middleware.Metadata) error { + var errorBuffer bytes.Buffer + if _, err := io.Copy(&errorBuffer, response.Body); err != nil { + return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} + } + errorBody := bytes.NewReader(errorBuffer.Bytes()) + + errorCode := "UnknownError" + errorMessage := errorCode + + errorComponents, err := ec2query.GetErrorResponseComponents(errorBody) + if err != nil { + return err + } + awsmiddleware.SetRequestIDMetadata(metadata, errorComponents.RequestID) + if len(errorComponents.Code) != 0 { + errorCode = errorComponents.Code + } + if len(errorComponents.Message) != 0 { + errorMessage = errorComponents.Message + } + errorBody.Seek(0, io.SeekStart) + switch { + default: + genericError := &smithy.GenericAPIError{ + Code: errorCode, + Message: errorMessage, + } + return genericError + + } +} + type awsEc2query_deserializeOpCreateIpamScope struct { } @@ -13080,6 +13262,97 @@ func awsEc2query_deserializeOpErrorDeleteIpamPool(response *smithyhttp.Response, } } +type awsEc2query_deserializeOpDeleteIpamResourceDiscovery struct { +} + +func (*awsEc2query_deserializeOpDeleteIpamResourceDiscovery) ID() string { + return "OperationDeserializer" +} + +func (m *awsEc2query_deserializeOpDeleteIpamResourceDiscovery) HandleDeserialize(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, awsEc2query_deserializeOpErrorDeleteIpamResourceDiscovery(response, &metadata) + } + output := &DeleteIpamResourceDiscoveryOutput{} + out.Result = output + + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + body := io.TeeReader(response.Body, ringBuffer) + rootDecoder := xml.NewDecoder(body) + t, err := smithyxml.FetchRootElement(rootDecoder) + if err == io.EOF { + return out, metadata, nil + } + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + return out, metadata, &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + } + + decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) + err = awsEc2query_deserializeOpDocumentDeleteIpamResourceDiscoveryOutput(&output, decoder) + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return out, metadata, err + } + + return out, metadata, err +} + +func awsEc2query_deserializeOpErrorDeleteIpamResourceDiscovery(response *smithyhttp.Response, metadata *middleware.Metadata) error { + var errorBuffer bytes.Buffer + if _, err := io.Copy(&errorBuffer, response.Body); err != nil { + return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} + } + errorBody := bytes.NewReader(errorBuffer.Bytes()) + + errorCode := "UnknownError" + errorMessage := errorCode + + errorComponents, err := ec2query.GetErrorResponseComponents(errorBody) + if err != nil { + return err + } + awsmiddleware.SetRequestIDMetadata(metadata, errorComponents.RequestID) + if len(errorComponents.Code) != 0 { + errorCode = errorComponents.Code + } + if len(errorComponents.Message) != 0 { + errorMessage = errorComponents.Message + } + errorBody.Seek(0, io.SeekStart) + switch { + default: + genericError := &smithy.GenericAPIError{ + Code: errorCode, + Message: errorMessage, + } + return genericError + + } +} + type awsEc2query_deserializeOpDeleteIpamScope struct { } @@ -23404,14 +23677,14 @@ func awsEc2query_deserializeOpErrorDescribeIpamPools(response *smithyhttp.Respon } } -type awsEc2query_deserializeOpDescribeIpams struct { +type awsEc2query_deserializeOpDescribeIpamResourceDiscoveries struct { } -func (*awsEc2query_deserializeOpDescribeIpams) ID() string { +func (*awsEc2query_deserializeOpDescribeIpamResourceDiscoveries) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDescribeIpams) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDescribeIpamResourceDiscoveries) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -23425,9 +23698,191 @@ func (m *awsEc2query_deserializeOpDescribeIpams) HandleDeserialize(ctx context.C } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDescribeIpams(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDescribeIpamResourceDiscoveries(response, &metadata) } - output := &DescribeIpamsOutput{} + output := &DescribeIpamResourceDiscoveriesOutput{} + out.Result = output + + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + body := io.TeeReader(response.Body, ringBuffer) + rootDecoder := xml.NewDecoder(body) + t, err := smithyxml.FetchRootElement(rootDecoder) + if err == io.EOF { + return out, metadata, nil + } + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + return out, metadata, &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + } + + decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) + err = awsEc2query_deserializeOpDocumentDescribeIpamResourceDiscoveriesOutput(&output, decoder) + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return out, metadata, err + } + + return out, metadata, err +} + +func awsEc2query_deserializeOpErrorDescribeIpamResourceDiscoveries(response *smithyhttp.Response, metadata *middleware.Metadata) error { + var errorBuffer bytes.Buffer + if _, err := io.Copy(&errorBuffer, response.Body); err != nil { + return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} + } + errorBody := bytes.NewReader(errorBuffer.Bytes()) + + errorCode := "UnknownError" + errorMessage := errorCode + + errorComponents, err := ec2query.GetErrorResponseComponents(errorBody) + if err != nil { + return err + } + awsmiddleware.SetRequestIDMetadata(metadata, errorComponents.RequestID) + if len(errorComponents.Code) != 0 { + errorCode = errorComponents.Code + } + if len(errorComponents.Message) != 0 { + errorMessage = errorComponents.Message + } + errorBody.Seek(0, io.SeekStart) + switch { + default: + genericError := &smithy.GenericAPIError{ + Code: errorCode, + Message: errorMessage, + } + return genericError + + } +} + +type awsEc2query_deserializeOpDescribeIpamResourceDiscoveryAssociations struct { +} + +func (*awsEc2query_deserializeOpDescribeIpamResourceDiscoveryAssociations) ID() string { + return "OperationDeserializer" +} + +func (m *awsEc2query_deserializeOpDescribeIpamResourceDiscoveryAssociations) HandleDeserialize(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, awsEc2query_deserializeOpErrorDescribeIpamResourceDiscoveryAssociations(response, &metadata) + } + output := &DescribeIpamResourceDiscoveryAssociationsOutput{} + out.Result = output + + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + body := io.TeeReader(response.Body, ringBuffer) + rootDecoder := xml.NewDecoder(body) + t, err := smithyxml.FetchRootElement(rootDecoder) + if err == io.EOF { + return out, metadata, nil + } + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + return out, metadata, &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + } + + decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) + err = awsEc2query_deserializeOpDocumentDescribeIpamResourceDiscoveryAssociationsOutput(&output, decoder) + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return out, metadata, err + } + + return out, metadata, err +} + +func awsEc2query_deserializeOpErrorDescribeIpamResourceDiscoveryAssociations(response *smithyhttp.Response, metadata *middleware.Metadata) error { + var errorBuffer bytes.Buffer + if _, err := io.Copy(&errorBuffer, response.Body); err != nil { + return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} + } + errorBody := bytes.NewReader(errorBuffer.Bytes()) + + errorCode := "UnknownError" + errorMessage := errorCode + + errorComponents, err := ec2query.GetErrorResponseComponents(errorBody) + if err != nil { + return err + } + awsmiddleware.SetRequestIDMetadata(metadata, errorComponents.RequestID) + if len(errorComponents.Code) != 0 { + errorCode = errorComponents.Code + } + if len(errorComponents.Message) != 0 { + errorMessage = errorComponents.Message + } + errorBody.Seek(0, io.SeekStart) + switch { + default: + genericError := &smithy.GenericAPIError{ + Code: errorCode, + Message: errorMessage, + } + return genericError + + } +} + +type awsEc2query_deserializeOpDescribeIpams struct { +} + +func (*awsEc2query_deserializeOpDescribeIpams) ID() string { + return "OperationDeserializer" +} + +func (m *awsEc2query_deserializeOpDescribeIpams) HandleDeserialize(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, awsEc2query_deserializeOpErrorDescribeIpams(response, &metadata) + } + output := &DescribeIpamsOutput{} out.Result = output var buff [1024]byte @@ -33390,6 +33845,97 @@ func awsEc2query_deserializeOpErrorDisassociateInstanceEventWindow(response *smi } } +type awsEc2query_deserializeOpDisassociateIpamResourceDiscovery struct { +} + +func (*awsEc2query_deserializeOpDisassociateIpamResourceDiscovery) ID() string { + return "OperationDeserializer" +} + +func (m *awsEc2query_deserializeOpDisassociateIpamResourceDiscovery) HandleDeserialize(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, awsEc2query_deserializeOpErrorDisassociateIpamResourceDiscovery(response, &metadata) + } + output := &DisassociateIpamResourceDiscoveryOutput{} + out.Result = output + + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + body := io.TeeReader(response.Body, ringBuffer) + rootDecoder := xml.NewDecoder(body) + t, err := smithyxml.FetchRootElement(rootDecoder) + if err == io.EOF { + return out, metadata, nil + } + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + return out, metadata, &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + } + + decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) + err = awsEc2query_deserializeOpDocumentDisassociateIpamResourceDiscoveryOutput(&output, decoder) + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return out, metadata, err + } + + return out, metadata, err +} + +func awsEc2query_deserializeOpErrorDisassociateIpamResourceDiscovery(response *smithyhttp.Response, metadata *middleware.Metadata) error { + var errorBuffer bytes.Buffer + if _, err := io.Copy(&errorBuffer, response.Body); err != nil { + return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} + } + errorBody := bytes.NewReader(errorBuffer.Bytes()) + + errorCode := "UnknownError" + errorMessage := errorCode + + errorComponents, err := ec2query.GetErrorResponseComponents(errorBody) + if err != nil { + return err + } + awsmiddleware.SetRequestIDMetadata(metadata, errorComponents.RequestID) + if len(errorComponents.Code) != 0 { + errorCode = errorComponents.Code + } + if len(errorComponents.Message) != 0 { + errorMessage = errorComponents.Message + } + errorBody.Seek(0, io.SeekStart) + switch { + default: + genericError := &smithy.GenericAPIError{ + Code: errorCode, + Message: errorMessage, + } + return genericError + + } +} + type awsEc2query_deserializeOpDisassociateRouteTable struct { } @@ -37052,6 +37598,188 @@ func awsEc2query_deserializeOpErrorGetIpamAddressHistory(response *smithyhttp.Re } } +type awsEc2query_deserializeOpGetIpamDiscoveredAccounts struct { +} + +func (*awsEc2query_deserializeOpGetIpamDiscoveredAccounts) ID() string { + return "OperationDeserializer" +} + +func (m *awsEc2query_deserializeOpGetIpamDiscoveredAccounts) HandleDeserialize(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, awsEc2query_deserializeOpErrorGetIpamDiscoveredAccounts(response, &metadata) + } + output := &GetIpamDiscoveredAccountsOutput{} + out.Result = output + + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + body := io.TeeReader(response.Body, ringBuffer) + rootDecoder := xml.NewDecoder(body) + t, err := smithyxml.FetchRootElement(rootDecoder) + if err == io.EOF { + return out, metadata, nil + } + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + return out, metadata, &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + } + + decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) + err = awsEc2query_deserializeOpDocumentGetIpamDiscoveredAccountsOutput(&output, decoder) + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return out, metadata, err + } + + return out, metadata, err +} + +func awsEc2query_deserializeOpErrorGetIpamDiscoveredAccounts(response *smithyhttp.Response, metadata *middleware.Metadata) error { + var errorBuffer bytes.Buffer + if _, err := io.Copy(&errorBuffer, response.Body); err != nil { + return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} + } + errorBody := bytes.NewReader(errorBuffer.Bytes()) + + errorCode := "UnknownError" + errorMessage := errorCode + + errorComponents, err := ec2query.GetErrorResponseComponents(errorBody) + if err != nil { + return err + } + awsmiddleware.SetRequestIDMetadata(metadata, errorComponents.RequestID) + if len(errorComponents.Code) != 0 { + errorCode = errorComponents.Code + } + if len(errorComponents.Message) != 0 { + errorMessage = errorComponents.Message + } + errorBody.Seek(0, io.SeekStart) + switch { + default: + genericError := &smithy.GenericAPIError{ + Code: errorCode, + Message: errorMessage, + } + return genericError + + } +} + +type awsEc2query_deserializeOpGetIpamDiscoveredResourceCidrs struct { +} + +func (*awsEc2query_deserializeOpGetIpamDiscoveredResourceCidrs) ID() string { + return "OperationDeserializer" +} + +func (m *awsEc2query_deserializeOpGetIpamDiscoveredResourceCidrs) HandleDeserialize(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, awsEc2query_deserializeOpErrorGetIpamDiscoveredResourceCidrs(response, &metadata) + } + output := &GetIpamDiscoveredResourceCidrsOutput{} + out.Result = output + + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + body := io.TeeReader(response.Body, ringBuffer) + rootDecoder := xml.NewDecoder(body) + t, err := smithyxml.FetchRootElement(rootDecoder) + if err == io.EOF { + return out, metadata, nil + } + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + return out, metadata, &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + } + + decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) + err = awsEc2query_deserializeOpDocumentGetIpamDiscoveredResourceCidrsOutput(&output, decoder) + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return out, metadata, err + } + + return out, metadata, err +} + +func awsEc2query_deserializeOpErrorGetIpamDiscoveredResourceCidrs(response *smithyhttp.Response, metadata *middleware.Metadata) error { + var errorBuffer bytes.Buffer + if _, err := io.Copy(&errorBuffer, response.Body); err != nil { + return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} + } + errorBody := bytes.NewReader(errorBuffer.Bytes()) + + errorCode := "UnknownError" + errorMessage := errorCode + + errorComponents, err := ec2query.GetErrorResponseComponents(errorBody) + if err != nil { + return err + } + awsmiddleware.SetRequestIDMetadata(metadata, errorComponents.RequestID) + if len(errorComponents.Code) != 0 { + errorCode = errorComponents.Code + } + if len(errorComponents.Message) != 0 { + errorMessage = errorComponents.Message + } + errorBody.Seek(0, io.SeekStart) + switch { + default: + genericError := &smithy.GenericAPIError{ + Code: errorCode, + Message: errorMessage, + } + return genericError + + } +} + type awsEc2query_deserializeOpGetIpamPoolAllocations struct { } @@ -42056,14 +42784,14 @@ func awsEc2query_deserializeOpErrorModifyIpamResourceCidr(response *smithyhttp.R } } -type awsEc2query_deserializeOpModifyIpamScope struct { +type awsEc2query_deserializeOpModifyIpamResourceDiscovery struct { } -func (*awsEc2query_deserializeOpModifyIpamScope) ID() string { +func (*awsEc2query_deserializeOpModifyIpamResourceDiscovery) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpModifyIpamScope) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpModifyIpamResourceDiscovery) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -42077,9 +42805,9 @@ func (m *awsEc2query_deserializeOpModifyIpamScope) HandleDeserialize(ctx context } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorModifyIpamScope(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorModifyIpamResourceDiscovery(response, &metadata) } - output := &ModifyIpamScopeOutput{} + output := &ModifyIpamResourceDiscoveryOutput{} out.Result = output var buff [1024]byte @@ -42100,7 +42828,7 @@ func (m *awsEc2query_deserializeOpModifyIpamScope) HandleDeserialize(ctx context } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentModifyIpamScopeOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentModifyIpamResourceDiscoveryOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -42114,98 +42842,7 @@ func (m *awsEc2query_deserializeOpModifyIpamScope) HandleDeserialize(ctx context return out, metadata, err } -func awsEc2query_deserializeOpErrorModifyIpamScope(response *smithyhttp.Response, metadata *middleware.Metadata) error { - var errorBuffer bytes.Buffer - if _, err := io.Copy(&errorBuffer, response.Body); err != nil { - return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} - } - errorBody := bytes.NewReader(errorBuffer.Bytes()) - - errorCode := "UnknownError" - errorMessage := errorCode - - errorComponents, err := ec2query.GetErrorResponseComponents(errorBody) - if err != nil { - return err - } - awsmiddleware.SetRequestIDMetadata(metadata, errorComponents.RequestID) - if len(errorComponents.Code) != 0 { - errorCode = errorComponents.Code - } - if len(errorComponents.Message) != 0 { - errorMessage = errorComponents.Message - } - errorBody.Seek(0, io.SeekStart) - switch { - default: - genericError := &smithy.GenericAPIError{ - Code: errorCode, - Message: errorMessage, - } - return genericError - - } -} - -type awsEc2query_deserializeOpModifyLaunchTemplate struct { -} - -func (*awsEc2query_deserializeOpModifyLaunchTemplate) ID() string { - return "OperationDeserializer" -} - -func (m *awsEc2query_deserializeOpModifyLaunchTemplate) HandleDeserialize(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, awsEc2query_deserializeOpErrorModifyLaunchTemplate(response, &metadata) - } - output := &ModifyLaunchTemplateOutput{} - out.Result = output - - var buff [1024]byte - ringBuffer := smithyio.NewRingBuffer(buff[:]) - body := io.TeeReader(response.Body, ringBuffer) - rootDecoder := xml.NewDecoder(body) - t, err := smithyxml.FetchRootElement(rootDecoder) - if err == io.EOF { - return out, metadata, nil - } - if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - return out, metadata, &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - } - - decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentModifyLaunchTemplateOutput(&output, decoder) - if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - return out, metadata, err - } - - return out, metadata, err -} - -func awsEc2query_deserializeOpErrorModifyLaunchTemplate(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorModifyIpamResourceDiscovery(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -42238,14 +42875,14 @@ func awsEc2query_deserializeOpErrorModifyLaunchTemplate(response *smithyhttp.Res } } -type awsEc2query_deserializeOpModifyLocalGatewayRoute struct { +type awsEc2query_deserializeOpModifyIpamScope struct { } -func (*awsEc2query_deserializeOpModifyLocalGatewayRoute) ID() string { +func (*awsEc2query_deserializeOpModifyIpamScope) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpModifyLocalGatewayRoute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpModifyIpamScope) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -42259,9 +42896,9 @@ func (m *awsEc2query_deserializeOpModifyLocalGatewayRoute) HandleDeserialize(ctx } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorModifyLocalGatewayRoute(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorModifyIpamScope(response, &metadata) } - output := &ModifyLocalGatewayRouteOutput{} + output := &ModifyIpamScopeOutput{} out.Result = output var buff [1024]byte @@ -42282,7 +42919,7 @@ func (m *awsEc2query_deserializeOpModifyLocalGatewayRoute) HandleDeserialize(ctx } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentModifyLocalGatewayRouteOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentModifyIpamScopeOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -42296,7 +42933,7 @@ func (m *awsEc2query_deserializeOpModifyLocalGatewayRoute) HandleDeserialize(ctx return out, metadata, err } -func awsEc2query_deserializeOpErrorModifyLocalGatewayRoute(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorModifyIpamScope(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -42329,14 +42966,14 @@ func awsEc2query_deserializeOpErrorModifyLocalGatewayRoute(response *smithyhttp. } } -type awsEc2query_deserializeOpModifyManagedPrefixList struct { +type awsEc2query_deserializeOpModifyLaunchTemplate struct { } -func (*awsEc2query_deserializeOpModifyManagedPrefixList) ID() string { +func (*awsEc2query_deserializeOpModifyLaunchTemplate) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpModifyManagedPrefixList) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpModifyLaunchTemplate) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -42350,9 +42987,9 @@ func (m *awsEc2query_deserializeOpModifyManagedPrefixList) HandleDeserialize(ctx } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorModifyManagedPrefixList(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorModifyLaunchTemplate(response, &metadata) } - output := &ModifyManagedPrefixListOutput{} + output := &ModifyLaunchTemplateOutput{} out.Result = output var buff [1024]byte @@ -42373,7 +43010,7 @@ func (m *awsEc2query_deserializeOpModifyManagedPrefixList) HandleDeserialize(ctx } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentModifyManagedPrefixListOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentModifyLaunchTemplateOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -42387,7 +43024,7 @@ func (m *awsEc2query_deserializeOpModifyManagedPrefixList) HandleDeserialize(ctx return out, metadata, err } -func awsEc2query_deserializeOpErrorModifyManagedPrefixList(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorModifyLaunchTemplate(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -42420,14 +43057,14 @@ func awsEc2query_deserializeOpErrorModifyManagedPrefixList(response *smithyhttp. } } -type awsEc2query_deserializeOpModifyNetworkInterfaceAttribute struct { +type awsEc2query_deserializeOpModifyLocalGatewayRoute struct { } -func (*awsEc2query_deserializeOpModifyNetworkInterfaceAttribute) ID() string { +func (*awsEc2query_deserializeOpModifyLocalGatewayRoute) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpModifyNetworkInterfaceAttribute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpModifyLocalGatewayRoute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -42441,21 +43078,44 @@ func (m *awsEc2query_deserializeOpModifyNetworkInterfaceAttribute) HandleDeseria } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorModifyNetworkInterfaceAttribute(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorModifyLocalGatewayRoute(response, &metadata) } - output := &ModifyNetworkInterfaceAttributeOutput{} + output := &ModifyLocalGatewayRouteOutput{} out.Result = output - if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + body := io.TeeReader(response.Body, ringBuffer) + rootDecoder := xml.NewDecoder(body) + t, err := smithyxml.FetchRootElement(rootDecoder) + if err == io.EOF { + return out, metadata, nil + } + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) return out, metadata, &smithy.DeserializationError{ - Err: fmt.Errorf("failed to discard response body, %w", err), + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + } + + decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) + err = awsEc2query_deserializeOpDocumentModifyLocalGatewayRouteOutput(&output, decoder) + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), } + return out, metadata, err } return out, metadata, err } -func awsEc2query_deserializeOpErrorModifyNetworkInterfaceAttribute(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorModifyLocalGatewayRoute(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -42488,14 +43148,14 @@ func awsEc2query_deserializeOpErrorModifyNetworkInterfaceAttribute(response *smi } } -type awsEc2query_deserializeOpModifyPrivateDnsNameOptions struct { +type awsEc2query_deserializeOpModifyManagedPrefixList struct { } -func (*awsEc2query_deserializeOpModifyPrivateDnsNameOptions) ID() string { +func (*awsEc2query_deserializeOpModifyManagedPrefixList) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpModifyPrivateDnsNameOptions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpModifyManagedPrefixList) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -42509,9 +43169,9 @@ func (m *awsEc2query_deserializeOpModifyPrivateDnsNameOptions) HandleDeserialize } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorModifyPrivateDnsNameOptions(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorModifyManagedPrefixList(response, &metadata) } - output := &ModifyPrivateDnsNameOptionsOutput{} + output := &ModifyManagedPrefixListOutput{} out.Result = output var buff [1024]byte @@ -42532,7 +43192,7 @@ func (m *awsEc2query_deserializeOpModifyPrivateDnsNameOptions) HandleDeserialize } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentModifyPrivateDnsNameOptionsOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentModifyManagedPrefixListOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -42546,7 +43206,7 @@ func (m *awsEc2query_deserializeOpModifyPrivateDnsNameOptions) HandleDeserialize return out, metadata, err } -func awsEc2query_deserializeOpErrorModifyPrivateDnsNameOptions(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorModifyManagedPrefixList(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -42579,14 +43239,14 @@ func awsEc2query_deserializeOpErrorModifyPrivateDnsNameOptions(response *smithyh } } -type awsEc2query_deserializeOpModifyReservedInstances struct { +type awsEc2query_deserializeOpModifyNetworkInterfaceAttribute struct { } -func (*awsEc2query_deserializeOpModifyReservedInstances) ID() string { +func (*awsEc2query_deserializeOpModifyNetworkInterfaceAttribute) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpModifyReservedInstances) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpModifyNetworkInterfaceAttribute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -42600,44 +43260,21 @@ func (m *awsEc2query_deserializeOpModifyReservedInstances) HandleDeserialize(ctx } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorModifyReservedInstances(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorModifyNetworkInterfaceAttribute(response, &metadata) } - output := &ModifyReservedInstancesOutput{} + output := &ModifyNetworkInterfaceAttributeOutput{} out.Result = output - var buff [1024]byte - ringBuffer := smithyio.NewRingBuffer(buff[:]) - body := io.TeeReader(response.Body, ringBuffer) - rootDecoder := xml.NewDecoder(body) - t, err := smithyxml.FetchRootElement(rootDecoder) - if err == io.EOF { - return out, metadata, nil - } - if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) + if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { return out, metadata, &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), + Err: fmt.Errorf("failed to discard response body, %w", err), } } - decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentModifyReservedInstancesOutput(&output, decoder) - if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - return out, metadata, err - } - return out, metadata, err } -func awsEc2query_deserializeOpErrorModifyReservedInstances(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorModifyNetworkInterfaceAttribute(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -42670,14 +43307,14 @@ func awsEc2query_deserializeOpErrorModifyReservedInstances(response *smithyhttp. } } -type awsEc2query_deserializeOpModifySecurityGroupRules struct { +type awsEc2query_deserializeOpModifyPrivateDnsNameOptions struct { } -func (*awsEc2query_deserializeOpModifySecurityGroupRules) ID() string { +func (*awsEc2query_deserializeOpModifyPrivateDnsNameOptions) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpModifySecurityGroupRules) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpModifyPrivateDnsNameOptions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -42691,9 +43328,9 @@ func (m *awsEc2query_deserializeOpModifySecurityGroupRules) HandleDeserialize(ct } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorModifySecurityGroupRules(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorModifyPrivateDnsNameOptions(response, &metadata) } - output := &ModifySecurityGroupRulesOutput{} + output := &ModifyPrivateDnsNameOptionsOutput{} out.Result = output var buff [1024]byte @@ -42714,7 +43351,7 @@ func (m *awsEc2query_deserializeOpModifySecurityGroupRules) HandleDeserialize(ct } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentModifySecurityGroupRulesOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentModifyPrivateDnsNameOptionsOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -42728,7 +43365,7 @@ func (m *awsEc2query_deserializeOpModifySecurityGroupRules) HandleDeserialize(ct return out, metadata, err } -func awsEc2query_deserializeOpErrorModifySecurityGroupRules(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorModifyPrivateDnsNameOptions(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -42761,14 +43398,14 @@ func awsEc2query_deserializeOpErrorModifySecurityGroupRules(response *smithyhttp } } -type awsEc2query_deserializeOpModifySnapshotAttribute struct { +type awsEc2query_deserializeOpModifyReservedInstances struct { } -func (*awsEc2query_deserializeOpModifySnapshotAttribute) ID() string { +func (*awsEc2query_deserializeOpModifyReservedInstances) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpModifySnapshotAttribute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpModifyReservedInstances) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -42782,21 +43419,44 @@ func (m *awsEc2query_deserializeOpModifySnapshotAttribute) HandleDeserialize(ctx } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorModifySnapshotAttribute(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorModifyReservedInstances(response, &metadata) } - output := &ModifySnapshotAttributeOutput{} + output := &ModifyReservedInstancesOutput{} out.Result = output - if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + body := io.TeeReader(response.Body, ringBuffer) + rootDecoder := xml.NewDecoder(body) + t, err := smithyxml.FetchRootElement(rootDecoder) + if err == io.EOF { + return out, metadata, nil + } + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) return out, metadata, &smithy.DeserializationError{ - Err: fmt.Errorf("failed to discard response body, %w", err), + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + } + + decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) + err = awsEc2query_deserializeOpDocumentModifyReservedInstancesOutput(&output, decoder) + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), } + return out, metadata, err } return out, metadata, err } -func awsEc2query_deserializeOpErrorModifySnapshotAttribute(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorModifyReservedInstances(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -42829,14 +43489,14 @@ func awsEc2query_deserializeOpErrorModifySnapshotAttribute(response *smithyhttp. } } -type awsEc2query_deserializeOpModifySnapshotTier struct { +type awsEc2query_deserializeOpModifySecurityGroupRules struct { } -func (*awsEc2query_deserializeOpModifySnapshotTier) ID() string { +func (*awsEc2query_deserializeOpModifySecurityGroupRules) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpModifySnapshotTier) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpModifySecurityGroupRules) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -42850,9 +43510,9 @@ func (m *awsEc2query_deserializeOpModifySnapshotTier) HandleDeserialize(ctx cont } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorModifySnapshotTier(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorModifySecurityGroupRules(response, &metadata) } - output := &ModifySnapshotTierOutput{} + output := &ModifySecurityGroupRulesOutput{} out.Result = output var buff [1024]byte @@ -42873,7 +43533,7 @@ func (m *awsEc2query_deserializeOpModifySnapshotTier) HandleDeserialize(ctx cont } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentModifySnapshotTierOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentModifySecurityGroupRulesOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -42887,7 +43547,7 @@ func (m *awsEc2query_deserializeOpModifySnapshotTier) HandleDeserialize(ctx cont return out, metadata, err } -func awsEc2query_deserializeOpErrorModifySnapshotTier(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorModifySecurityGroupRules(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -42920,14 +43580,14 @@ func awsEc2query_deserializeOpErrorModifySnapshotTier(response *smithyhttp.Respo } } -type awsEc2query_deserializeOpModifySpotFleetRequest struct { +type awsEc2query_deserializeOpModifySnapshotAttribute struct { } -func (*awsEc2query_deserializeOpModifySpotFleetRequest) ID() string { +func (*awsEc2query_deserializeOpModifySnapshotAttribute) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpModifySpotFleetRequest) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpModifySnapshotAttribute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -42941,44 +43601,21 @@ func (m *awsEc2query_deserializeOpModifySpotFleetRequest) HandleDeserialize(ctx } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorModifySpotFleetRequest(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorModifySnapshotAttribute(response, &metadata) } - output := &ModifySpotFleetRequestOutput{} + output := &ModifySnapshotAttributeOutput{} out.Result = output - var buff [1024]byte - ringBuffer := smithyio.NewRingBuffer(buff[:]) - body := io.TeeReader(response.Body, ringBuffer) - rootDecoder := xml.NewDecoder(body) - t, err := smithyxml.FetchRootElement(rootDecoder) - if err == io.EOF { - return out, metadata, nil - } - if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) + if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { return out, metadata, &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - } - - decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentModifySpotFleetRequestOutput(&output, decoder) - if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), + Err: fmt.Errorf("failed to discard response body, %w", err), } - return out, metadata, err } return out, metadata, err } -func awsEc2query_deserializeOpErrorModifySpotFleetRequest(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorModifySnapshotAttribute(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -43011,14 +43648,14 @@ func awsEc2query_deserializeOpErrorModifySpotFleetRequest(response *smithyhttp.R } } -type awsEc2query_deserializeOpModifySubnetAttribute struct { +type awsEc2query_deserializeOpModifySnapshotTier struct { } -func (*awsEc2query_deserializeOpModifySubnetAttribute) ID() string { +func (*awsEc2query_deserializeOpModifySnapshotTier) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpModifySubnetAttribute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpModifySnapshotTier) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -43032,21 +43669,44 @@ func (m *awsEc2query_deserializeOpModifySubnetAttribute) HandleDeserialize(ctx c } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorModifySubnetAttribute(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorModifySnapshotTier(response, &metadata) } - output := &ModifySubnetAttributeOutput{} + output := &ModifySnapshotTierOutput{} out.Result = output - if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + body := io.TeeReader(response.Body, ringBuffer) + rootDecoder := xml.NewDecoder(body) + t, err := smithyxml.FetchRootElement(rootDecoder) + if err == io.EOF { + return out, metadata, nil + } + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) return out, metadata, &smithy.DeserializationError{ - Err: fmt.Errorf("failed to discard response body, %w", err), + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + } + + decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) + err = awsEc2query_deserializeOpDocumentModifySnapshotTierOutput(&output, decoder) + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), } + return out, metadata, err } return out, metadata, err } -func awsEc2query_deserializeOpErrorModifySubnetAttribute(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorModifySnapshotTier(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -43079,14 +43739,14 @@ func awsEc2query_deserializeOpErrorModifySubnetAttribute(response *smithyhttp.Re } } -type awsEc2query_deserializeOpModifyTrafficMirrorFilterNetworkServices struct { +type awsEc2query_deserializeOpModifySpotFleetRequest struct { } -func (*awsEc2query_deserializeOpModifyTrafficMirrorFilterNetworkServices) ID() string { +func (*awsEc2query_deserializeOpModifySpotFleetRequest) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpModifyTrafficMirrorFilterNetworkServices) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpModifySpotFleetRequest) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -43100,9 +43760,9 @@ func (m *awsEc2query_deserializeOpModifyTrafficMirrorFilterNetworkServices) Hand } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorModifyTrafficMirrorFilterNetworkServices(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorModifySpotFleetRequest(response, &metadata) } - output := &ModifyTrafficMirrorFilterNetworkServicesOutput{} + output := &ModifySpotFleetRequestOutput{} out.Result = output var buff [1024]byte @@ -43123,7 +43783,7 @@ func (m *awsEc2query_deserializeOpModifyTrafficMirrorFilterNetworkServices) Hand } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentModifyTrafficMirrorFilterNetworkServicesOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentModifySpotFleetRequestOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -43137,7 +43797,7 @@ func (m *awsEc2query_deserializeOpModifyTrafficMirrorFilterNetworkServices) Hand return out, metadata, err } -func awsEc2query_deserializeOpErrorModifyTrafficMirrorFilterNetworkServices(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorModifySpotFleetRequest(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -43170,14 +43830,14 @@ func awsEc2query_deserializeOpErrorModifyTrafficMirrorFilterNetworkServices(resp } } -type awsEc2query_deserializeOpModifyTrafficMirrorFilterRule struct { +type awsEc2query_deserializeOpModifySubnetAttribute struct { } -func (*awsEc2query_deserializeOpModifyTrafficMirrorFilterRule) ID() string { +func (*awsEc2query_deserializeOpModifySubnetAttribute) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpModifyTrafficMirrorFilterRule) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpModifySubnetAttribute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -43191,44 +43851,21 @@ func (m *awsEc2query_deserializeOpModifyTrafficMirrorFilterRule) HandleDeseriali } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorModifyTrafficMirrorFilterRule(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorModifySubnetAttribute(response, &metadata) } - output := &ModifyTrafficMirrorFilterRuleOutput{} + output := &ModifySubnetAttributeOutput{} out.Result = output - var buff [1024]byte - ringBuffer := smithyio.NewRingBuffer(buff[:]) - body := io.TeeReader(response.Body, ringBuffer) - rootDecoder := xml.NewDecoder(body) - t, err := smithyxml.FetchRootElement(rootDecoder) - if err == io.EOF { - return out, metadata, nil - } - if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) + if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { return out, metadata, &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - } - - decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentModifyTrafficMirrorFilterRuleOutput(&output, decoder) - if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), + Err: fmt.Errorf("failed to discard response body, %w", err), } - return out, metadata, err } return out, metadata, err } -func awsEc2query_deserializeOpErrorModifyTrafficMirrorFilterRule(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorModifySubnetAttribute(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -43261,14 +43898,14 @@ func awsEc2query_deserializeOpErrorModifyTrafficMirrorFilterRule(response *smith } } -type awsEc2query_deserializeOpModifyTrafficMirrorSession struct { +type awsEc2query_deserializeOpModifyTrafficMirrorFilterNetworkServices struct { } -func (*awsEc2query_deserializeOpModifyTrafficMirrorSession) ID() string { +func (*awsEc2query_deserializeOpModifyTrafficMirrorFilterNetworkServices) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpModifyTrafficMirrorSession) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpModifyTrafficMirrorFilterNetworkServices) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -43282,9 +43919,9 @@ func (m *awsEc2query_deserializeOpModifyTrafficMirrorSession) HandleDeserialize( } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorModifyTrafficMirrorSession(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorModifyTrafficMirrorFilterNetworkServices(response, &metadata) } - output := &ModifyTrafficMirrorSessionOutput{} + output := &ModifyTrafficMirrorFilterNetworkServicesOutput{} out.Result = output var buff [1024]byte @@ -43305,7 +43942,7 @@ func (m *awsEc2query_deserializeOpModifyTrafficMirrorSession) HandleDeserialize( } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentModifyTrafficMirrorSessionOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentModifyTrafficMirrorFilterNetworkServicesOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -43319,7 +43956,7 @@ func (m *awsEc2query_deserializeOpModifyTrafficMirrorSession) HandleDeserialize( return out, metadata, err } -func awsEc2query_deserializeOpErrorModifyTrafficMirrorSession(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorModifyTrafficMirrorFilterNetworkServices(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -43352,14 +43989,14 @@ func awsEc2query_deserializeOpErrorModifyTrafficMirrorSession(response *smithyht } } -type awsEc2query_deserializeOpModifyTransitGateway struct { +type awsEc2query_deserializeOpModifyTrafficMirrorFilterRule struct { } -func (*awsEc2query_deserializeOpModifyTransitGateway) ID() string { +func (*awsEc2query_deserializeOpModifyTrafficMirrorFilterRule) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpModifyTransitGateway) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpModifyTrafficMirrorFilterRule) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -43373,9 +44010,9 @@ func (m *awsEc2query_deserializeOpModifyTransitGateway) HandleDeserialize(ctx co } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorModifyTransitGateway(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorModifyTrafficMirrorFilterRule(response, &metadata) } - output := &ModifyTransitGatewayOutput{} + output := &ModifyTrafficMirrorFilterRuleOutput{} out.Result = output var buff [1024]byte @@ -43396,7 +44033,7 @@ func (m *awsEc2query_deserializeOpModifyTransitGateway) HandleDeserialize(ctx co } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentModifyTransitGatewayOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentModifyTrafficMirrorFilterRuleOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -43410,7 +44047,7 @@ func (m *awsEc2query_deserializeOpModifyTransitGateway) HandleDeserialize(ctx co return out, metadata, err } -func awsEc2query_deserializeOpErrorModifyTransitGateway(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorModifyTrafficMirrorFilterRule(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -43443,14 +44080,14 @@ func awsEc2query_deserializeOpErrorModifyTransitGateway(response *smithyhttp.Res } } -type awsEc2query_deserializeOpModifyTransitGatewayPrefixListReference struct { +type awsEc2query_deserializeOpModifyTrafficMirrorSession struct { } -func (*awsEc2query_deserializeOpModifyTransitGatewayPrefixListReference) ID() string { +func (*awsEc2query_deserializeOpModifyTrafficMirrorSession) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpModifyTransitGatewayPrefixListReference) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpModifyTrafficMirrorSession) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -43464,9 +44101,9 @@ func (m *awsEc2query_deserializeOpModifyTransitGatewayPrefixListReference) Handl } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorModifyTransitGatewayPrefixListReference(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorModifyTrafficMirrorSession(response, &metadata) } - output := &ModifyTransitGatewayPrefixListReferenceOutput{} + output := &ModifyTrafficMirrorSessionOutput{} out.Result = output var buff [1024]byte @@ -43487,7 +44124,7 @@ func (m *awsEc2query_deserializeOpModifyTransitGatewayPrefixListReference) Handl } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentModifyTransitGatewayPrefixListReferenceOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentModifyTrafficMirrorSessionOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -43501,7 +44138,7 @@ func (m *awsEc2query_deserializeOpModifyTransitGatewayPrefixListReference) Handl return out, metadata, err } -func awsEc2query_deserializeOpErrorModifyTransitGatewayPrefixListReference(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorModifyTrafficMirrorSession(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -43534,14 +44171,14 @@ func awsEc2query_deserializeOpErrorModifyTransitGatewayPrefixListReference(respo } } -type awsEc2query_deserializeOpModifyTransitGatewayVpcAttachment struct { +type awsEc2query_deserializeOpModifyTransitGateway struct { } -func (*awsEc2query_deserializeOpModifyTransitGatewayVpcAttachment) ID() string { +func (*awsEc2query_deserializeOpModifyTransitGateway) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpModifyTransitGatewayVpcAttachment) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpModifyTransitGateway) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -43555,9 +44192,9 @@ func (m *awsEc2query_deserializeOpModifyTransitGatewayVpcAttachment) HandleDeser } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorModifyTransitGatewayVpcAttachment(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorModifyTransitGateway(response, &metadata) } - output := &ModifyTransitGatewayVpcAttachmentOutput{} + output := &ModifyTransitGatewayOutput{} out.Result = output var buff [1024]byte @@ -43578,7 +44215,7 @@ func (m *awsEc2query_deserializeOpModifyTransitGatewayVpcAttachment) HandleDeser } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentModifyTransitGatewayVpcAttachmentOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentModifyTransitGatewayOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -43592,7 +44229,7 @@ func (m *awsEc2query_deserializeOpModifyTransitGatewayVpcAttachment) HandleDeser return out, metadata, err } -func awsEc2query_deserializeOpErrorModifyTransitGatewayVpcAttachment(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorModifyTransitGateway(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -43625,14 +44262,14 @@ func awsEc2query_deserializeOpErrorModifyTransitGatewayVpcAttachment(response *s } } -type awsEc2query_deserializeOpModifyVerifiedAccessEndpoint struct { +type awsEc2query_deserializeOpModifyTransitGatewayPrefixListReference struct { } -func (*awsEc2query_deserializeOpModifyVerifiedAccessEndpoint) ID() string { +func (*awsEc2query_deserializeOpModifyTransitGatewayPrefixListReference) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpModifyVerifiedAccessEndpoint) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpModifyTransitGatewayPrefixListReference) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -43646,9 +44283,9 @@ func (m *awsEc2query_deserializeOpModifyVerifiedAccessEndpoint) HandleDeserializ } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorModifyVerifiedAccessEndpoint(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorModifyTransitGatewayPrefixListReference(response, &metadata) } - output := &ModifyVerifiedAccessEndpointOutput{} + output := &ModifyTransitGatewayPrefixListReferenceOutput{} out.Result = output var buff [1024]byte @@ -43669,7 +44306,7 @@ func (m *awsEc2query_deserializeOpModifyVerifiedAccessEndpoint) HandleDeserializ } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentModifyVerifiedAccessEndpointOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentModifyTransitGatewayPrefixListReferenceOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -43683,7 +44320,7 @@ func (m *awsEc2query_deserializeOpModifyVerifiedAccessEndpoint) HandleDeserializ return out, metadata, err } -func awsEc2query_deserializeOpErrorModifyVerifiedAccessEndpoint(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorModifyTransitGatewayPrefixListReference(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -43716,14 +44353,14 @@ func awsEc2query_deserializeOpErrorModifyVerifiedAccessEndpoint(response *smithy } } -type awsEc2query_deserializeOpModifyVerifiedAccessEndpointPolicy struct { +type awsEc2query_deserializeOpModifyTransitGatewayVpcAttachment struct { } -func (*awsEc2query_deserializeOpModifyVerifiedAccessEndpointPolicy) ID() string { +func (*awsEc2query_deserializeOpModifyTransitGatewayVpcAttachment) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpModifyVerifiedAccessEndpointPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpModifyTransitGatewayVpcAttachment) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -43737,9 +44374,9 @@ func (m *awsEc2query_deserializeOpModifyVerifiedAccessEndpointPolicy) HandleDese } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorModifyVerifiedAccessEndpointPolicy(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorModifyTransitGatewayVpcAttachment(response, &metadata) } - output := &ModifyVerifiedAccessEndpointPolicyOutput{} + output := &ModifyTransitGatewayVpcAttachmentOutput{} out.Result = output var buff [1024]byte @@ -43760,7 +44397,7 @@ func (m *awsEc2query_deserializeOpModifyVerifiedAccessEndpointPolicy) HandleDese } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentModifyVerifiedAccessEndpointPolicyOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentModifyTransitGatewayVpcAttachmentOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -43774,7 +44411,7 @@ func (m *awsEc2query_deserializeOpModifyVerifiedAccessEndpointPolicy) HandleDese return out, metadata, err } -func awsEc2query_deserializeOpErrorModifyVerifiedAccessEndpointPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorModifyTransitGatewayVpcAttachment(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -43807,14 +44444,14 @@ func awsEc2query_deserializeOpErrorModifyVerifiedAccessEndpointPolicy(response * } } -type awsEc2query_deserializeOpModifyVerifiedAccessGroup struct { +type awsEc2query_deserializeOpModifyVerifiedAccessEndpoint struct { } -func (*awsEc2query_deserializeOpModifyVerifiedAccessGroup) ID() string { +func (*awsEc2query_deserializeOpModifyVerifiedAccessEndpoint) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpModifyVerifiedAccessGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpModifyVerifiedAccessEndpoint) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -43828,9 +44465,9 @@ func (m *awsEc2query_deserializeOpModifyVerifiedAccessGroup) HandleDeserialize(c } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorModifyVerifiedAccessGroup(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorModifyVerifiedAccessEndpoint(response, &metadata) } - output := &ModifyVerifiedAccessGroupOutput{} + output := &ModifyVerifiedAccessEndpointOutput{} out.Result = output var buff [1024]byte @@ -43851,7 +44488,7 @@ func (m *awsEc2query_deserializeOpModifyVerifiedAccessGroup) HandleDeserialize(c } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentModifyVerifiedAccessGroupOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentModifyVerifiedAccessEndpointOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -43865,7 +44502,7 @@ func (m *awsEc2query_deserializeOpModifyVerifiedAccessGroup) HandleDeserialize(c return out, metadata, err } -func awsEc2query_deserializeOpErrorModifyVerifiedAccessGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorModifyVerifiedAccessEndpoint(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -43898,14 +44535,14 @@ func awsEc2query_deserializeOpErrorModifyVerifiedAccessGroup(response *smithyhtt } } -type awsEc2query_deserializeOpModifyVerifiedAccessGroupPolicy struct { +type awsEc2query_deserializeOpModifyVerifiedAccessEndpointPolicy struct { } -func (*awsEc2query_deserializeOpModifyVerifiedAccessGroupPolicy) ID() string { +func (*awsEc2query_deserializeOpModifyVerifiedAccessEndpointPolicy) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpModifyVerifiedAccessGroupPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpModifyVerifiedAccessEndpointPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -43919,9 +44556,9 @@ func (m *awsEc2query_deserializeOpModifyVerifiedAccessGroupPolicy) HandleDeseria } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorModifyVerifiedAccessGroupPolicy(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorModifyVerifiedAccessEndpointPolicy(response, &metadata) } - output := &ModifyVerifiedAccessGroupPolicyOutput{} + output := &ModifyVerifiedAccessEndpointPolicyOutput{} out.Result = output var buff [1024]byte @@ -43942,7 +44579,7 @@ func (m *awsEc2query_deserializeOpModifyVerifiedAccessGroupPolicy) HandleDeseria } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentModifyVerifiedAccessGroupPolicyOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentModifyVerifiedAccessEndpointPolicyOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -43956,7 +44593,7 @@ func (m *awsEc2query_deserializeOpModifyVerifiedAccessGroupPolicy) HandleDeseria return out, metadata, err } -func awsEc2query_deserializeOpErrorModifyVerifiedAccessGroupPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorModifyVerifiedAccessEndpointPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -43989,14 +44626,14 @@ func awsEc2query_deserializeOpErrorModifyVerifiedAccessGroupPolicy(response *smi } } -type awsEc2query_deserializeOpModifyVerifiedAccessInstance struct { +type awsEc2query_deserializeOpModifyVerifiedAccessGroup struct { } -func (*awsEc2query_deserializeOpModifyVerifiedAccessInstance) ID() string { +func (*awsEc2query_deserializeOpModifyVerifiedAccessGroup) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpModifyVerifiedAccessInstance) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpModifyVerifiedAccessGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -44010,9 +44647,9 @@ func (m *awsEc2query_deserializeOpModifyVerifiedAccessInstance) HandleDeserializ } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorModifyVerifiedAccessInstance(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorModifyVerifiedAccessGroup(response, &metadata) } - output := &ModifyVerifiedAccessInstanceOutput{} + output := &ModifyVerifiedAccessGroupOutput{} out.Result = output var buff [1024]byte @@ -44033,7 +44670,7 @@ func (m *awsEc2query_deserializeOpModifyVerifiedAccessInstance) HandleDeserializ } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentModifyVerifiedAccessInstanceOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentModifyVerifiedAccessGroupOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -44047,7 +44684,7 @@ func (m *awsEc2query_deserializeOpModifyVerifiedAccessInstance) HandleDeserializ return out, metadata, err } -func awsEc2query_deserializeOpErrorModifyVerifiedAccessInstance(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorModifyVerifiedAccessGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -44080,14 +44717,14 @@ func awsEc2query_deserializeOpErrorModifyVerifiedAccessInstance(response *smithy } } -type awsEc2query_deserializeOpModifyVerifiedAccessInstanceLoggingConfiguration struct { +type awsEc2query_deserializeOpModifyVerifiedAccessGroupPolicy struct { } -func (*awsEc2query_deserializeOpModifyVerifiedAccessInstanceLoggingConfiguration) ID() string { +func (*awsEc2query_deserializeOpModifyVerifiedAccessGroupPolicy) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpModifyVerifiedAccessInstanceLoggingConfiguration) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpModifyVerifiedAccessGroupPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -44101,9 +44738,9 @@ func (m *awsEc2query_deserializeOpModifyVerifiedAccessInstanceLoggingConfigurati } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorModifyVerifiedAccessInstanceLoggingConfiguration(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorModifyVerifiedAccessGroupPolicy(response, &metadata) } - output := &ModifyVerifiedAccessInstanceLoggingConfigurationOutput{} + output := &ModifyVerifiedAccessGroupPolicyOutput{} out.Result = output var buff [1024]byte @@ -44124,7 +44761,7 @@ func (m *awsEc2query_deserializeOpModifyVerifiedAccessInstanceLoggingConfigurati } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentModifyVerifiedAccessInstanceLoggingConfigurationOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentModifyVerifiedAccessGroupPolicyOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -44138,7 +44775,7 @@ func (m *awsEc2query_deserializeOpModifyVerifiedAccessInstanceLoggingConfigurati return out, metadata, err } -func awsEc2query_deserializeOpErrorModifyVerifiedAccessInstanceLoggingConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorModifyVerifiedAccessGroupPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -44171,14 +44808,14 @@ func awsEc2query_deserializeOpErrorModifyVerifiedAccessInstanceLoggingConfigurat } } -type awsEc2query_deserializeOpModifyVerifiedAccessTrustProvider struct { +type awsEc2query_deserializeOpModifyVerifiedAccessInstance struct { } -func (*awsEc2query_deserializeOpModifyVerifiedAccessTrustProvider) ID() string { +func (*awsEc2query_deserializeOpModifyVerifiedAccessInstance) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpModifyVerifiedAccessTrustProvider) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpModifyVerifiedAccessInstance) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -44192,9 +44829,9 @@ func (m *awsEc2query_deserializeOpModifyVerifiedAccessTrustProvider) HandleDeser } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorModifyVerifiedAccessTrustProvider(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorModifyVerifiedAccessInstance(response, &metadata) } - output := &ModifyVerifiedAccessTrustProviderOutput{} + output := &ModifyVerifiedAccessInstanceOutput{} out.Result = output var buff [1024]byte @@ -44215,7 +44852,7 @@ func (m *awsEc2query_deserializeOpModifyVerifiedAccessTrustProvider) HandleDeser } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentModifyVerifiedAccessTrustProviderOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentModifyVerifiedAccessInstanceOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -44229,7 +44866,7 @@ func (m *awsEc2query_deserializeOpModifyVerifiedAccessTrustProvider) HandleDeser return out, metadata, err } -func awsEc2query_deserializeOpErrorModifyVerifiedAccessTrustProvider(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorModifyVerifiedAccessInstance(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -44262,14 +44899,14 @@ func awsEc2query_deserializeOpErrorModifyVerifiedAccessTrustProvider(response *s } } -type awsEc2query_deserializeOpModifyVolume struct { +type awsEc2query_deserializeOpModifyVerifiedAccessInstanceLoggingConfiguration struct { } -func (*awsEc2query_deserializeOpModifyVolume) ID() string { +func (*awsEc2query_deserializeOpModifyVerifiedAccessInstanceLoggingConfiguration) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpModifyVolume) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpModifyVerifiedAccessInstanceLoggingConfiguration) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -44283,9 +44920,9 @@ func (m *awsEc2query_deserializeOpModifyVolume) HandleDeserialize(ctx context.Co } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorModifyVolume(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorModifyVerifiedAccessInstanceLoggingConfiguration(response, &metadata) } - output := &ModifyVolumeOutput{} + output := &ModifyVerifiedAccessInstanceLoggingConfigurationOutput{} out.Result = output var buff [1024]byte @@ -44306,7 +44943,7 @@ func (m *awsEc2query_deserializeOpModifyVolume) HandleDeserialize(ctx context.Co } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentModifyVolumeOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentModifyVerifiedAccessInstanceLoggingConfigurationOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -44320,7 +44957,7 @@ func (m *awsEc2query_deserializeOpModifyVolume) HandleDeserialize(ctx context.Co return out, metadata, err } -func awsEc2query_deserializeOpErrorModifyVolume(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorModifyVerifiedAccessInstanceLoggingConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -44353,14 +44990,14 @@ func awsEc2query_deserializeOpErrorModifyVolume(response *smithyhttp.Response, m } } -type awsEc2query_deserializeOpModifyVolumeAttribute struct { +type awsEc2query_deserializeOpModifyVerifiedAccessTrustProvider struct { } -func (*awsEc2query_deserializeOpModifyVolumeAttribute) ID() string { +func (*awsEc2query_deserializeOpModifyVerifiedAccessTrustProvider) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpModifyVolumeAttribute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpModifyVerifiedAccessTrustProvider) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -44374,21 +45011,44 @@ func (m *awsEc2query_deserializeOpModifyVolumeAttribute) HandleDeserialize(ctx c } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorModifyVolumeAttribute(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorModifyVerifiedAccessTrustProvider(response, &metadata) } - output := &ModifyVolumeAttributeOutput{} + output := &ModifyVerifiedAccessTrustProviderOutput{} out.Result = output - if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + body := io.TeeReader(response.Body, ringBuffer) + rootDecoder := xml.NewDecoder(body) + t, err := smithyxml.FetchRootElement(rootDecoder) + if err == io.EOF { + return out, metadata, nil + } + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) return out, metadata, &smithy.DeserializationError{ - Err: fmt.Errorf("failed to discard response body, %w", err), + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + } + + decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) + err = awsEc2query_deserializeOpDocumentModifyVerifiedAccessTrustProviderOutput(&output, decoder) + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), } + return out, metadata, err } return out, metadata, err } -func awsEc2query_deserializeOpErrorModifyVolumeAttribute(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorModifyVerifiedAccessTrustProvider(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -44421,14 +45081,14 @@ func awsEc2query_deserializeOpErrorModifyVolumeAttribute(response *smithyhttp.Re } } -type awsEc2query_deserializeOpModifyVpcAttribute struct { +type awsEc2query_deserializeOpModifyVolume struct { } -func (*awsEc2query_deserializeOpModifyVpcAttribute) ID() string { +func (*awsEc2query_deserializeOpModifyVolume) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpModifyVpcAttribute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpModifyVolume) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -44442,21 +45102,44 @@ func (m *awsEc2query_deserializeOpModifyVpcAttribute) HandleDeserialize(ctx cont } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorModifyVpcAttribute(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorModifyVolume(response, &metadata) } - output := &ModifyVpcAttributeOutput{} + output := &ModifyVolumeOutput{} out.Result = output - if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + body := io.TeeReader(response.Body, ringBuffer) + rootDecoder := xml.NewDecoder(body) + t, err := smithyxml.FetchRootElement(rootDecoder) + if err == io.EOF { + return out, metadata, nil + } + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) return out, metadata, &smithy.DeserializationError{ - Err: fmt.Errorf("failed to discard response body, %w", err), + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), } } + decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) + err = awsEc2query_deserializeOpDocumentModifyVolumeOutput(&output, decoder) + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return out, metadata, err + } + return out, metadata, err } -func awsEc2query_deserializeOpErrorModifyVpcAttribute(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorModifyVolume(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -44489,14 +45172,14 @@ func awsEc2query_deserializeOpErrorModifyVpcAttribute(response *smithyhttp.Respo } } -type awsEc2query_deserializeOpModifyVpcEndpoint struct { +type awsEc2query_deserializeOpModifyVolumeAttribute struct { } -func (*awsEc2query_deserializeOpModifyVpcEndpoint) ID() string { +func (*awsEc2query_deserializeOpModifyVolumeAttribute) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpModifyVpcEndpoint) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpModifyVolumeAttribute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -44510,44 +45193,21 @@ func (m *awsEc2query_deserializeOpModifyVpcEndpoint) HandleDeserialize(ctx conte } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorModifyVpcEndpoint(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorModifyVolumeAttribute(response, &metadata) } - output := &ModifyVpcEndpointOutput{} + output := &ModifyVolumeAttributeOutput{} out.Result = output - var buff [1024]byte - ringBuffer := smithyio.NewRingBuffer(buff[:]) - body := io.TeeReader(response.Body, ringBuffer) - rootDecoder := xml.NewDecoder(body) - t, err := smithyxml.FetchRootElement(rootDecoder) - if err == io.EOF { - return out, metadata, nil - } - if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) + if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { return out, metadata, &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - } - - decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentModifyVpcEndpointOutput(&output, decoder) - if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), + Err: fmt.Errorf("failed to discard response body, %w", err), } - return out, metadata, err } return out, metadata, err } -func awsEc2query_deserializeOpErrorModifyVpcEndpoint(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorModifyVolumeAttribute(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -44580,14 +45240,14 @@ func awsEc2query_deserializeOpErrorModifyVpcEndpoint(response *smithyhttp.Respon } } -type awsEc2query_deserializeOpModifyVpcEndpointConnectionNotification struct { +type awsEc2query_deserializeOpModifyVpcAttribute struct { } -func (*awsEc2query_deserializeOpModifyVpcEndpointConnectionNotification) ID() string { +func (*awsEc2query_deserializeOpModifyVpcAttribute) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpModifyVpcEndpointConnectionNotification) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpModifyVpcAttribute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -44601,44 +45261,21 @@ func (m *awsEc2query_deserializeOpModifyVpcEndpointConnectionNotification) Handl } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorModifyVpcEndpointConnectionNotification(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorModifyVpcAttribute(response, &metadata) } - output := &ModifyVpcEndpointConnectionNotificationOutput{} + output := &ModifyVpcAttributeOutput{} out.Result = output - var buff [1024]byte - ringBuffer := smithyio.NewRingBuffer(buff[:]) - body := io.TeeReader(response.Body, ringBuffer) - rootDecoder := xml.NewDecoder(body) - t, err := smithyxml.FetchRootElement(rootDecoder) - if err == io.EOF { - return out, metadata, nil - } - if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) + if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { return out, metadata, &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - } - - decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentModifyVpcEndpointConnectionNotificationOutput(&output, decoder) - if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), + Err: fmt.Errorf("failed to discard response body, %w", err), } - return out, metadata, err } return out, metadata, err } -func awsEc2query_deserializeOpErrorModifyVpcEndpointConnectionNotification(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorModifyVpcAttribute(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -44671,14 +45308,14 @@ func awsEc2query_deserializeOpErrorModifyVpcEndpointConnectionNotification(respo } } -type awsEc2query_deserializeOpModifyVpcEndpointServiceConfiguration struct { +type awsEc2query_deserializeOpModifyVpcEndpoint struct { } -func (*awsEc2query_deserializeOpModifyVpcEndpointServiceConfiguration) ID() string { +func (*awsEc2query_deserializeOpModifyVpcEndpoint) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpModifyVpcEndpointServiceConfiguration) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpModifyVpcEndpoint) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -44692,9 +45329,9 @@ func (m *awsEc2query_deserializeOpModifyVpcEndpointServiceConfiguration) HandleD } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorModifyVpcEndpointServiceConfiguration(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorModifyVpcEndpoint(response, &metadata) } - output := &ModifyVpcEndpointServiceConfigurationOutput{} + output := &ModifyVpcEndpointOutput{} out.Result = output var buff [1024]byte @@ -44715,7 +45352,7 @@ func (m *awsEc2query_deserializeOpModifyVpcEndpointServiceConfiguration) HandleD } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentModifyVpcEndpointServiceConfigurationOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentModifyVpcEndpointOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -44729,7 +45366,7 @@ func (m *awsEc2query_deserializeOpModifyVpcEndpointServiceConfiguration) HandleD return out, metadata, err } -func awsEc2query_deserializeOpErrorModifyVpcEndpointServiceConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorModifyVpcEndpoint(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -44762,14 +45399,14 @@ func awsEc2query_deserializeOpErrorModifyVpcEndpointServiceConfiguration(respons } } -type awsEc2query_deserializeOpModifyVpcEndpointServicePayerResponsibility struct { +type awsEc2query_deserializeOpModifyVpcEndpointConnectionNotification struct { } -func (*awsEc2query_deserializeOpModifyVpcEndpointServicePayerResponsibility) ID() string { +func (*awsEc2query_deserializeOpModifyVpcEndpointConnectionNotification) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpModifyVpcEndpointServicePayerResponsibility) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpModifyVpcEndpointConnectionNotification) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -44783,9 +45420,9 @@ func (m *awsEc2query_deserializeOpModifyVpcEndpointServicePayerResponsibility) H } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorModifyVpcEndpointServicePayerResponsibility(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorModifyVpcEndpointConnectionNotification(response, &metadata) } - output := &ModifyVpcEndpointServicePayerResponsibilityOutput{} + output := &ModifyVpcEndpointConnectionNotificationOutput{} out.Result = output var buff [1024]byte @@ -44806,7 +45443,7 @@ func (m *awsEc2query_deserializeOpModifyVpcEndpointServicePayerResponsibility) H } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentModifyVpcEndpointServicePayerResponsibilityOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentModifyVpcEndpointConnectionNotificationOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -44820,7 +45457,7 @@ func (m *awsEc2query_deserializeOpModifyVpcEndpointServicePayerResponsibility) H return out, metadata, err } -func awsEc2query_deserializeOpErrorModifyVpcEndpointServicePayerResponsibility(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorModifyVpcEndpointConnectionNotification(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -44853,14 +45490,14 @@ func awsEc2query_deserializeOpErrorModifyVpcEndpointServicePayerResponsibility(r } } -type awsEc2query_deserializeOpModifyVpcEndpointServicePermissions struct { +type awsEc2query_deserializeOpModifyVpcEndpointServiceConfiguration struct { } -func (*awsEc2query_deserializeOpModifyVpcEndpointServicePermissions) ID() string { +func (*awsEc2query_deserializeOpModifyVpcEndpointServiceConfiguration) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpModifyVpcEndpointServicePermissions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpModifyVpcEndpointServiceConfiguration) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -44874,9 +45511,9 @@ func (m *awsEc2query_deserializeOpModifyVpcEndpointServicePermissions) HandleDes } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorModifyVpcEndpointServicePermissions(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorModifyVpcEndpointServiceConfiguration(response, &metadata) } - output := &ModifyVpcEndpointServicePermissionsOutput{} + output := &ModifyVpcEndpointServiceConfigurationOutput{} out.Result = output var buff [1024]byte @@ -44897,7 +45534,7 @@ func (m *awsEc2query_deserializeOpModifyVpcEndpointServicePermissions) HandleDes } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentModifyVpcEndpointServicePermissionsOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentModifyVpcEndpointServiceConfigurationOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -44911,7 +45548,7 @@ func (m *awsEc2query_deserializeOpModifyVpcEndpointServicePermissions) HandleDes return out, metadata, err } -func awsEc2query_deserializeOpErrorModifyVpcEndpointServicePermissions(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorModifyVpcEndpointServiceConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -44944,14 +45581,14 @@ func awsEc2query_deserializeOpErrorModifyVpcEndpointServicePermissions(response } } -type awsEc2query_deserializeOpModifyVpcPeeringConnectionOptions struct { +type awsEc2query_deserializeOpModifyVpcEndpointServicePayerResponsibility struct { } -func (*awsEc2query_deserializeOpModifyVpcPeeringConnectionOptions) ID() string { +func (*awsEc2query_deserializeOpModifyVpcEndpointServicePayerResponsibility) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpModifyVpcPeeringConnectionOptions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpModifyVpcEndpointServicePayerResponsibility) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -44965,9 +45602,9 @@ func (m *awsEc2query_deserializeOpModifyVpcPeeringConnectionOptions) HandleDeser } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorModifyVpcPeeringConnectionOptions(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorModifyVpcEndpointServicePayerResponsibility(response, &metadata) } - output := &ModifyVpcPeeringConnectionOptionsOutput{} + output := &ModifyVpcEndpointServicePayerResponsibilityOutput{} out.Result = output var buff [1024]byte @@ -44988,7 +45625,7 @@ func (m *awsEc2query_deserializeOpModifyVpcPeeringConnectionOptions) HandleDeser } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentModifyVpcPeeringConnectionOptionsOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentModifyVpcEndpointServicePayerResponsibilityOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -45002,7 +45639,7 @@ func (m *awsEc2query_deserializeOpModifyVpcPeeringConnectionOptions) HandleDeser return out, metadata, err } -func awsEc2query_deserializeOpErrorModifyVpcPeeringConnectionOptions(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorModifyVpcEndpointServicePayerResponsibility(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -45035,14 +45672,14 @@ func awsEc2query_deserializeOpErrorModifyVpcPeeringConnectionOptions(response *s } } -type awsEc2query_deserializeOpModifyVpcTenancy struct { +type awsEc2query_deserializeOpModifyVpcEndpointServicePermissions struct { } -func (*awsEc2query_deserializeOpModifyVpcTenancy) ID() string { +func (*awsEc2query_deserializeOpModifyVpcEndpointServicePermissions) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpModifyVpcTenancy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpModifyVpcEndpointServicePermissions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -45056,9 +45693,9 @@ func (m *awsEc2query_deserializeOpModifyVpcTenancy) HandleDeserialize(ctx contex } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorModifyVpcTenancy(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorModifyVpcEndpointServicePermissions(response, &metadata) } - output := &ModifyVpcTenancyOutput{} + output := &ModifyVpcEndpointServicePermissionsOutput{} out.Result = output var buff [1024]byte @@ -45079,7 +45716,7 @@ func (m *awsEc2query_deserializeOpModifyVpcTenancy) HandleDeserialize(ctx contex } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentModifyVpcTenancyOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentModifyVpcEndpointServicePermissionsOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -45093,7 +45730,7 @@ func (m *awsEc2query_deserializeOpModifyVpcTenancy) HandleDeserialize(ctx contex return out, metadata, err } -func awsEc2query_deserializeOpErrorModifyVpcTenancy(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorModifyVpcEndpointServicePermissions(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -45126,14 +45763,14 @@ func awsEc2query_deserializeOpErrorModifyVpcTenancy(response *smithyhttp.Respons } } -type awsEc2query_deserializeOpModifyVpnConnection struct { +type awsEc2query_deserializeOpModifyVpcPeeringConnectionOptions struct { } -func (*awsEc2query_deserializeOpModifyVpnConnection) ID() string { +func (*awsEc2query_deserializeOpModifyVpcPeeringConnectionOptions) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpModifyVpnConnection) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpModifyVpcPeeringConnectionOptions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -45147,9 +45784,9 @@ func (m *awsEc2query_deserializeOpModifyVpnConnection) HandleDeserialize(ctx con } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorModifyVpnConnection(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorModifyVpcPeeringConnectionOptions(response, &metadata) } - output := &ModifyVpnConnectionOutput{} + output := &ModifyVpcPeeringConnectionOptionsOutput{} out.Result = output var buff [1024]byte @@ -45170,7 +45807,7 @@ func (m *awsEc2query_deserializeOpModifyVpnConnection) HandleDeserialize(ctx con } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentModifyVpnConnectionOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentModifyVpcPeeringConnectionOptionsOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -45184,7 +45821,7 @@ func (m *awsEc2query_deserializeOpModifyVpnConnection) HandleDeserialize(ctx con return out, metadata, err } -func awsEc2query_deserializeOpErrorModifyVpnConnection(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorModifyVpcPeeringConnectionOptions(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -45217,14 +45854,14 @@ func awsEc2query_deserializeOpErrorModifyVpnConnection(response *smithyhttp.Resp } } -type awsEc2query_deserializeOpModifyVpnConnectionOptions struct { +type awsEc2query_deserializeOpModifyVpcTenancy struct { } -func (*awsEc2query_deserializeOpModifyVpnConnectionOptions) ID() string { +func (*awsEc2query_deserializeOpModifyVpcTenancy) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpModifyVpnConnectionOptions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpModifyVpcTenancy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -45238,9 +45875,9 @@ func (m *awsEc2query_deserializeOpModifyVpnConnectionOptions) HandleDeserialize( } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorModifyVpnConnectionOptions(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorModifyVpcTenancy(response, &metadata) } - output := &ModifyVpnConnectionOptionsOutput{} + output := &ModifyVpcTenancyOutput{} out.Result = output var buff [1024]byte @@ -45261,7 +45898,7 @@ func (m *awsEc2query_deserializeOpModifyVpnConnectionOptions) HandleDeserialize( } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentModifyVpnConnectionOptionsOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentModifyVpcTenancyOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -45275,7 +45912,7 @@ func (m *awsEc2query_deserializeOpModifyVpnConnectionOptions) HandleDeserialize( return out, metadata, err } -func awsEc2query_deserializeOpErrorModifyVpnConnectionOptions(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorModifyVpcTenancy(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -45308,14 +45945,14 @@ func awsEc2query_deserializeOpErrorModifyVpnConnectionOptions(response *smithyht } } -type awsEc2query_deserializeOpModifyVpnTunnelCertificate struct { +type awsEc2query_deserializeOpModifyVpnConnection struct { } -func (*awsEc2query_deserializeOpModifyVpnTunnelCertificate) ID() string { +func (*awsEc2query_deserializeOpModifyVpnConnection) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpModifyVpnTunnelCertificate) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpModifyVpnConnection) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -45329,9 +45966,9 @@ func (m *awsEc2query_deserializeOpModifyVpnTunnelCertificate) HandleDeserialize( } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorModifyVpnTunnelCertificate(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorModifyVpnConnection(response, &metadata) } - output := &ModifyVpnTunnelCertificateOutput{} + output := &ModifyVpnConnectionOutput{} out.Result = output var buff [1024]byte @@ -45352,7 +45989,7 @@ func (m *awsEc2query_deserializeOpModifyVpnTunnelCertificate) HandleDeserialize( } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentModifyVpnTunnelCertificateOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentModifyVpnConnectionOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -45366,7 +46003,7 @@ func (m *awsEc2query_deserializeOpModifyVpnTunnelCertificate) HandleDeserialize( return out, metadata, err } -func awsEc2query_deserializeOpErrorModifyVpnTunnelCertificate(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorModifyVpnConnection(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -45399,14 +46036,14 @@ func awsEc2query_deserializeOpErrorModifyVpnTunnelCertificate(response *smithyht } } -type awsEc2query_deserializeOpModifyVpnTunnelOptions struct { +type awsEc2query_deserializeOpModifyVpnConnectionOptions struct { } -func (*awsEc2query_deserializeOpModifyVpnTunnelOptions) ID() string { +func (*awsEc2query_deserializeOpModifyVpnConnectionOptions) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpModifyVpnTunnelOptions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpModifyVpnConnectionOptions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -45420,9 +46057,9 @@ func (m *awsEc2query_deserializeOpModifyVpnTunnelOptions) HandleDeserialize(ctx } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorModifyVpnTunnelOptions(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorModifyVpnConnectionOptions(response, &metadata) } - output := &ModifyVpnTunnelOptionsOutput{} + output := &ModifyVpnConnectionOptionsOutput{} out.Result = output var buff [1024]byte @@ -45443,7 +46080,7 @@ func (m *awsEc2query_deserializeOpModifyVpnTunnelOptions) HandleDeserialize(ctx } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentModifyVpnTunnelOptionsOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentModifyVpnConnectionOptionsOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -45457,7 +46094,7 @@ func (m *awsEc2query_deserializeOpModifyVpnTunnelOptions) HandleDeserialize(ctx return out, metadata, err } -func awsEc2query_deserializeOpErrorModifyVpnTunnelOptions(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorModifyVpnConnectionOptions(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -45490,14 +46127,14 @@ func awsEc2query_deserializeOpErrorModifyVpnTunnelOptions(response *smithyhttp.R } } -type awsEc2query_deserializeOpMonitorInstances struct { +type awsEc2query_deserializeOpModifyVpnTunnelCertificate struct { } -func (*awsEc2query_deserializeOpMonitorInstances) ID() string { +func (*awsEc2query_deserializeOpModifyVpnTunnelCertificate) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpMonitorInstances) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpModifyVpnTunnelCertificate) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -45511,9 +46148,9 @@ func (m *awsEc2query_deserializeOpMonitorInstances) HandleDeserialize(ctx contex } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorMonitorInstances(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorModifyVpnTunnelCertificate(response, &metadata) } - output := &MonitorInstancesOutput{} + output := &ModifyVpnTunnelCertificateOutput{} out.Result = output var buff [1024]byte @@ -45534,7 +46171,7 @@ func (m *awsEc2query_deserializeOpMonitorInstances) HandleDeserialize(ctx contex } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentMonitorInstancesOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentModifyVpnTunnelCertificateOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -45548,7 +46185,7 @@ func (m *awsEc2query_deserializeOpMonitorInstances) HandleDeserialize(ctx contex return out, metadata, err } -func awsEc2query_deserializeOpErrorMonitorInstances(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorModifyVpnTunnelCertificate(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -45581,14 +46218,14 @@ func awsEc2query_deserializeOpErrorMonitorInstances(response *smithyhttp.Respons } } -type awsEc2query_deserializeOpMoveAddressToVpc struct { +type awsEc2query_deserializeOpModifyVpnTunnelOptions struct { } -func (*awsEc2query_deserializeOpMoveAddressToVpc) ID() string { +func (*awsEc2query_deserializeOpModifyVpnTunnelOptions) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpMoveAddressToVpc) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpModifyVpnTunnelOptions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -45602,9 +46239,9 @@ func (m *awsEc2query_deserializeOpMoveAddressToVpc) HandleDeserialize(ctx contex } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorMoveAddressToVpc(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorModifyVpnTunnelOptions(response, &metadata) } - output := &MoveAddressToVpcOutput{} + output := &ModifyVpnTunnelOptionsOutput{} out.Result = output var buff [1024]byte @@ -45625,7 +46262,7 @@ func (m *awsEc2query_deserializeOpMoveAddressToVpc) HandleDeserialize(ctx contex } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentMoveAddressToVpcOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentModifyVpnTunnelOptionsOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -45639,7 +46276,7 @@ func (m *awsEc2query_deserializeOpMoveAddressToVpc) HandleDeserialize(ctx contex return out, metadata, err } -func awsEc2query_deserializeOpErrorMoveAddressToVpc(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorModifyVpnTunnelOptions(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -45672,14 +46309,14 @@ func awsEc2query_deserializeOpErrorMoveAddressToVpc(response *smithyhttp.Respons } } -type awsEc2query_deserializeOpMoveByoipCidrToIpam struct { +type awsEc2query_deserializeOpMonitorInstances struct { } -func (*awsEc2query_deserializeOpMoveByoipCidrToIpam) ID() string { +func (*awsEc2query_deserializeOpMonitorInstances) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpMoveByoipCidrToIpam) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpMonitorInstances) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -45693,9 +46330,9 @@ func (m *awsEc2query_deserializeOpMoveByoipCidrToIpam) HandleDeserialize(ctx con } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorMoveByoipCidrToIpam(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorMonitorInstances(response, &metadata) } - output := &MoveByoipCidrToIpamOutput{} + output := &MonitorInstancesOutput{} out.Result = output var buff [1024]byte @@ -45716,7 +46353,7 @@ func (m *awsEc2query_deserializeOpMoveByoipCidrToIpam) HandleDeserialize(ctx con } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentMoveByoipCidrToIpamOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentMonitorInstancesOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -45730,7 +46367,7 @@ func (m *awsEc2query_deserializeOpMoveByoipCidrToIpam) HandleDeserialize(ctx con return out, metadata, err } -func awsEc2query_deserializeOpErrorMoveByoipCidrToIpam(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorMonitorInstances(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -45763,14 +46400,14 @@ func awsEc2query_deserializeOpErrorMoveByoipCidrToIpam(response *smithyhttp.Resp } } -type awsEc2query_deserializeOpProvisionByoipCidr struct { +type awsEc2query_deserializeOpMoveAddressToVpc struct { } -func (*awsEc2query_deserializeOpProvisionByoipCidr) ID() string { +func (*awsEc2query_deserializeOpMoveAddressToVpc) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpProvisionByoipCidr) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpMoveAddressToVpc) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -45784,9 +46421,9 @@ func (m *awsEc2query_deserializeOpProvisionByoipCidr) HandleDeserialize(ctx cont } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorProvisionByoipCidr(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorMoveAddressToVpc(response, &metadata) } - output := &ProvisionByoipCidrOutput{} + output := &MoveAddressToVpcOutput{} out.Result = output var buff [1024]byte @@ -45807,7 +46444,7 @@ func (m *awsEc2query_deserializeOpProvisionByoipCidr) HandleDeserialize(ctx cont } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentProvisionByoipCidrOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentMoveAddressToVpcOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -45821,7 +46458,7 @@ func (m *awsEc2query_deserializeOpProvisionByoipCidr) HandleDeserialize(ctx cont return out, metadata, err } -func awsEc2query_deserializeOpErrorProvisionByoipCidr(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorMoveAddressToVpc(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -45854,14 +46491,14 @@ func awsEc2query_deserializeOpErrorProvisionByoipCidr(response *smithyhttp.Respo } } -type awsEc2query_deserializeOpProvisionIpamPoolCidr struct { +type awsEc2query_deserializeOpMoveByoipCidrToIpam struct { } -func (*awsEc2query_deserializeOpProvisionIpamPoolCidr) ID() string { +func (*awsEc2query_deserializeOpMoveByoipCidrToIpam) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpProvisionIpamPoolCidr) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpMoveByoipCidrToIpam) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -45875,9 +46512,9 @@ func (m *awsEc2query_deserializeOpProvisionIpamPoolCidr) HandleDeserialize(ctx c } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorProvisionIpamPoolCidr(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorMoveByoipCidrToIpam(response, &metadata) } - output := &ProvisionIpamPoolCidrOutput{} + output := &MoveByoipCidrToIpamOutput{} out.Result = output var buff [1024]byte @@ -45898,7 +46535,7 @@ func (m *awsEc2query_deserializeOpProvisionIpamPoolCidr) HandleDeserialize(ctx c } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentProvisionIpamPoolCidrOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentMoveByoipCidrToIpamOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -45912,7 +46549,7 @@ func (m *awsEc2query_deserializeOpProvisionIpamPoolCidr) HandleDeserialize(ctx c return out, metadata, err } -func awsEc2query_deserializeOpErrorProvisionIpamPoolCidr(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorMoveByoipCidrToIpam(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -45945,14 +46582,14 @@ func awsEc2query_deserializeOpErrorProvisionIpamPoolCidr(response *smithyhttp.Re } } -type awsEc2query_deserializeOpProvisionPublicIpv4PoolCidr struct { +type awsEc2query_deserializeOpProvisionByoipCidr struct { } -func (*awsEc2query_deserializeOpProvisionPublicIpv4PoolCidr) ID() string { +func (*awsEc2query_deserializeOpProvisionByoipCidr) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpProvisionPublicIpv4PoolCidr) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpProvisionByoipCidr) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -45966,9 +46603,9 @@ func (m *awsEc2query_deserializeOpProvisionPublicIpv4PoolCidr) HandleDeserialize } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorProvisionPublicIpv4PoolCidr(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorProvisionByoipCidr(response, &metadata) } - output := &ProvisionPublicIpv4PoolCidrOutput{} + output := &ProvisionByoipCidrOutput{} out.Result = output var buff [1024]byte @@ -45989,7 +46626,7 @@ func (m *awsEc2query_deserializeOpProvisionPublicIpv4PoolCidr) HandleDeserialize } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentProvisionPublicIpv4PoolCidrOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentProvisionByoipCidrOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -46003,7 +46640,7 @@ func (m *awsEc2query_deserializeOpProvisionPublicIpv4PoolCidr) HandleDeserialize return out, metadata, err } -func awsEc2query_deserializeOpErrorProvisionPublicIpv4PoolCidr(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorProvisionByoipCidr(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -46036,14 +46673,14 @@ func awsEc2query_deserializeOpErrorProvisionPublicIpv4PoolCidr(response *smithyh } } -type awsEc2query_deserializeOpPurchaseHostReservation struct { +type awsEc2query_deserializeOpProvisionIpamPoolCidr struct { } -func (*awsEc2query_deserializeOpPurchaseHostReservation) ID() string { +func (*awsEc2query_deserializeOpProvisionIpamPoolCidr) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpPurchaseHostReservation) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpProvisionIpamPoolCidr) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -46057,9 +46694,9 @@ func (m *awsEc2query_deserializeOpPurchaseHostReservation) HandleDeserialize(ctx } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorPurchaseHostReservation(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorProvisionIpamPoolCidr(response, &metadata) } - output := &PurchaseHostReservationOutput{} + output := &ProvisionIpamPoolCidrOutput{} out.Result = output var buff [1024]byte @@ -46080,7 +46717,7 @@ func (m *awsEc2query_deserializeOpPurchaseHostReservation) HandleDeserialize(ctx } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentPurchaseHostReservationOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentProvisionIpamPoolCidrOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -46094,7 +46731,7 @@ func (m *awsEc2query_deserializeOpPurchaseHostReservation) HandleDeserialize(ctx return out, metadata, err } -func awsEc2query_deserializeOpErrorPurchaseHostReservation(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorProvisionIpamPoolCidr(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -46127,14 +46764,14 @@ func awsEc2query_deserializeOpErrorPurchaseHostReservation(response *smithyhttp. } } -type awsEc2query_deserializeOpPurchaseReservedInstancesOffering struct { +type awsEc2query_deserializeOpProvisionPublicIpv4PoolCidr struct { } -func (*awsEc2query_deserializeOpPurchaseReservedInstancesOffering) ID() string { +func (*awsEc2query_deserializeOpProvisionPublicIpv4PoolCidr) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpPurchaseReservedInstancesOffering) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpProvisionPublicIpv4PoolCidr) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -46148,9 +46785,9 @@ func (m *awsEc2query_deserializeOpPurchaseReservedInstancesOffering) HandleDeser } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorPurchaseReservedInstancesOffering(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorProvisionPublicIpv4PoolCidr(response, &metadata) } - output := &PurchaseReservedInstancesOfferingOutput{} + output := &ProvisionPublicIpv4PoolCidrOutput{} out.Result = output var buff [1024]byte @@ -46171,7 +46808,7 @@ func (m *awsEc2query_deserializeOpPurchaseReservedInstancesOffering) HandleDeser } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentPurchaseReservedInstancesOfferingOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentProvisionPublicIpv4PoolCidrOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -46185,7 +46822,7 @@ func (m *awsEc2query_deserializeOpPurchaseReservedInstancesOffering) HandleDeser return out, metadata, err } -func awsEc2query_deserializeOpErrorPurchaseReservedInstancesOffering(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorProvisionPublicIpv4PoolCidr(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -46218,14 +46855,14 @@ func awsEc2query_deserializeOpErrorPurchaseReservedInstancesOffering(response *s } } -type awsEc2query_deserializeOpPurchaseScheduledInstances struct { +type awsEc2query_deserializeOpPurchaseHostReservation struct { } -func (*awsEc2query_deserializeOpPurchaseScheduledInstances) ID() string { +func (*awsEc2query_deserializeOpPurchaseHostReservation) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpPurchaseScheduledInstances) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpPurchaseHostReservation) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -46239,9 +46876,9 @@ func (m *awsEc2query_deserializeOpPurchaseScheduledInstances) HandleDeserialize( } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorPurchaseScheduledInstances(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorPurchaseHostReservation(response, &metadata) } - output := &PurchaseScheduledInstancesOutput{} + output := &PurchaseHostReservationOutput{} out.Result = output var buff [1024]byte @@ -46262,7 +46899,7 @@ func (m *awsEc2query_deserializeOpPurchaseScheduledInstances) HandleDeserialize( } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentPurchaseScheduledInstancesOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentPurchaseHostReservationOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -46276,7 +46913,7 @@ func (m *awsEc2query_deserializeOpPurchaseScheduledInstances) HandleDeserialize( return out, metadata, err } -func awsEc2query_deserializeOpErrorPurchaseScheduledInstances(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorPurchaseHostReservation(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -46309,14 +46946,14 @@ func awsEc2query_deserializeOpErrorPurchaseScheduledInstances(response *smithyht } } -type awsEc2query_deserializeOpRebootInstances struct { +type awsEc2query_deserializeOpPurchaseReservedInstancesOffering struct { } -func (*awsEc2query_deserializeOpRebootInstances) ID() string { +func (*awsEc2query_deserializeOpPurchaseReservedInstancesOffering) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpRebootInstances) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpPurchaseReservedInstancesOffering) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -46330,21 +46967,44 @@ func (m *awsEc2query_deserializeOpRebootInstances) HandleDeserialize(ctx context } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorRebootInstances(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorPurchaseReservedInstancesOffering(response, &metadata) } - output := &RebootInstancesOutput{} + output := &PurchaseReservedInstancesOfferingOutput{} out.Result = output - if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + body := io.TeeReader(response.Body, ringBuffer) + rootDecoder := xml.NewDecoder(body) + t, err := smithyxml.FetchRootElement(rootDecoder) + if err == io.EOF { + return out, metadata, nil + } + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) return out, metadata, &smithy.DeserializationError{ - Err: fmt.Errorf("failed to discard response body, %w", err), + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), } } + decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) + err = awsEc2query_deserializeOpDocumentPurchaseReservedInstancesOfferingOutput(&output, decoder) + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return out, metadata, err + } + return out, metadata, err } -func awsEc2query_deserializeOpErrorRebootInstances(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorPurchaseReservedInstancesOffering(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -46377,14 +47037,14 @@ func awsEc2query_deserializeOpErrorRebootInstances(response *smithyhttp.Response } } -type awsEc2query_deserializeOpRegisterImage struct { +type awsEc2query_deserializeOpPurchaseScheduledInstances struct { } -func (*awsEc2query_deserializeOpRegisterImage) ID() string { +func (*awsEc2query_deserializeOpPurchaseScheduledInstances) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpRegisterImage) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpPurchaseScheduledInstances) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -46398,9 +47058,9 @@ func (m *awsEc2query_deserializeOpRegisterImage) HandleDeserialize(ctx context.C } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorRegisterImage(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorPurchaseScheduledInstances(response, &metadata) } - output := &RegisterImageOutput{} + output := &PurchaseScheduledInstancesOutput{} out.Result = output var buff [1024]byte @@ -46421,7 +47081,7 @@ func (m *awsEc2query_deserializeOpRegisterImage) HandleDeserialize(ctx context.C } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentRegisterImageOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentPurchaseScheduledInstancesOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -46435,7 +47095,7 @@ func (m *awsEc2query_deserializeOpRegisterImage) HandleDeserialize(ctx context.C return out, metadata, err } -func awsEc2query_deserializeOpErrorRegisterImage(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorPurchaseScheduledInstances(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -46468,14 +47128,14 @@ func awsEc2query_deserializeOpErrorRegisterImage(response *smithyhttp.Response, } } -type awsEc2query_deserializeOpRegisterInstanceEventNotificationAttributes struct { +type awsEc2query_deserializeOpRebootInstances struct { } -func (*awsEc2query_deserializeOpRegisterInstanceEventNotificationAttributes) ID() string { +func (*awsEc2query_deserializeOpRebootInstances) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpRegisterInstanceEventNotificationAttributes) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpRebootInstances) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -46489,44 +47149,21 @@ func (m *awsEc2query_deserializeOpRegisterInstanceEventNotificationAttributes) H } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorRegisterInstanceEventNotificationAttributes(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorRebootInstances(response, &metadata) } - output := &RegisterInstanceEventNotificationAttributesOutput{} + output := &RebootInstancesOutput{} out.Result = output - var buff [1024]byte - ringBuffer := smithyio.NewRingBuffer(buff[:]) - body := io.TeeReader(response.Body, ringBuffer) - rootDecoder := xml.NewDecoder(body) - t, err := smithyxml.FetchRootElement(rootDecoder) - if err == io.EOF { - return out, metadata, nil - } - if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) + if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { return out, metadata, &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - } - - decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentRegisterInstanceEventNotificationAttributesOutput(&output, decoder) - if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), + Err: fmt.Errorf("failed to discard response body, %w", err), } - return out, metadata, err } return out, metadata, err } -func awsEc2query_deserializeOpErrorRegisterInstanceEventNotificationAttributes(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorRebootInstances(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -46559,14 +47196,14 @@ func awsEc2query_deserializeOpErrorRegisterInstanceEventNotificationAttributes(r } } -type awsEc2query_deserializeOpRegisterTransitGatewayMulticastGroupMembers struct { +type awsEc2query_deserializeOpRegisterImage struct { } -func (*awsEc2query_deserializeOpRegisterTransitGatewayMulticastGroupMembers) ID() string { +func (*awsEc2query_deserializeOpRegisterImage) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpRegisterTransitGatewayMulticastGroupMembers) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpRegisterImage) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -46580,9 +47217,9 @@ func (m *awsEc2query_deserializeOpRegisterTransitGatewayMulticastGroupMembers) H } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorRegisterTransitGatewayMulticastGroupMembers(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorRegisterImage(response, &metadata) } - output := &RegisterTransitGatewayMulticastGroupMembersOutput{} + output := &RegisterImageOutput{} out.Result = output var buff [1024]byte @@ -46603,7 +47240,7 @@ func (m *awsEc2query_deserializeOpRegisterTransitGatewayMulticastGroupMembers) H } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentRegisterTransitGatewayMulticastGroupMembersOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentRegisterImageOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -46617,7 +47254,7 @@ func (m *awsEc2query_deserializeOpRegisterTransitGatewayMulticastGroupMembers) H return out, metadata, err } -func awsEc2query_deserializeOpErrorRegisterTransitGatewayMulticastGroupMembers(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorRegisterImage(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -46650,14 +47287,14 @@ func awsEc2query_deserializeOpErrorRegisterTransitGatewayMulticastGroupMembers(r } } -type awsEc2query_deserializeOpRegisterTransitGatewayMulticastGroupSources struct { +type awsEc2query_deserializeOpRegisterInstanceEventNotificationAttributes struct { } -func (*awsEc2query_deserializeOpRegisterTransitGatewayMulticastGroupSources) ID() string { +func (*awsEc2query_deserializeOpRegisterInstanceEventNotificationAttributes) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpRegisterTransitGatewayMulticastGroupSources) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpRegisterInstanceEventNotificationAttributes) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -46671,9 +47308,9 @@ func (m *awsEc2query_deserializeOpRegisterTransitGatewayMulticastGroupSources) H } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorRegisterTransitGatewayMulticastGroupSources(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorRegisterInstanceEventNotificationAttributes(response, &metadata) } - output := &RegisterTransitGatewayMulticastGroupSourcesOutput{} + output := &RegisterInstanceEventNotificationAttributesOutput{} out.Result = output var buff [1024]byte @@ -46694,7 +47331,7 @@ func (m *awsEc2query_deserializeOpRegisterTransitGatewayMulticastGroupSources) H } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentRegisterTransitGatewayMulticastGroupSourcesOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentRegisterInstanceEventNotificationAttributesOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -46708,7 +47345,7 @@ func (m *awsEc2query_deserializeOpRegisterTransitGatewayMulticastGroupSources) H return out, metadata, err } -func awsEc2query_deserializeOpErrorRegisterTransitGatewayMulticastGroupSources(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorRegisterInstanceEventNotificationAttributes(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -46741,14 +47378,14 @@ func awsEc2query_deserializeOpErrorRegisterTransitGatewayMulticastGroupSources(r } } -type awsEc2query_deserializeOpRejectTransitGatewayMulticastDomainAssociations struct { +type awsEc2query_deserializeOpRegisterTransitGatewayMulticastGroupMembers struct { } -func (*awsEc2query_deserializeOpRejectTransitGatewayMulticastDomainAssociations) ID() string { +func (*awsEc2query_deserializeOpRegisterTransitGatewayMulticastGroupMembers) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpRejectTransitGatewayMulticastDomainAssociations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpRegisterTransitGatewayMulticastGroupMembers) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -46762,9 +47399,9 @@ func (m *awsEc2query_deserializeOpRejectTransitGatewayMulticastDomainAssociation } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorRejectTransitGatewayMulticastDomainAssociations(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorRegisterTransitGatewayMulticastGroupMembers(response, &metadata) } - output := &RejectTransitGatewayMulticastDomainAssociationsOutput{} + output := &RegisterTransitGatewayMulticastGroupMembersOutput{} out.Result = output var buff [1024]byte @@ -46785,7 +47422,7 @@ func (m *awsEc2query_deserializeOpRejectTransitGatewayMulticastDomainAssociation } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentRejectTransitGatewayMulticastDomainAssociationsOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentRegisterTransitGatewayMulticastGroupMembersOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -46799,7 +47436,7 @@ func (m *awsEc2query_deserializeOpRejectTransitGatewayMulticastDomainAssociation return out, metadata, err } -func awsEc2query_deserializeOpErrorRejectTransitGatewayMulticastDomainAssociations(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorRegisterTransitGatewayMulticastGroupMembers(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -46832,14 +47469,14 @@ func awsEc2query_deserializeOpErrorRejectTransitGatewayMulticastDomainAssociatio } } -type awsEc2query_deserializeOpRejectTransitGatewayPeeringAttachment struct { +type awsEc2query_deserializeOpRegisterTransitGatewayMulticastGroupSources struct { } -func (*awsEc2query_deserializeOpRejectTransitGatewayPeeringAttachment) ID() string { +func (*awsEc2query_deserializeOpRegisterTransitGatewayMulticastGroupSources) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpRejectTransitGatewayPeeringAttachment) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpRegisterTransitGatewayMulticastGroupSources) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -46853,9 +47490,9 @@ func (m *awsEc2query_deserializeOpRejectTransitGatewayPeeringAttachment) HandleD } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorRejectTransitGatewayPeeringAttachment(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorRegisterTransitGatewayMulticastGroupSources(response, &metadata) } - output := &RejectTransitGatewayPeeringAttachmentOutput{} + output := &RegisterTransitGatewayMulticastGroupSourcesOutput{} out.Result = output var buff [1024]byte @@ -46876,7 +47513,7 @@ func (m *awsEc2query_deserializeOpRejectTransitGatewayPeeringAttachment) HandleD } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentRejectTransitGatewayPeeringAttachmentOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentRegisterTransitGatewayMulticastGroupSourcesOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -46890,7 +47527,7 @@ func (m *awsEc2query_deserializeOpRejectTransitGatewayPeeringAttachment) HandleD return out, metadata, err } -func awsEc2query_deserializeOpErrorRejectTransitGatewayPeeringAttachment(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorRegisterTransitGatewayMulticastGroupSources(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -46923,14 +47560,14 @@ func awsEc2query_deserializeOpErrorRejectTransitGatewayPeeringAttachment(respons } } -type awsEc2query_deserializeOpRejectTransitGatewayVpcAttachment struct { +type awsEc2query_deserializeOpRejectTransitGatewayMulticastDomainAssociations struct { } -func (*awsEc2query_deserializeOpRejectTransitGatewayVpcAttachment) ID() string { +func (*awsEc2query_deserializeOpRejectTransitGatewayMulticastDomainAssociations) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpRejectTransitGatewayVpcAttachment) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpRejectTransitGatewayMulticastDomainAssociations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -46944,9 +47581,9 @@ func (m *awsEc2query_deserializeOpRejectTransitGatewayVpcAttachment) HandleDeser } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorRejectTransitGatewayVpcAttachment(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorRejectTransitGatewayMulticastDomainAssociations(response, &metadata) } - output := &RejectTransitGatewayVpcAttachmentOutput{} + output := &RejectTransitGatewayMulticastDomainAssociationsOutput{} out.Result = output var buff [1024]byte @@ -46967,7 +47604,7 @@ func (m *awsEc2query_deserializeOpRejectTransitGatewayVpcAttachment) HandleDeser } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentRejectTransitGatewayVpcAttachmentOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentRejectTransitGatewayMulticastDomainAssociationsOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -46981,7 +47618,7 @@ func (m *awsEc2query_deserializeOpRejectTransitGatewayVpcAttachment) HandleDeser return out, metadata, err } -func awsEc2query_deserializeOpErrorRejectTransitGatewayVpcAttachment(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorRejectTransitGatewayMulticastDomainAssociations(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -47014,14 +47651,14 @@ func awsEc2query_deserializeOpErrorRejectTransitGatewayVpcAttachment(response *s } } -type awsEc2query_deserializeOpRejectVpcEndpointConnections struct { +type awsEc2query_deserializeOpRejectTransitGatewayPeeringAttachment struct { } -func (*awsEc2query_deserializeOpRejectVpcEndpointConnections) ID() string { +func (*awsEc2query_deserializeOpRejectTransitGatewayPeeringAttachment) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpRejectVpcEndpointConnections) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpRejectTransitGatewayPeeringAttachment) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -47035,9 +47672,9 @@ func (m *awsEc2query_deserializeOpRejectVpcEndpointConnections) HandleDeserializ } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorRejectVpcEndpointConnections(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorRejectTransitGatewayPeeringAttachment(response, &metadata) } - output := &RejectVpcEndpointConnectionsOutput{} + output := &RejectTransitGatewayPeeringAttachmentOutput{} out.Result = output var buff [1024]byte @@ -47058,7 +47695,7 @@ func (m *awsEc2query_deserializeOpRejectVpcEndpointConnections) HandleDeserializ } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentRejectVpcEndpointConnectionsOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentRejectTransitGatewayPeeringAttachmentOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -47072,7 +47709,7 @@ func (m *awsEc2query_deserializeOpRejectVpcEndpointConnections) HandleDeserializ return out, metadata, err } -func awsEc2query_deserializeOpErrorRejectVpcEndpointConnections(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorRejectTransitGatewayPeeringAttachment(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -47105,14 +47742,14 @@ func awsEc2query_deserializeOpErrorRejectVpcEndpointConnections(response *smithy } } -type awsEc2query_deserializeOpRejectVpcPeeringConnection struct { +type awsEc2query_deserializeOpRejectTransitGatewayVpcAttachment struct { } -func (*awsEc2query_deserializeOpRejectVpcPeeringConnection) ID() string { +func (*awsEc2query_deserializeOpRejectTransitGatewayVpcAttachment) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpRejectVpcPeeringConnection) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpRejectTransitGatewayVpcAttachment) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -47126,9 +47763,9 @@ func (m *awsEc2query_deserializeOpRejectVpcPeeringConnection) HandleDeserialize( } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorRejectVpcPeeringConnection(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorRejectTransitGatewayVpcAttachment(response, &metadata) } - output := &RejectVpcPeeringConnectionOutput{} + output := &RejectTransitGatewayVpcAttachmentOutput{} out.Result = output var buff [1024]byte @@ -47149,7 +47786,7 @@ func (m *awsEc2query_deserializeOpRejectVpcPeeringConnection) HandleDeserialize( } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentRejectVpcPeeringConnectionOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentRejectTransitGatewayVpcAttachmentOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -47163,7 +47800,7 @@ func (m *awsEc2query_deserializeOpRejectVpcPeeringConnection) HandleDeserialize( return out, metadata, err } -func awsEc2query_deserializeOpErrorRejectVpcPeeringConnection(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorRejectTransitGatewayVpcAttachment(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -47196,14 +47833,14 @@ func awsEc2query_deserializeOpErrorRejectVpcPeeringConnection(response *smithyht } } -type awsEc2query_deserializeOpReleaseAddress struct { +type awsEc2query_deserializeOpRejectVpcEndpointConnections struct { } -func (*awsEc2query_deserializeOpReleaseAddress) ID() string { +func (*awsEc2query_deserializeOpRejectVpcEndpointConnections) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpReleaseAddress) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpRejectVpcEndpointConnections) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -47217,21 +47854,44 @@ func (m *awsEc2query_deserializeOpReleaseAddress) HandleDeserialize(ctx context. } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorReleaseAddress(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorRejectVpcEndpointConnections(response, &metadata) } - output := &ReleaseAddressOutput{} + output := &RejectVpcEndpointConnectionsOutput{} out.Result = output - if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + body := io.TeeReader(response.Body, ringBuffer) + rootDecoder := xml.NewDecoder(body) + t, err := smithyxml.FetchRootElement(rootDecoder) + if err == io.EOF { + return out, metadata, nil + } + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) return out, metadata, &smithy.DeserializationError{ - Err: fmt.Errorf("failed to discard response body, %w", err), + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), } } + decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) + err = awsEc2query_deserializeOpDocumentRejectVpcEndpointConnectionsOutput(&output, decoder) + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return out, metadata, err + } + return out, metadata, err } -func awsEc2query_deserializeOpErrorReleaseAddress(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorRejectVpcEndpointConnections(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -47264,14 +47924,14 @@ func awsEc2query_deserializeOpErrorReleaseAddress(response *smithyhttp.Response, } } -type awsEc2query_deserializeOpReleaseHosts struct { +type awsEc2query_deserializeOpRejectVpcPeeringConnection struct { } -func (*awsEc2query_deserializeOpReleaseHosts) ID() string { +func (*awsEc2query_deserializeOpRejectVpcPeeringConnection) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpReleaseHosts) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpRejectVpcPeeringConnection) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -47285,9 +47945,9 @@ func (m *awsEc2query_deserializeOpReleaseHosts) HandleDeserialize(ctx context.Co } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorReleaseHosts(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorRejectVpcPeeringConnection(response, &metadata) } - output := &ReleaseHostsOutput{} + output := &RejectVpcPeeringConnectionOutput{} out.Result = output var buff [1024]byte @@ -47308,7 +47968,7 @@ func (m *awsEc2query_deserializeOpReleaseHosts) HandleDeserialize(ctx context.Co } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentReleaseHostsOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentRejectVpcPeeringConnectionOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -47322,7 +47982,7 @@ func (m *awsEc2query_deserializeOpReleaseHosts) HandleDeserialize(ctx context.Co return out, metadata, err } -func awsEc2query_deserializeOpErrorReleaseHosts(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorRejectVpcPeeringConnection(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -47355,14 +48015,14 @@ func awsEc2query_deserializeOpErrorReleaseHosts(response *smithyhttp.Response, m } } -type awsEc2query_deserializeOpReleaseIpamPoolAllocation struct { +type awsEc2query_deserializeOpReleaseAddress struct { } -func (*awsEc2query_deserializeOpReleaseIpamPoolAllocation) ID() string { +func (*awsEc2query_deserializeOpReleaseAddress) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpReleaseIpamPoolAllocation) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpReleaseAddress) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -47376,44 +48036,21 @@ func (m *awsEc2query_deserializeOpReleaseIpamPoolAllocation) HandleDeserialize(c } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorReleaseIpamPoolAllocation(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorReleaseAddress(response, &metadata) } - output := &ReleaseIpamPoolAllocationOutput{} + output := &ReleaseAddressOutput{} out.Result = output - var buff [1024]byte - ringBuffer := smithyio.NewRingBuffer(buff[:]) - body := io.TeeReader(response.Body, ringBuffer) - rootDecoder := xml.NewDecoder(body) - t, err := smithyxml.FetchRootElement(rootDecoder) - if err == io.EOF { - return out, metadata, nil - } - if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) + if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { return out, metadata, &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - } - - decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentReleaseIpamPoolAllocationOutput(&output, decoder) - if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), + Err: fmt.Errorf("failed to discard response body, %w", err), } - return out, metadata, err } return out, metadata, err } -func awsEc2query_deserializeOpErrorReleaseIpamPoolAllocation(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorReleaseAddress(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -47446,14 +48083,14 @@ func awsEc2query_deserializeOpErrorReleaseIpamPoolAllocation(response *smithyhtt } } -type awsEc2query_deserializeOpReplaceIamInstanceProfileAssociation struct { +type awsEc2query_deserializeOpReleaseHosts struct { } -func (*awsEc2query_deserializeOpReplaceIamInstanceProfileAssociation) ID() string { +func (*awsEc2query_deserializeOpReleaseHosts) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpReplaceIamInstanceProfileAssociation) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpReleaseHosts) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -47467,9 +48104,9 @@ func (m *awsEc2query_deserializeOpReplaceIamInstanceProfileAssociation) HandleDe } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorReplaceIamInstanceProfileAssociation(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorReleaseHosts(response, &metadata) } - output := &ReplaceIamInstanceProfileAssociationOutput{} + output := &ReleaseHostsOutput{} out.Result = output var buff [1024]byte @@ -47490,7 +48127,7 @@ func (m *awsEc2query_deserializeOpReplaceIamInstanceProfileAssociation) HandleDe } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentReplaceIamInstanceProfileAssociationOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentReleaseHostsOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -47504,7 +48141,7 @@ func (m *awsEc2query_deserializeOpReplaceIamInstanceProfileAssociation) HandleDe return out, metadata, err } -func awsEc2query_deserializeOpErrorReplaceIamInstanceProfileAssociation(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorReleaseHosts(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -47537,14 +48174,14 @@ func awsEc2query_deserializeOpErrorReplaceIamInstanceProfileAssociation(response } } -type awsEc2query_deserializeOpReplaceNetworkAclAssociation struct { +type awsEc2query_deserializeOpReleaseIpamPoolAllocation struct { } -func (*awsEc2query_deserializeOpReplaceNetworkAclAssociation) ID() string { +func (*awsEc2query_deserializeOpReleaseIpamPoolAllocation) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpReplaceNetworkAclAssociation) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpReleaseIpamPoolAllocation) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -47558,9 +48195,9 @@ func (m *awsEc2query_deserializeOpReplaceNetworkAclAssociation) HandleDeserializ } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorReplaceNetworkAclAssociation(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorReleaseIpamPoolAllocation(response, &metadata) } - output := &ReplaceNetworkAclAssociationOutput{} + output := &ReleaseIpamPoolAllocationOutput{} out.Result = output var buff [1024]byte @@ -47581,7 +48218,7 @@ func (m *awsEc2query_deserializeOpReplaceNetworkAclAssociation) HandleDeserializ } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentReplaceNetworkAclAssociationOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentReleaseIpamPoolAllocationOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -47595,7 +48232,7 @@ func (m *awsEc2query_deserializeOpReplaceNetworkAclAssociation) HandleDeserializ return out, metadata, err } -func awsEc2query_deserializeOpErrorReplaceNetworkAclAssociation(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorReleaseIpamPoolAllocation(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -47628,14 +48265,14 @@ func awsEc2query_deserializeOpErrorReplaceNetworkAclAssociation(response *smithy } } -type awsEc2query_deserializeOpReplaceNetworkAclEntry struct { +type awsEc2query_deserializeOpReplaceIamInstanceProfileAssociation struct { } -func (*awsEc2query_deserializeOpReplaceNetworkAclEntry) ID() string { +func (*awsEc2query_deserializeOpReplaceIamInstanceProfileAssociation) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpReplaceNetworkAclEntry) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpReplaceIamInstanceProfileAssociation) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -47649,89 +48286,44 @@ func (m *awsEc2query_deserializeOpReplaceNetworkAclEntry) HandleDeserialize(ctx } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorReplaceNetworkAclEntry(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorReplaceIamInstanceProfileAssociation(response, &metadata) } - output := &ReplaceNetworkAclEntryOutput{} + output := &ReplaceIamInstanceProfileAssociationOutput{} out.Result = output - if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { - return out, metadata, &smithy.DeserializationError{ - Err: fmt.Errorf("failed to discard response body, %w", err), - } - } - - return out, metadata, err -} - -func awsEc2query_deserializeOpErrorReplaceNetworkAclEntry(response *smithyhttp.Response, metadata *middleware.Metadata) error { - var errorBuffer bytes.Buffer - if _, err := io.Copy(&errorBuffer, response.Body); err != nil { - return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + body := io.TeeReader(response.Body, ringBuffer) + rootDecoder := xml.NewDecoder(body) + t, err := smithyxml.FetchRootElement(rootDecoder) + if err == io.EOF { + return out, metadata, nil } - errorBody := bytes.NewReader(errorBuffer.Bytes()) - - errorCode := "UnknownError" - errorMessage := errorCode - - errorComponents, err := ec2query.GetErrorResponseComponents(errorBody) if err != nil { - return err - } - awsmiddleware.SetRequestIDMetadata(metadata, errorComponents.RequestID) - if len(errorComponents.Code) != 0 { - errorCode = errorComponents.Code - } - if len(errorComponents.Message) != 0 { - errorMessage = errorComponents.Message - } - errorBody.Seek(0, io.SeekStart) - switch { - default: - genericError := &smithy.GenericAPIError{ - Code: errorCode, - Message: errorMessage, + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + return out, metadata, &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), } - return genericError - } -} - -type awsEc2query_deserializeOpReplaceRoute struct { -} - -func (*awsEc2query_deserializeOpReplaceRoute) ID() string { - return "OperationDeserializer" -} -func (m *awsEc2query_deserializeOpReplaceRoute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( - out middleware.DeserializeOutput, metadata middleware.Metadata, err error, -) { - out, metadata, err = next.HandleDeserialize(ctx, in) + decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) + err = awsEc2query_deserializeOpDocumentReplaceIamInstanceProfileAssociationOutput(&output, decoder) 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, awsEc2query_deserializeOpErrorReplaceRoute(response, &metadata) - } - output := &ReplaceRouteOutput{} - out.Result = output - - if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { - return out, metadata, &smithy.DeserializationError{ - Err: fmt.Errorf("failed to discard response body, %w", err), + var 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 awsEc2query_deserializeOpErrorReplaceRoute(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorReplaceIamInstanceProfileAssociation(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -47764,14 +48356,14 @@ func awsEc2query_deserializeOpErrorReplaceRoute(response *smithyhttp.Response, m } } -type awsEc2query_deserializeOpReplaceRouteTableAssociation struct { +type awsEc2query_deserializeOpReplaceNetworkAclAssociation struct { } -func (*awsEc2query_deserializeOpReplaceRouteTableAssociation) ID() string { +func (*awsEc2query_deserializeOpReplaceNetworkAclAssociation) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpReplaceRouteTableAssociation) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpReplaceNetworkAclAssociation) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -47785,9 +48377,9 @@ func (m *awsEc2query_deserializeOpReplaceRouteTableAssociation) HandleDeserializ } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorReplaceRouteTableAssociation(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorReplaceNetworkAclAssociation(response, &metadata) } - output := &ReplaceRouteTableAssociationOutput{} + output := &ReplaceNetworkAclAssociationOutput{} out.Result = output var buff [1024]byte @@ -47808,7 +48400,7 @@ func (m *awsEc2query_deserializeOpReplaceRouteTableAssociation) HandleDeserializ } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentReplaceRouteTableAssociationOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentReplaceNetworkAclAssociationOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -47822,7 +48414,7 @@ func (m *awsEc2query_deserializeOpReplaceRouteTableAssociation) HandleDeserializ return out, metadata, err } -func awsEc2query_deserializeOpErrorReplaceRouteTableAssociation(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorReplaceNetworkAclAssociation(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -47855,14 +48447,14 @@ func awsEc2query_deserializeOpErrorReplaceRouteTableAssociation(response *smithy } } -type awsEc2query_deserializeOpReplaceTransitGatewayRoute struct { +type awsEc2query_deserializeOpReplaceNetworkAclEntry struct { } -func (*awsEc2query_deserializeOpReplaceTransitGatewayRoute) ID() string { +func (*awsEc2query_deserializeOpReplaceNetworkAclEntry) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpReplaceTransitGatewayRoute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpReplaceNetworkAclEntry) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -47876,44 +48468,21 @@ func (m *awsEc2query_deserializeOpReplaceTransitGatewayRoute) HandleDeserialize( } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorReplaceTransitGatewayRoute(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorReplaceNetworkAclEntry(response, &metadata) } - output := &ReplaceTransitGatewayRouteOutput{} + output := &ReplaceNetworkAclEntryOutput{} out.Result = output - var buff [1024]byte - ringBuffer := smithyio.NewRingBuffer(buff[:]) - body := io.TeeReader(response.Body, ringBuffer) - rootDecoder := xml.NewDecoder(body) - t, err := smithyxml.FetchRootElement(rootDecoder) - if err == io.EOF { - return out, metadata, nil - } - if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) + if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { return out, metadata, &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - } - - decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentReplaceTransitGatewayRouteOutput(&output, decoder) - if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), + Err: fmt.Errorf("failed to discard response body, %w", err), } - return out, metadata, err } return out, metadata, err } -func awsEc2query_deserializeOpErrorReplaceTransitGatewayRoute(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorReplaceNetworkAclEntry(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -47946,14 +48515,14 @@ func awsEc2query_deserializeOpErrorReplaceTransitGatewayRoute(response *smithyht } } -type awsEc2query_deserializeOpReportInstanceStatus struct { +type awsEc2query_deserializeOpReplaceRoute struct { } -func (*awsEc2query_deserializeOpReportInstanceStatus) ID() string { +func (*awsEc2query_deserializeOpReplaceRoute) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpReportInstanceStatus) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpReplaceRoute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -47967,9 +48536,9 @@ func (m *awsEc2query_deserializeOpReportInstanceStatus) HandleDeserialize(ctx co } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorReportInstanceStatus(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorReplaceRoute(response, &metadata) } - output := &ReportInstanceStatusOutput{} + output := &ReplaceRouteOutput{} out.Result = output if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { @@ -47981,7 +48550,7 @@ func (m *awsEc2query_deserializeOpReportInstanceStatus) HandleDeserialize(ctx co return out, metadata, err } -func awsEc2query_deserializeOpErrorReportInstanceStatus(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorReplaceRoute(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -48014,14 +48583,14 @@ func awsEc2query_deserializeOpErrorReportInstanceStatus(response *smithyhttp.Res } } -type awsEc2query_deserializeOpRequestSpotFleet struct { +type awsEc2query_deserializeOpReplaceRouteTableAssociation struct { } -func (*awsEc2query_deserializeOpRequestSpotFleet) ID() string { +func (*awsEc2query_deserializeOpReplaceRouteTableAssociation) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpRequestSpotFleet) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpReplaceRouteTableAssociation) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -48035,9 +48604,9 @@ func (m *awsEc2query_deserializeOpRequestSpotFleet) HandleDeserialize(ctx contex } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorRequestSpotFleet(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorReplaceRouteTableAssociation(response, &metadata) } - output := &RequestSpotFleetOutput{} + output := &ReplaceRouteTableAssociationOutput{} out.Result = output var buff [1024]byte @@ -48058,7 +48627,7 @@ func (m *awsEc2query_deserializeOpRequestSpotFleet) HandleDeserialize(ctx contex } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentRequestSpotFleetOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentReplaceRouteTableAssociationOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -48072,7 +48641,7 @@ func (m *awsEc2query_deserializeOpRequestSpotFleet) HandleDeserialize(ctx contex return out, metadata, err } -func awsEc2query_deserializeOpErrorRequestSpotFleet(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorReplaceRouteTableAssociation(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -48105,14 +48674,14 @@ func awsEc2query_deserializeOpErrorRequestSpotFleet(response *smithyhttp.Respons } } -type awsEc2query_deserializeOpRequestSpotInstances struct { +type awsEc2query_deserializeOpReplaceTransitGatewayRoute struct { } -func (*awsEc2query_deserializeOpRequestSpotInstances) ID() string { +func (*awsEc2query_deserializeOpReplaceTransitGatewayRoute) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpRequestSpotInstances) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpReplaceTransitGatewayRoute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -48126,9 +48695,9 @@ func (m *awsEc2query_deserializeOpRequestSpotInstances) HandleDeserialize(ctx co } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorRequestSpotInstances(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorReplaceTransitGatewayRoute(response, &metadata) } - output := &RequestSpotInstancesOutput{} + output := &ReplaceTransitGatewayRouteOutput{} out.Result = output var buff [1024]byte @@ -48149,7 +48718,7 @@ func (m *awsEc2query_deserializeOpRequestSpotInstances) HandleDeserialize(ctx co } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentRequestSpotInstancesOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentReplaceTransitGatewayRouteOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -48163,7 +48732,7 @@ func (m *awsEc2query_deserializeOpRequestSpotInstances) HandleDeserialize(ctx co return out, metadata, err } -func awsEc2query_deserializeOpErrorRequestSpotInstances(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorReplaceTransitGatewayRoute(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -48196,14 +48765,14 @@ func awsEc2query_deserializeOpErrorRequestSpotInstances(response *smithyhttp.Res } } -type awsEc2query_deserializeOpResetAddressAttribute struct { +type awsEc2query_deserializeOpReportInstanceStatus struct { } -func (*awsEc2query_deserializeOpResetAddressAttribute) ID() string { +func (*awsEc2query_deserializeOpReportInstanceStatus) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpResetAddressAttribute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpReportInstanceStatus) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -48217,44 +48786,21 @@ func (m *awsEc2query_deserializeOpResetAddressAttribute) HandleDeserialize(ctx c } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorResetAddressAttribute(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorReportInstanceStatus(response, &metadata) } - output := &ResetAddressAttributeOutput{} + output := &ReportInstanceStatusOutput{} out.Result = output - var buff [1024]byte - ringBuffer := smithyio.NewRingBuffer(buff[:]) - body := io.TeeReader(response.Body, ringBuffer) - rootDecoder := xml.NewDecoder(body) - t, err := smithyxml.FetchRootElement(rootDecoder) - if err == io.EOF { - return out, metadata, nil - } - if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) + if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { return out, metadata, &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), + Err: fmt.Errorf("failed to discard response body, %w", err), } } - decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentResetAddressAttributeOutput(&output, decoder) - if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - return out, metadata, err - } - return out, metadata, err } -func awsEc2query_deserializeOpErrorResetAddressAttribute(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorReportInstanceStatus(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -48287,14 +48833,14 @@ func awsEc2query_deserializeOpErrorResetAddressAttribute(response *smithyhttp.Re } } -type awsEc2query_deserializeOpResetEbsDefaultKmsKeyId struct { +type awsEc2query_deserializeOpRequestSpotFleet struct { } -func (*awsEc2query_deserializeOpResetEbsDefaultKmsKeyId) ID() string { +func (*awsEc2query_deserializeOpRequestSpotFleet) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpResetEbsDefaultKmsKeyId) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpRequestSpotFleet) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -48308,9 +48854,9 @@ func (m *awsEc2query_deserializeOpResetEbsDefaultKmsKeyId) HandleDeserialize(ctx } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorResetEbsDefaultKmsKeyId(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorRequestSpotFleet(response, &metadata) } - output := &ResetEbsDefaultKmsKeyIdOutput{} + output := &RequestSpotFleetOutput{} out.Result = output var buff [1024]byte @@ -48331,7 +48877,7 @@ func (m *awsEc2query_deserializeOpResetEbsDefaultKmsKeyId) HandleDeserialize(ctx } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentResetEbsDefaultKmsKeyIdOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentRequestSpotFleetOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -48345,7 +48891,7 @@ func (m *awsEc2query_deserializeOpResetEbsDefaultKmsKeyId) HandleDeserialize(ctx return out, metadata, err } -func awsEc2query_deserializeOpErrorResetEbsDefaultKmsKeyId(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorRequestSpotFleet(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -48378,14 +48924,14 @@ func awsEc2query_deserializeOpErrorResetEbsDefaultKmsKeyId(response *smithyhttp. } } -type awsEc2query_deserializeOpResetFpgaImageAttribute struct { +type awsEc2query_deserializeOpRequestSpotInstances struct { } -func (*awsEc2query_deserializeOpResetFpgaImageAttribute) ID() string { +func (*awsEc2query_deserializeOpRequestSpotInstances) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpResetFpgaImageAttribute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpRequestSpotInstances) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -48399,9 +48945,9 @@ func (m *awsEc2query_deserializeOpResetFpgaImageAttribute) HandleDeserialize(ctx } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorResetFpgaImageAttribute(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorRequestSpotInstances(response, &metadata) } - output := &ResetFpgaImageAttributeOutput{} + output := &RequestSpotInstancesOutput{} out.Result = output var buff [1024]byte @@ -48422,7 +48968,7 @@ func (m *awsEc2query_deserializeOpResetFpgaImageAttribute) HandleDeserialize(ctx } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentResetFpgaImageAttributeOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentRequestSpotInstancesOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -48436,7 +48982,7 @@ func (m *awsEc2query_deserializeOpResetFpgaImageAttribute) HandleDeserialize(ctx return out, metadata, err } -func awsEc2query_deserializeOpErrorResetFpgaImageAttribute(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorRequestSpotInstances(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -48469,14 +49015,14 @@ func awsEc2query_deserializeOpErrorResetFpgaImageAttribute(response *smithyhttp. } } -type awsEc2query_deserializeOpResetImageAttribute struct { +type awsEc2query_deserializeOpResetAddressAttribute struct { } -func (*awsEc2query_deserializeOpResetImageAttribute) ID() string { +func (*awsEc2query_deserializeOpResetAddressAttribute) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpResetImageAttribute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpResetAddressAttribute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -48490,89 +49036,44 @@ func (m *awsEc2query_deserializeOpResetImageAttribute) HandleDeserialize(ctx con } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorResetImageAttribute(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorResetAddressAttribute(response, &metadata) } - output := &ResetImageAttributeOutput{} + output := &ResetAddressAttributeOutput{} out.Result = output - if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { - return out, metadata, &smithy.DeserializationError{ - Err: fmt.Errorf("failed to discard response body, %w", err), - } - } - - return out, metadata, err -} - -func awsEc2query_deserializeOpErrorResetImageAttribute(response *smithyhttp.Response, metadata *middleware.Metadata) error { - var errorBuffer bytes.Buffer - if _, err := io.Copy(&errorBuffer, response.Body); err != nil { - return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + body := io.TeeReader(response.Body, ringBuffer) + rootDecoder := xml.NewDecoder(body) + t, err := smithyxml.FetchRootElement(rootDecoder) + if err == io.EOF { + return out, metadata, nil } - errorBody := bytes.NewReader(errorBuffer.Bytes()) - - errorCode := "UnknownError" - errorMessage := errorCode - - errorComponents, err := ec2query.GetErrorResponseComponents(errorBody) if err != nil { - return err - } - awsmiddleware.SetRequestIDMetadata(metadata, errorComponents.RequestID) - if len(errorComponents.Code) != 0 { - errorCode = errorComponents.Code - } - if len(errorComponents.Message) != 0 { - errorMessage = errorComponents.Message - } - errorBody.Seek(0, io.SeekStart) - switch { - default: - genericError := &smithy.GenericAPIError{ - Code: errorCode, - Message: errorMessage, + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + return out, metadata, &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), } - return genericError - } -} - -type awsEc2query_deserializeOpResetInstanceAttribute struct { -} - -func (*awsEc2query_deserializeOpResetInstanceAttribute) ID() string { - return "OperationDeserializer" -} -func (m *awsEc2query_deserializeOpResetInstanceAttribute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( - out middleware.DeserializeOutput, metadata middleware.Metadata, err error, -) { - out, metadata, err = next.HandleDeserialize(ctx, in) + decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) + err = awsEc2query_deserializeOpDocumentResetAddressAttributeOutput(&output, decoder) 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, awsEc2query_deserializeOpErrorResetInstanceAttribute(response, &metadata) - } - output := &ResetInstanceAttributeOutput{} - out.Result = output - - if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { - return out, metadata, &smithy.DeserializationError{ - Err: fmt.Errorf("failed to discard response body, %w", err), + var 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 awsEc2query_deserializeOpErrorResetInstanceAttribute(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorResetAddressAttribute(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -48605,14 +49106,14 @@ func awsEc2query_deserializeOpErrorResetInstanceAttribute(response *smithyhttp.R } } -type awsEc2query_deserializeOpResetNetworkInterfaceAttribute struct { +type awsEc2query_deserializeOpResetEbsDefaultKmsKeyId struct { } -func (*awsEc2query_deserializeOpResetNetworkInterfaceAttribute) ID() string { +func (*awsEc2query_deserializeOpResetEbsDefaultKmsKeyId) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpResetNetworkInterfaceAttribute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpResetEbsDefaultKmsKeyId) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -48626,21 +49127,44 @@ func (m *awsEc2query_deserializeOpResetNetworkInterfaceAttribute) HandleDeserial } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorResetNetworkInterfaceAttribute(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorResetEbsDefaultKmsKeyId(response, &metadata) } - output := &ResetNetworkInterfaceAttributeOutput{} + output := &ResetEbsDefaultKmsKeyIdOutput{} out.Result = output - if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + body := io.TeeReader(response.Body, ringBuffer) + rootDecoder := xml.NewDecoder(body) + t, err := smithyxml.FetchRootElement(rootDecoder) + if err == io.EOF { + return out, metadata, nil + } + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) return out, metadata, &smithy.DeserializationError{ - Err: fmt.Errorf("failed to discard response body, %w", err), + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + } + + decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) + err = awsEc2query_deserializeOpDocumentResetEbsDefaultKmsKeyIdOutput(&output, decoder) + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), } + return out, metadata, err } return out, metadata, err } -func awsEc2query_deserializeOpErrorResetNetworkInterfaceAttribute(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorResetEbsDefaultKmsKeyId(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -48673,14 +49197,14 @@ func awsEc2query_deserializeOpErrorResetNetworkInterfaceAttribute(response *smit } } -type awsEc2query_deserializeOpResetSnapshotAttribute struct { +type awsEc2query_deserializeOpResetFpgaImageAttribute struct { } -func (*awsEc2query_deserializeOpResetSnapshotAttribute) ID() string { +func (*awsEc2query_deserializeOpResetFpgaImageAttribute) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpResetSnapshotAttribute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpResetFpgaImageAttribute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -48694,21 +49218,44 @@ func (m *awsEc2query_deserializeOpResetSnapshotAttribute) HandleDeserialize(ctx } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorResetSnapshotAttribute(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorResetFpgaImageAttribute(response, &metadata) } - output := &ResetSnapshotAttributeOutput{} + output := &ResetFpgaImageAttributeOutput{} out.Result = output - if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + body := io.TeeReader(response.Body, ringBuffer) + rootDecoder := xml.NewDecoder(body) + t, err := smithyxml.FetchRootElement(rootDecoder) + if err == io.EOF { + return out, metadata, nil + } + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) return out, metadata, &smithy.DeserializationError{ - Err: fmt.Errorf("failed to discard response body, %w", err), + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), } } + decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) + err = awsEc2query_deserializeOpDocumentResetFpgaImageAttributeOutput(&output, decoder) + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return out, metadata, err + } + return out, metadata, err } -func awsEc2query_deserializeOpErrorResetSnapshotAttribute(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorResetFpgaImageAttribute(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -48741,14 +49288,14 @@ func awsEc2query_deserializeOpErrorResetSnapshotAttribute(response *smithyhttp.R } } -type awsEc2query_deserializeOpRestoreAddressToClassic struct { +type awsEc2query_deserializeOpResetImageAttribute struct { } -func (*awsEc2query_deserializeOpRestoreAddressToClassic) ID() string { +func (*awsEc2query_deserializeOpResetImageAttribute) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpRestoreAddressToClassic) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpResetImageAttribute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -48762,44 +49309,21 @@ func (m *awsEc2query_deserializeOpRestoreAddressToClassic) HandleDeserialize(ctx } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorRestoreAddressToClassic(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorResetImageAttribute(response, &metadata) } - output := &RestoreAddressToClassicOutput{} + output := &ResetImageAttributeOutput{} out.Result = output - var buff [1024]byte - ringBuffer := smithyio.NewRingBuffer(buff[:]) - body := io.TeeReader(response.Body, ringBuffer) - rootDecoder := xml.NewDecoder(body) - t, err := smithyxml.FetchRootElement(rootDecoder) - if err == io.EOF { - return out, metadata, nil - } - if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) + if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { return out, metadata, &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - } - - decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentRestoreAddressToClassicOutput(&output, decoder) - if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), + Err: fmt.Errorf("failed to discard response body, %w", err), } - return out, metadata, err } return out, metadata, err } -func awsEc2query_deserializeOpErrorRestoreAddressToClassic(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorResetImageAttribute(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -48832,14 +49356,14 @@ func awsEc2query_deserializeOpErrorRestoreAddressToClassic(response *smithyhttp. } } -type awsEc2query_deserializeOpRestoreImageFromRecycleBin struct { +type awsEc2query_deserializeOpResetInstanceAttribute struct { } -func (*awsEc2query_deserializeOpRestoreImageFromRecycleBin) ID() string { +func (*awsEc2query_deserializeOpResetInstanceAttribute) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpRestoreImageFromRecycleBin) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpResetInstanceAttribute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -48853,44 +49377,21 @@ func (m *awsEc2query_deserializeOpRestoreImageFromRecycleBin) HandleDeserialize( } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorRestoreImageFromRecycleBin(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorResetInstanceAttribute(response, &metadata) } - output := &RestoreImageFromRecycleBinOutput{} + output := &ResetInstanceAttributeOutput{} out.Result = output - var buff [1024]byte - ringBuffer := smithyio.NewRingBuffer(buff[:]) - body := io.TeeReader(response.Body, ringBuffer) - rootDecoder := xml.NewDecoder(body) - t, err := smithyxml.FetchRootElement(rootDecoder) - if err == io.EOF { - return out, metadata, nil - } - if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) + if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { return out, metadata, &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - } - - decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentRestoreImageFromRecycleBinOutput(&output, decoder) - if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), + Err: fmt.Errorf("failed to discard response body, %w", err), } - return out, metadata, err } return out, metadata, err } -func awsEc2query_deserializeOpErrorRestoreImageFromRecycleBin(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorResetInstanceAttribute(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -48923,14 +49424,14 @@ func awsEc2query_deserializeOpErrorRestoreImageFromRecycleBin(response *smithyht } } -type awsEc2query_deserializeOpRestoreManagedPrefixListVersion struct { +type awsEc2query_deserializeOpResetNetworkInterfaceAttribute struct { } -func (*awsEc2query_deserializeOpRestoreManagedPrefixListVersion) ID() string { +func (*awsEc2query_deserializeOpResetNetworkInterfaceAttribute) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpRestoreManagedPrefixListVersion) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpResetNetworkInterfaceAttribute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -48944,44 +49445,21 @@ func (m *awsEc2query_deserializeOpRestoreManagedPrefixListVersion) HandleDeseria } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorRestoreManagedPrefixListVersion(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorResetNetworkInterfaceAttribute(response, &metadata) } - output := &RestoreManagedPrefixListVersionOutput{} + output := &ResetNetworkInterfaceAttributeOutput{} out.Result = output - var buff [1024]byte - ringBuffer := smithyio.NewRingBuffer(buff[:]) - body := io.TeeReader(response.Body, ringBuffer) - rootDecoder := xml.NewDecoder(body) - t, err := smithyxml.FetchRootElement(rootDecoder) - if err == io.EOF { - return out, metadata, nil - } - if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) + if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { return out, metadata, &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - } - - decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentRestoreManagedPrefixListVersionOutput(&output, decoder) - if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), + Err: fmt.Errorf("failed to discard response body, %w", err), } - return out, metadata, err } return out, metadata, err } -func awsEc2query_deserializeOpErrorRestoreManagedPrefixListVersion(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorResetNetworkInterfaceAttribute(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -49014,14 +49492,14 @@ func awsEc2query_deserializeOpErrorRestoreManagedPrefixListVersion(response *smi } } -type awsEc2query_deserializeOpRestoreSnapshotFromRecycleBin struct { +type awsEc2query_deserializeOpResetSnapshotAttribute struct { } -func (*awsEc2query_deserializeOpRestoreSnapshotFromRecycleBin) ID() string { +func (*awsEc2query_deserializeOpResetSnapshotAttribute) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpRestoreSnapshotFromRecycleBin) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpResetSnapshotAttribute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -49035,44 +49513,21 @@ func (m *awsEc2query_deserializeOpRestoreSnapshotFromRecycleBin) HandleDeseriali } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorRestoreSnapshotFromRecycleBin(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorResetSnapshotAttribute(response, &metadata) } - output := &RestoreSnapshotFromRecycleBinOutput{} + output := &ResetSnapshotAttributeOutput{} out.Result = output - var buff [1024]byte - ringBuffer := smithyio.NewRingBuffer(buff[:]) - body := io.TeeReader(response.Body, ringBuffer) - rootDecoder := xml.NewDecoder(body) - t, err := smithyxml.FetchRootElement(rootDecoder) - if err == io.EOF { - return out, metadata, nil - } - if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) + if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { return out, metadata, &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - } - - decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentRestoreSnapshotFromRecycleBinOutput(&output, decoder) - if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), + Err: fmt.Errorf("failed to discard response body, %w", err), } - return out, metadata, err } return out, metadata, err } -func awsEc2query_deserializeOpErrorRestoreSnapshotFromRecycleBin(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorResetSnapshotAttribute(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -49105,14 +49560,14 @@ func awsEc2query_deserializeOpErrorRestoreSnapshotFromRecycleBin(response *smith } } -type awsEc2query_deserializeOpRestoreSnapshotTier struct { +type awsEc2query_deserializeOpRestoreAddressToClassic struct { } -func (*awsEc2query_deserializeOpRestoreSnapshotTier) ID() string { +func (*awsEc2query_deserializeOpRestoreAddressToClassic) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpRestoreSnapshotTier) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpRestoreAddressToClassic) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -49126,9 +49581,9 @@ func (m *awsEc2query_deserializeOpRestoreSnapshotTier) HandleDeserialize(ctx con } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorRestoreSnapshotTier(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorRestoreAddressToClassic(response, &metadata) } - output := &RestoreSnapshotTierOutput{} + output := &RestoreAddressToClassicOutput{} out.Result = output var buff [1024]byte @@ -49149,7 +49604,7 @@ func (m *awsEc2query_deserializeOpRestoreSnapshotTier) HandleDeserialize(ctx con } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentRestoreSnapshotTierOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentRestoreAddressToClassicOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -49163,7 +49618,7 @@ func (m *awsEc2query_deserializeOpRestoreSnapshotTier) HandleDeserialize(ctx con return out, metadata, err } -func awsEc2query_deserializeOpErrorRestoreSnapshotTier(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorRestoreAddressToClassic(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -49196,14 +49651,14 @@ func awsEc2query_deserializeOpErrorRestoreSnapshotTier(response *smithyhttp.Resp } } -type awsEc2query_deserializeOpRevokeClientVpnIngress struct { +type awsEc2query_deserializeOpRestoreImageFromRecycleBin struct { } -func (*awsEc2query_deserializeOpRevokeClientVpnIngress) ID() string { +func (*awsEc2query_deserializeOpRestoreImageFromRecycleBin) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpRevokeClientVpnIngress) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpRestoreImageFromRecycleBin) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -49217,9 +49672,9 @@ func (m *awsEc2query_deserializeOpRevokeClientVpnIngress) HandleDeserialize(ctx } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorRevokeClientVpnIngress(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorRestoreImageFromRecycleBin(response, &metadata) } - output := &RevokeClientVpnIngressOutput{} + output := &RestoreImageFromRecycleBinOutput{} out.Result = output var buff [1024]byte @@ -49240,7 +49695,7 @@ func (m *awsEc2query_deserializeOpRevokeClientVpnIngress) HandleDeserialize(ctx } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentRevokeClientVpnIngressOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentRestoreImageFromRecycleBinOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -49254,7 +49709,7 @@ func (m *awsEc2query_deserializeOpRevokeClientVpnIngress) HandleDeserialize(ctx return out, metadata, err } -func awsEc2query_deserializeOpErrorRevokeClientVpnIngress(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorRestoreImageFromRecycleBin(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -49287,14 +49742,14 @@ func awsEc2query_deserializeOpErrorRevokeClientVpnIngress(response *smithyhttp.R } } -type awsEc2query_deserializeOpRevokeSecurityGroupEgress struct { +type awsEc2query_deserializeOpRestoreManagedPrefixListVersion struct { } -func (*awsEc2query_deserializeOpRevokeSecurityGroupEgress) ID() string { +func (*awsEc2query_deserializeOpRestoreManagedPrefixListVersion) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpRevokeSecurityGroupEgress) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpRestoreManagedPrefixListVersion) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -49308,9 +49763,9 @@ func (m *awsEc2query_deserializeOpRevokeSecurityGroupEgress) HandleDeserialize(c } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorRevokeSecurityGroupEgress(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorRestoreManagedPrefixListVersion(response, &metadata) } - output := &RevokeSecurityGroupEgressOutput{} + output := &RestoreManagedPrefixListVersionOutput{} out.Result = output var buff [1024]byte @@ -49331,7 +49786,7 @@ func (m *awsEc2query_deserializeOpRevokeSecurityGroupEgress) HandleDeserialize(c } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentRevokeSecurityGroupEgressOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentRestoreManagedPrefixListVersionOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -49345,7 +49800,7 @@ func (m *awsEc2query_deserializeOpRevokeSecurityGroupEgress) HandleDeserialize(c return out, metadata, err } -func awsEc2query_deserializeOpErrorRevokeSecurityGroupEgress(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorRestoreManagedPrefixListVersion(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -49378,14 +49833,14 @@ func awsEc2query_deserializeOpErrorRevokeSecurityGroupEgress(response *smithyhtt } } -type awsEc2query_deserializeOpRevokeSecurityGroupIngress struct { +type awsEc2query_deserializeOpRestoreSnapshotFromRecycleBin struct { } -func (*awsEc2query_deserializeOpRevokeSecurityGroupIngress) ID() string { +func (*awsEc2query_deserializeOpRestoreSnapshotFromRecycleBin) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpRevokeSecurityGroupIngress) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpRestoreSnapshotFromRecycleBin) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -49399,9 +49854,9 @@ func (m *awsEc2query_deserializeOpRevokeSecurityGroupIngress) HandleDeserialize( } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorRevokeSecurityGroupIngress(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorRestoreSnapshotFromRecycleBin(response, &metadata) } - output := &RevokeSecurityGroupIngressOutput{} + output := &RestoreSnapshotFromRecycleBinOutput{} out.Result = output var buff [1024]byte @@ -49422,7 +49877,7 @@ func (m *awsEc2query_deserializeOpRevokeSecurityGroupIngress) HandleDeserialize( } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentRevokeSecurityGroupIngressOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentRestoreSnapshotFromRecycleBinOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -49436,7 +49891,7 @@ func (m *awsEc2query_deserializeOpRevokeSecurityGroupIngress) HandleDeserialize( return out, metadata, err } -func awsEc2query_deserializeOpErrorRevokeSecurityGroupIngress(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorRestoreSnapshotFromRecycleBin(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -49469,14 +49924,14 @@ func awsEc2query_deserializeOpErrorRevokeSecurityGroupIngress(response *smithyht } } -type awsEc2query_deserializeOpRunInstances struct { +type awsEc2query_deserializeOpRestoreSnapshotTier struct { } -func (*awsEc2query_deserializeOpRunInstances) ID() string { +func (*awsEc2query_deserializeOpRestoreSnapshotTier) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpRunInstances) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpRestoreSnapshotTier) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -49490,9 +49945,9 @@ func (m *awsEc2query_deserializeOpRunInstances) HandleDeserialize(ctx context.Co } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorRunInstances(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorRestoreSnapshotTier(response, &metadata) } - output := &RunInstancesOutput{} + output := &RestoreSnapshotTierOutput{} out.Result = output var buff [1024]byte @@ -49513,7 +49968,7 @@ func (m *awsEc2query_deserializeOpRunInstances) HandleDeserialize(ctx context.Co } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentRunInstancesOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentRestoreSnapshotTierOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -49527,7 +49982,7 @@ func (m *awsEc2query_deserializeOpRunInstances) HandleDeserialize(ctx context.Co return out, metadata, err } -func awsEc2query_deserializeOpErrorRunInstances(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorRestoreSnapshotTier(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -49560,14 +50015,14 @@ func awsEc2query_deserializeOpErrorRunInstances(response *smithyhttp.Response, m } } -type awsEc2query_deserializeOpRunScheduledInstances struct { +type awsEc2query_deserializeOpRevokeClientVpnIngress struct { } -func (*awsEc2query_deserializeOpRunScheduledInstances) ID() string { +func (*awsEc2query_deserializeOpRevokeClientVpnIngress) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpRunScheduledInstances) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpRevokeClientVpnIngress) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -49581,9 +50036,9 @@ func (m *awsEc2query_deserializeOpRunScheduledInstances) HandleDeserialize(ctx c } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorRunScheduledInstances(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorRevokeClientVpnIngress(response, &metadata) } - output := &RunScheduledInstancesOutput{} + output := &RevokeClientVpnIngressOutput{} out.Result = output var buff [1024]byte @@ -49604,7 +50059,7 @@ func (m *awsEc2query_deserializeOpRunScheduledInstances) HandleDeserialize(ctx c } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentRunScheduledInstancesOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentRevokeClientVpnIngressOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -49618,7 +50073,7 @@ func (m *awsEc2query_deserializeOpRunScheduledInstances) HandleDeserialize(ctx c return out, metadata, err } -func awsEc2query_deserializeOpErrorRunScheduledInstances(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorRevokeClientVpnIngress(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -49651,14 +50106,14 @@ func awsEc2query_deserializeOpErrorRunScheduledInstances(response *smithyhttp.Re } } -type awsEc2query_deserializeOpSearchLocalGatewayRoutes struct { +type awsEc2query_deserializeOpRevokeSecurityGroupEgress struct { } -func (*awsEc2query_deserializeOpSearchLocalGatewayRoutes) ID() string { +func (*awsEc2query_deserializeOpRevokeSecurityGroupEgress) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpSearchLocalGatewayRoutes) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpRevokeSecurityGroupEgress) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -49672,9 +50127,9 @@ func (m *awsEc2query_deserializeOpSearchLocalGatewayRoutes) HandleDeserialize(ct } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorSearchLocalGatewayRoutes(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorRevokeSecurityGroupEgress(response, &metadata) } - output := &SearchLocalGatewayRoutesOutput{} + output := &RevokeSecurityGroupEgressOutput{} out.Result = output var buff [1024]byte @@ -49695,7 +50150,7 @@ func (m *awsEc2query_deserializeOpSearchLocalGatewayRoutes) HandleDeserialize(ct } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentSearchLocalGatewayRoutesOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentRevokeSecurityGroupEgressOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -49709,7 +50164,7 @@ func (m *awsEc2query_deserializeOpSearchLocalGatewayRoutes) HandleDeserialize(ct return out, metadata, err } -func awsEc2query_deserializeOpErrorSearchLocalGatewayRoutes(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorRevokeSecurityGroupEgress(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -49742,14 +50197,14 @@ func awsEc2query_deserializeOpErrorSearchLocalGatewayRoutes(response *smithyhttp } } -type awsEc2query_deserializeOpSearchTransitGatewayMulticastGroups struct { +type awsEc2query_deserializeOpRevokeSecurityGroupIngress struct { } -func (*awsEc2query_deserializeOpSearchTransitGatewayMulticastGroups) ID() string { +func (*awsEc2query_deserializeOpRevokeSecurityGroupIngress) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpSearchTransitGatewayMulticastGroups) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpRevokeSecurityGroupIngress) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -49763,9 +50218,9 @@ func (m *awsEc2query_deserializeOpSearchTransitGatewayMulticastGroups) HandleDes } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorSearchTransitGatewayMulticastGroups(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorRevokeSecurityGroupIngress(response, &metadata) } - output := &SearchTransitGatewayMulticastGroupsOutput{} + output := &RevokeSecurityGroupIngressOutput{} out.Result = output var buff [1024]byte @@ -49786,7 +50241,7 @@ func (m *awsEc2query_deserializeOpSearchTransitGatewayMulticastGroups) HandleDes } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentSearchTransitGatewayMulticastGroupsOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentRevokeSecurityGroupIngressOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -49800,7 +50255,7 @@ func (m *awsEc2query_deserializeOpSearchTransitGatewayMulticastGroups) HandleDes return out, metadata, err } -func awsEc2query_deserializeOpErrorSearchTransitGatewayMulticastGroups(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorRevokeSecurityGroupIngress(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -49833,14 +50288,14 @@ func awsEc2query_deserializeOpErrorSearchTransitGatewayMulticastGroups(response } } -type awsEc2query_deserializeOpSearchTransitGatewayRoutes struct { +type awsEc2query_deserializeOpRunInstances struct { } -func (*awsEc2query_deserializeOpSearchTransitGatewayRoutes) ID() string { +func (*awsEc2query_deserializeOpRunInstances) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpSearchTransitGatewayRoutes) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpRunInstances) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -49854,9 +50309,9 @@ func (m *awsEc2query_deserializeOpSearchTransitGatewayRoutes) HandleDeserialize( } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorSearchTransitGatewayRoutes(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorRunInstances(response, &metadata) } - output := &SearchTransitGatewayRoutesOutput{} + output := &RunInstancesOutput{} out.Result = output var buff [1024]byte @@ -49877,7 +50332,7 @@ func (m *awsEc2query_deserializeOpSearchTransitGatewayRoutes) HandleDeserialize( } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentSearchTransitGatewayRoutesOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentRunInstancesOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -49891,7 +50346,7 @@ func (m *awsEc2query_deserializeOpSearchTransitGatewayRoutes) HandleDeserialize( return out, metadata, err } -func awsEc2query_deserializeOpErrorSearchTransitGatewayRoutes(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorRunInstances(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -49924,14 +50379,14 @@ func awsEc2query_deserializeOpErrorSearchTransitGatewayRoutes(response *smithyht } } -type awsEc2query_deserializeOpSendDiagnosticInterrupt struct { +type awsEc2query_deserializeOpRunScheduledInstances struct { } -func (*awsEc2query_deserializeOpSendDiagnosticInterrupt) ID() string { +func (*awsEc2query_deserializeOpRunScheduledInstances) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpSendDiagnosticInterrupt) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpRunScheduledInstances) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -49945,21 +50400,44 @@ func (m *awsEc2query_deserializeOpSendDiagnosticInterrupt) HandleDeserialize(ctx } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorSendDiagnosticInterrupt(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorRunScheduledInstances(response, &metadata) } - output := &SendDiagnosticInterruptOutput{} + output := &RunScheduledInstancesOutput{} out.Result = output - if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + body := io.TeeReader(response.Body, ringBuffer) + rootDecoder := xml.NewDecoder(body) + t, err := smithyxml.FetchRootElement(rootDecoder) + if err == io.EOF { + return out, metadata, nil + } + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) return out, metadata, &smithy.DeserializationError{ - Err: fmt.Errorf("failed to discard response body, %w", err), + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + } + + decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) + err = awsEc2query_deserializeOpDocumentRunScheduledInstancesOutput(&output, decoder) + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), } + return out, metadata, err } return out, metadata, err } -func awsEc2query_deserializeOpErrorSendDiagnosticInterrupt(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorRunScheduledInstances(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -49992,14 +50470,14 @@ func awsEc2query_deserializeOpErrorSendDiagnosticInterrupt(response *smithyhttp. } } -type awsEc2query_deserializeOpStartInstances struct { +type awsEc2query_deserializeOpSearchLocalGatewayRoutes struct { } -func (*awsEc2query_deserializeOpStartInstances) ID() string { +func (*awsEc2query_deserializeOpSearchLocalGatewayRoutes) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpStartInstances) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpSearchLocalGatewayRoutes) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -50013,9 +50491,9 @@ func (m *awsEc2query_deserializeOpStartInstances) HandleDeserialize(ctx context. } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorStartInstances(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorSearchLocalGatewayRoutes(response, &metadata) } - output := &StartInstancesOutput{} + output := &SearchLocalGatewayRoutesOutput{} out.Result = output var buff [1024]byte @@ -50036,7 +50514,7 @@ func (m *awsEc2query_deserializeOpStartInstances) HandleDeserialize(ctx context. } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentStartInstancesOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentSearchLocalGatewayRoutesOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -50050,7 +50528,7 @@ func (m *awsEc2query_deserializeOpStartInstances) HandleDeserialize(ctx context. return out, metadata, err } -func awsEc2query_deserializeOpErrorStartInstances(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorSearchLocalGatewayRoutes(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -50083,14 +50561,14 @@ func awsEc2query_deserializeOpErrorStartInstances(response *smithyhttp.Response, } } -type awsEc2query_deserializeOpStartNetworkInsightsAccessScopeAnalysis struct { +type awsEc2query_deserializeOpSearchTransitGatewayMulticastGroups struct { } -func (*awsEc2query_deserializeOpStartNetworkInsightsAccessScopeAnalysis) ID() string { +func (*awsEc2query_deserializeOpSearchTransitGatewayMulticastGroups) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpStartNetworkInsightsAccessScopeAnalysis) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpSearchTransitGatewayMulticastGroups) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -50104,9 +50582,9 @@ func (m *awsEc2query_deserializeOpStartNetworkInsightsAccessScopeAnalysis) Handl } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorStartNetworkInsightsAccessScopeAnalysis(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorSearchTransitGatewayMulticastGroups(response, &metadata) } - output := &StartNetworkInsightsAccessScopeAnalysisOutput{} + output := &SearchTransitGatewayMulticastGroupsOutput{} out.Result = output var buff [1024]byte @@ -50127,7 +50605,7 @@ func (m *awsEc2query_deserializeOpStartNetworkInsightsAccessScopeAnalysis) Handl } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentStartNetworkInsightsAccessScopeAnalysisOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentSearchTransitGatewayMulticastGroupsOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -50141,7 +50619,7 @@ func (m *awsEc2query_deserializeOpStartNetworkInsightsAccessScopeAnalysis) Handl return out, metadata, err } -func awsEc2query_deserializeOpErrorStartNetworkInsightsAccessScopeAnalysis(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorSearchTransitGatewayMulticastGroups(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -50174,14 +50652,14 @@ func awsEc2query_deserializeOpErrorStartNetworkInsightsAccessScopeAnalysis(respo } } -type awsEc2query_deserializeOpStartNetworkInsightsAnalysis struct { +type awsEc2query_deserializeOpSearchTransitGatewayRoutes struct { } -func (*awsEc2query_deserializeOpStartNetworkInsightsAnalysis) ID() string { +func (*awsEc2query_deserializeOpSearchTransitGatewayRoutes) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpStartNetworkInsightsAnalysis) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpSearchTransitGatewayRoutes) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -50195,9 +50673,9 @@ func (m *awsEc2query_deserializeOpStartNetworkInsightsAnalysis) HandleDeserializ } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorStartNetworkInsightsAnalysis(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorSearchTransitGatewayRoutes(response, &metadata) } - output := &StartNetworkInsightsAnalysisOutput{} + output := &SearchTransitGatewayRoutesOutput{} out.Result = output var buff [1024]byte @@ -50218,7 +50696,7 @@ func (m *awsEc2query_deserializeOpStartNetworkInsightsAnalysis) HandleDeserializ } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentStartNetworkInsightsAnalysisOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentSearchTransitGatewayRoutesOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -50232,7 +50710,7 @@ func (m *awsEc2query_deserializeOpStartNetworkInsightsAnalysis) HandleDeserializ return out, metadata, err } -func awsEc2query_deserializeOpErrorStartNetworkInsightsAnalysis(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorSearchTransitGatewayRoutes(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -50265,14 +50743,14 @@ func awsEc2query_deserializeOpErrorStartNetworkInsightsAnalysis(response *smithy } } -type awsEc2query_deserializeOpStartVpcEndpointServicePrivateDnsVerification struct { +type awsEc2query_deserializeOpSendDiagnosticInterrupt struct { } -func (*awsEc2query_deserializeOpStartVpcEndpointServicePrivateDnsVerification) ID() string { +func (*awsEc2query_deserializeOpSendDiagnosticInterrupt) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpStartVpcEndpointServicePrivateDnsVerification) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpSendDiagnosticInterrupt) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -50286,44 +50764,21 @@ func (m *awsEc2query_deserializeOpStartVpcEndpointServicePrivateDnsVerification) } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorStartVpcEndpointServicePrivateDnsVerification(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorSendDiagnosticInterrupt(response, &metadata) } - output := &StartVpcEndpointServicePrivateDnsVerificationOutput{} + output := &SendDiagnosticInterruptOutput{} out.Result = output - var buff [1024]byte - ringBuffer := smithyio.NewRingBuffer(buff[:]) - body := io.TeeReader(response.Body, ringBuffer) - rootDecoder := xml.NewDecoder(body) - t, err := smithyxml.FetchRootElement(rootDecoder) - if err == io.EOF { - return out, metadata, nil - } - if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) + if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { return out, metadata, &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - } - - decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentStartVpcEndpointServicePrivateDnsVerificationOutput(&output, decoder) - if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), + Err: fmt.Errorf("failed to discard response body, %w", err), } - return out, metadata, err } return out, metadata, err } -func awsEc2query_deserializeOpErrorStartVpcEndpointServicePrivateDnsVerification(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorSendDiagnosticInterrupt(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -50356,14 +50811,14 @@ func awsEc2query_deserializeOpErrorStartVpcEndpointServicePrivateDnsVerification } } -type awsEc2query_deserializeOpStopInstances struct { +type awsEc2query_deserializeOpStartInstances struct { } -func (*awsEc2query_deserializeOpStopInstances) ID() string { +func (*awsEc2query_deserializeOpStartInstances) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpStopInstances) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpStartInstances) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -50377,9 +50832,9 @@ func (m *awsEc2query_deserializeOpStopInstances) HandleDeserialize(ctx context.C } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorStopInstances(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorStartInstances(response, &metadata) } - output := &StopInstancesOutput{} + output := &StartInstancesOutput{} out.Result = output var buff [1024]byte @@ -50400,7 +50855,7 @@ func (m *awsEc2query_deserializeOpStopInstances) HandleDeserialize(ctx context.C } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentStopInstancesOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentStartInstancesOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -50414,7 +50869,7 @@ func (m *awsEc2query_deserializeOpStopInstances) HandleDeserialize(ctx context.C return out, metadata, err } -func awsEc2query_deserializeOpErrorStopInstances(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorStartInstances(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -50447,14 +50902,14 @@ func awsEc2query_deserializeOpErrorStopInstances(response *smithyhttp.Response, } } -type awsEc2query_deserializeOpTerminateClientVpnConnections struct { +type awsEc2query_deserializeOpStartNetworkInsightsAccessScopeAnalysis struct { } -func (*awsEc2query_deserializeOpTerminateClientVpnConnections) ID() string { +func (*awsEc2query_deserializeOpStartNetworkInsightsAccessScopeAnalysis) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpTerminateClientVpnConnections) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpStartNetworkInsightsAccessScopeAnalysis) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -50468,9 +50923,9 @@ func (m *awsEc2query_deserializeOpTerminateClientVpnConnections) HandleDeseriali } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorTerminateClientVpnConnections(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorStartNetworkInsightsAccessScopeAnalysis(response, &metadata) } - output := &TerminateClientVpnConnectionsOutput{} + output := &StartNetworkInsightsAccessScopeAnalysisOutput{} out.Result = output var buff [1024]byte @@ -50491,7 +50946,7 @@ func (m *awsEc2query_deserializeOpTerminateClientVpnConnections) HandleDeseriali } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentTerminateClientVpnConnectionsOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentStartNetworkInsightsAccessScopeAnalysisOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -50505,7 +50960,7 @@ func (m *awsEc2query_deserializeOpTerminateClientVpnConnections) HandleDeseriali return out, metadata, err } -func awsEc2query_deserializeOpErrorTerminateClientVpnConnections(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorStartNetworkInsightsAccessScopeAnalysis(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -50538,14 +50993,14 @@ func awsEc2query_deserializeOpErrorTerminateClientVpnConnections(response *smith } } -type awsEc2query_deserializeOpTerminateInstances struct { +type awsEc2query_deserializeOpStartNetworkInsightsAnalysis struct { } -func (*awsEc2query_deserializeOpTerminateInstances) ID() string { +func (*awsEc2query_deserializeOpStartNetworkInsightsAnalysis) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpTerminateInstances) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpStartNetworkInsightsAnalysis) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -50559,9 +51014,9 @@ func (m *awsEc2query_deserializeOpTerminateInstances) HandleDeserialize(ctx cont } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorTerminateInstances(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorStartNetworkInsightsAnalysis(response, &metadata) } - output := &TerminateInstancesOutput{} + output := &StartNetworkInsightsAnalysisOutput{} out.Result = output var buff [1024]byte @@ -50582,7 +51037,7 @@ func (m *awsEc2query_deserializeOpTerminateInstances) HandleDeserialize(ctx cont } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentTerminateInstancesOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentStartNetworkInsightsAnalysisOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -50596,7 +51051,371 @@ func (m *awsEc2query_deserializeOpTerminateInstances) HandleDeserialize(ctx cont return out, metadata, err } -func awsEc2query_deserializeOpErrorTerminateInstances(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorStartNetworkInsightsAnalysis(response *smithyhttp.Response, metadata *middleware.Metadata) error { + var errorBuffer bytes.Buffer + if _, err := io.Copy(&errorBuffer, response.Body); err != nil { + return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} + } + errorBody := bytes.NewReader(errorBuffer.Bytes()) + + errorCode := "UnknownError" + errorMessage := errorCode + + errorComponents, err := ec2query.GetErrorResponseComponents(errorBody) + if err != nil { + return err + } + awsmiddleware.SetRequestIDMetadata(metadata, errorComponents.RequestID) + if len(errorComponents.Code) != 0 { + errorCode = errorComponents.Code + } + if len(errorComponents.Message) != 0 { + errorMessage = errorComponents.Message + } + errorBody.Seek(0, io.SeekStart) + switch { + default: + genericError := &smithy.GenericAPIError{ + Code: errorCode, + Message: errorMessage, + } + return genericError + + } +} + +type awsEc2query_deserializeOpStartVpcEndpointServicePrivateDnsVerification struct { +} + +func (*awsEc2query_deserializeOpStartVpcEndpointServicePrivateDnsVerification) ID() string { + return "OperationDeserializer" +} + +func (m *awsEc2query_deserializeOpStartVpcEndpointServicePrivateDnsVerification) HandleDeserialize(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, awsEc2query_deserializeOpErrorStartVpcEndpointServicePrivateDnsVerification(response, &metadata) + } + output := &StartVpcEndpointServicePrivateDnsVerificationOutput{} + out.Result = output + + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + body := io.TeeReader(response.Body, ringBuffer) + rootDecoder := xml.NewDecoder(body) + t, err := smithyxml.FetchRootElement(rootDecoder) + if err == io.EOF { + return out, metadata, nil + } + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + return out, metadata, &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + } + + decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) + err = awsEc2query_deserializeOpDocumentStartVpcEndpointServicePrivateDnsVerificationOutput(&output, decoder) + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return out, metadata, err + } + + return out, metadata, err +} + +func awsEc2query_deserializeOpErrorStartVpcEndpointServicePrivateDnsVerification(response *smithyhttp.Response, metadata *middleware.Metadata) error { + var errorBuffer bytes.Buffer + if _, err := io.Copy(&errorBuffer, response.Body); err != nil { + return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} + } + errorBody := bytes.NewReader(errorBuffer.Bytes()) + + errorCode := "UnknownError" + errorMessage := errorCode + + errorComponents, err := ec2query.GetErrorResponseComponents(errorBody) + if err != nil { + return err + } + awsmiddleware.SetRequestIDMetadata(metadata, errorComponents.RequestID) + if len(errorComponents.Code) != 0 { + errorCode = errorComponents.Code + } + if len(errorComponents.Message) != 0 { + errorMessage = errorComponents.Message + } + errorBody.Seek(0, io.SeekStart) + switch { + default: + genericError := &smithy.GenericAPIError{ + Code: errorCode, + Message: errorMessage, + } + return genericError + + } +} + +type awsEc2query_deserializeOpStopInstances struct { +} + +func (*awsEc2query_deserializeOpStopInstances) ID() string { + return "OperationDeserializer" +} + +func (m *awsEc2query_deserializeOpStopInstances) HandleDeserialize(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, awsEc2query_deserializeOpErrorStopInstances(response, &metadata) + } + output := &StopInstancesOutput{} + out.Result = output + + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + body := io.TeeReader(response.Body, ringBuffer) + rootDecoder := xml.NewDecoder(body) + t, err := smithyxml.FetchRootElement(rootDecoder) + if err == io.EOF { + return out, metadata, nil + } + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + return out, metadata, &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + } + + decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) + err = awsEc2query_deserializeOpDocumentStopInstancesOutput(&output, decoder) + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return out, metadata, err + } + + return out, metadata, err +} + +func awsEc2query_deserializeOpErrorStopInstances(response *smithyhttp.Response, metadata *middleware.Metadata) error { + var errorBuffer bytes.Buffer + if _, err := io.Copy(&errorBuffer, response.Body); err != nil { + return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} + } + errorBody := bytes.NewReader(errorBuffer.Bytes()) + + errorCode := "UnknownError" + errorMessage := errorCode + + errorComponents, err := ec2query.GetErrorResponseComponents(errorBody) + if err != nil { + return err + } + awsmiddleware.SetRequestIDMetadata(metadata, errorComponents.RequestID) + if len(errorComponents.Code) != 0 { + errorCode = errorComponents.Code + } + if len(errorComponents.Message) != 0 { + errorMessage = errorComponents.Message + } + errorBody.Seek(0, io.SeekStart) + switch { + default: + genericError := &smithy.GenericAPIError{ + Code: errorCode, + Message: errorMessage, + } + return genericError + + } +} + +type awsEc2query_deserializeOpTerminateClientVpnConnections struct { +} + +func (*awsEc2query_deserializeOpTerminateClientVpnConnections) ID() string { + return "OperationDeserializer" +} + +func (m *awsEc2query_deserializeOpTerminateClientVpnConnections) HandleDeserialize(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, awsEc2query_deserializeOpErrorTerminateClientVpnConnections(response, &metadata) + } + output := &TerminateClientVpnConnectionsOutput{} + out.Result = output + + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + body := io.TeeReader(response.Body, ringBuffer) + rootDecoder := xml.NewDecoder(body) + t, err := smithyxml.FetchRootElement(rootDecoder) + if err == io.EOF { + return out, metadata, nil + } + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + return out, metadata, &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + } + + decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) + err = awsEc2query_deserializeOpDocumentTerminateClientVpnConnectionsOutput(&output, decoder) + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return out, metadata, err + } + + return out, metadata, err +} + +func awsEc2query_deserializeOpErrorTerminateClientVpnConnections(response *smithyhttp.Response, metadata *middleware.Metadata) error { + var errorBuffer bytes.Buffer + if _, err := io.Copy(&errorBuffer, response.Body); err != nil { + return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} + } + errorBody := bytes.NewReader(errorBuffer.Bytes()) + + errorCode := "UnknownError" + errorMessage := errorCode + + errorComponents, err := ec2query.GetErrorResponseComponents(errorBody) + if err != nil { + return err + } + awsmiddleware.SetRequestIDMetadata(metadata, errorComponents.RequestID) + if len(errorComponents.Code) != 0 { + errorCode = errorComponents.Code + } + if len(errorComponents.Message) != 0 { + errorMessage = errorComponents.Message + } + errorBody.Seek(0, io.SeekStart) + switch { + default: + genericError := &smithy.GenericAPIError{ + Code: errorCode, + Message: errorMessage, + } + return genericError + + } +} + +type awsEc2query_deserializeOpTerminateInstances struct { +} + +func (*awsEc2query_deserializeOpTerminateInstances) ID() string { + return "OperationDeserializer" +} + +func (m *awsEc2query_deserializeOpTerminateInstances) HandleDeserialize(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, awsEc2query_deserializeOpErrorTerminateInstances(response, &metadata) + } + output := &TerminateInstancesOutput{} + out.Result = output + + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + body := io.TeeReader(response.Body, ringBuffer) + rootDecoder := xml.NewDecoder(body) + t, err := smithyxml.FetchRootElement(rootDecoder) + if err == io.EOF { + return out, metadata, nil + } + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + return out, metadata, &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + } + + decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) + err = awsEc2query_deserializeOpDocumentTerminateInstancesOutput(&output, decoder) + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return out, metadata, err + } + + return out, metadata, err +} + +func awsEc2query_deserializeOpErrorTerminateInstances(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -82086,6 +82905,32 @@ func awsEc2query_deserializeDocumentIpam(v **types.Ipam, decoder smithyxml.NodeD originalDecoder := decoder decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) switch { + case strings.EqualFold("defaultResourceDiscoveryAssociationId", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.DefaultResourceDiscoveryAssociationId = ptr.String(xtv) + } + + case strings.EqualFold("defaultResourceDiscoveryId", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.DefaultResourceDiscoveryId = ptr.String(xtv) + } + case strings.EqualFold("description", t.Name.Local): val, err := decoder.Value() if err != nil { @@ -82183,6 +83028,23 @@ func awsEc2query_deserializeDocumentIpam(v **types.Ipam, decoder smithyxml.NodeD sv.PublicDefaultScopeId = ptr.String(xtv) } + case strings.EqualFold("resourceDiscoveryAssociationCount", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + i64, err := strconv.ParseInt(xtv, 10, 64) + if err != nil { + return err + } + sv.ResourceDiscoveryAssociationCount = ptr.Int32(int32(i64)) + } + case strings.EqualFold("scopeCount", t.Name.Local): val, err := decoder.Value() if err != nil { @@ -82488,6 +83350,473 @@ func awsEc2query_deserializeDocumentIpamAddressHistoryRecordSetUnwrapped(v *[]ty *v = sv return nil } +func awsEc2query_deserializeDocumentIpamDiscoveredAccount(v **types.IpamDiscoveredAccount, decoder smithyxml.NodeDecoder) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + var sv *types.IpamDiscoveredAccount + if *v == nil { + sv = &types.IpamDiscoveredAccount{} + } else { + sv = *v + } + + for { + t, done, err := decoder.Token() + if err != nil { + return err + } + if done { + break + } + originalDecoder := decoder + decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) + switch { + case strings.EqualFold("accountId", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.AccountId = ptr.String(xtv) + } + + case strings.EqualFold("discoveryRegion", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.DiscoveryRegion = ptr.String(xtv) + } + + case strings.EqualFold("failureReason", t.Name.Local): + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + if err := awsEc2query_deserializeDocumentIpamDiscoveryFailureReason(&sv.FailureReason, nodeDecoder); err != nil { + return err + } + + case strings.EqualFold("lastAttemptedDiscoveryTime", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + t, err := smithytime.ParseDateTime(xtv) + if err != nil { + return err + } + sv.LastAttemptedDiscoveryTime = ptr.Time(t) + } + + case strings.EqualFold("lastSuccessfulDiscoveryTime", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + t, err := smithytime.ParseDateTime(xtv) + if err != nil { + return err + } + sv.LastSuccessfulDiscoveryTime = ptr.Time(t) + } + + default: + // Do nothing and ignore the unexpected tag element + err = decoder.Decoder.Skip() + if err != nil { + return err + } + + } + decoder = originalDecoder + } + *v = sv + return nil +} + +func awsEc2query_deserializeDocumentIpamDiscoveredAccountSet(v *[]types.IpamDiscoveredAccount, decoder smithyxml.NodeDecoder) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + var sv []types.IpamDiscoveredAccount + if *v == nil { + sv = make([]types.IpamDiscoveredAccount, 0) + } else { + sv = *v + } + + originalDecoder := decoder + for { + t, done, err := decoder.Token() + if err != nil { + return err + } + if done { + break + } + switch { + case strings.EqualFold("item", t.Name.Local): + var col types.IpamDiscoveredAccount + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + destAddr := &col + if err := awsEc2query_deserializeDocumentIpamDiscoveredAccount(&destAddr, nodeDecoder); err != nil { + return err + } + col = *destAddr + sv = append(sv, col) + + default: + err = decoder.Decoder.Skip() + if err != nil { + return err + } + + } + decoder = originalDecoder + } + *v = sv + return nil +} + +func awsEc2query_deserializeDocumentIpamDiscoveredAccountSetUnwrapped(v *[]types.IpamDiscoveredAccount, decoder smithyxml.NodeDecoder) error { + var sv []types.IpamDiscoveredAccount + if *v == nil { + sv = make([]types.IpamDiscoveredAccount, 0) + } else { + sv = *v + } + + switch { + default: + var mv types.IpamDiscoveredAccount + t := decoder.StartEl + _ = t + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + destAddr := &mv + if err := awsEc2query_deserializeDocumentIpamDiscoveredAccount(&destAddr, nodeDecoder); err != nil { + return err + } + mv = *destAddr + sv = append(sv, mv) + } + *v = sv + return nil +} +func awsEc2query_deserializeDocumentIpamDiscoveredResourceCidr(v **types.IpamDiscoveredResourceCidr, decoder smithyxml.NodeDecoder) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + var sv *types.IpamDiscoveredResourceCidr + if *v == nil { + sv = &types.IpamDiscoveredResourceCidr{} + } else { + sv = *v + } + + for { + t, done, err := decoder.Token() + if err != nil { + return err + } + if done { + break + } + originalDecoder := decoder + decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) + switch { + case strings.EqualFold("ipamResourceDiscoveryId", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.IpamResourceDiscoveryId = ptr.String(xtv) + } + + case strings.EqualFold("ipUsage", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + f64, err := strconv.ParseFloat(xtv, 64) + if err != nil { + return err + } + sv.IpUsage = ptr.Float64(f64) + } + + case strings.EqualFold("resourceCidr", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.ResourceCidr = ptr.String(xtv) + } + + case strings.EqualFold("resourceId", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.ResourceId = ptr.String(xtv) + } + + case strings.EqualFold("resourceOwnerId", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.ResourceOwnerId = ptr.String(xtv) + } + + case strings.EqualFold("resourceRegion", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.ResourceRegion = ptr.String(xtv) + } + + case strings.EqualFold("resourceTagSet", t.Name.Local): + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + if err := awsEc2query_deserializeDocumentIpamResourceTagList(&sv.ResourceTags, nodeDecoder); err != nil { + return err + } + + case strings.EqualFold("resourceType", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.ResourceType = types.IpamResourceType(xtv) + } + + case strings.EqualFold("sampleTime", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + t, err := smithytime.ParseDateTime(xtv) + if err != nil { + return err + } + sv.SampleTime = ptr.Time(t) + } + + case strings.EqualFold("vpcId", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.VpcId = ptr.String(xtv) + } + + default: + // Do nothing and ignore the unexpected tag element + err = decoder.Decoder.Skip() + if err != nil { + return err + } + + } + decoder = originalDecoder + } + *v = sv + return nil +} + +func awsEc2query_deserializeDocumentIpamDiscoveredResourceCidrSet(v *[]types.IpamDiscoveredResourceCidr, decoder smithyxml.NodeDecoder) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + var sv []types.IpamDiscoveredResourceCidr + if *v == nil { + sv = make([]types.IpamDiscoveredResourceCidr, 0) + } else { + sv = *v + } + + originalDecoder := decoder + for { + t, done, err := decoder.Token() + if err != nil { + return err + } + if done { + break + } + switch { + case strings.EqualFold("item", t.Name.Local): + var col types.IpamDiscoveredResourceCidr + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + destAddr := &col + if err := awsEc2query_deserializeDocumentIpamDiscoveredResourceCidr(&destAddr, nodeDecoder); err != nil { + return err + } + col = *destAddr + sv = append(sv, col) + + default: + err = decoder.Decoder.Skip() + if err != nil { + return err + } + + } + decoder = originalDecoder + } + *v = sv + return nil +} + +func awsEc2query_deserializeDocumentIpamDiscoveredResourceCidrSetUnwrapped(v *[]types.IpamDiscoveredResourceCidr, decoder smithyxml.NodeDecoder) error { + var sv []types.IpamDiscoveredResourceCidr + if *v == nil { + sv = make([]types.IpamDiscoveredResourceCidr, 0) + } else { + sv = *v + } + + switch { + default: + var mv types.IpamDiscoveredResourceCidr + t := decoder.StartEl + _ = t + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + destAddr := &mv + if err := awsEc2query_deserializeDocumentIpamDiscoveredResourceCidr(&destAddr, nodeDecoder); err != nil { + return err + } + mv = *destAddr + sv = append(sv, mv) + } + *v = sv + return nil +} +func awsEc2query_deserializeDocumentIpamDiscoveryFailureReason(v **types.IpamDiscoveryFailureReason, decoder smithyxml.NodeDecoder) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + var sv *types.IpamDiscoveryFailureReason + if *v == nil { + sv = &types.IpamDiscoveryFailureReason{} + } else { + sv = *v + } + + for { + t, done, err := decoder.Token() + if err != nil { + return err + } + if done { + break + } + originalDecoder := decoder + decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) + switch { + case strings.EqualFold("code", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.Code = types.IpamDiscoveryFailureCode(xtv) + } + + case strings.EqualFold("message", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.Message = ptr.String(xtv) + } + + default: + // Do nothing and ignore the unexpected tag element + err = decoder.Decoder.Skip() + if err != nil { + return err + } + + } + decoder = originalDecoder + } + *v = sv + return nil +} + func awsEc2query_deserializeDocumentIpamOperatingRegion(v **types.IpamOperatingRegion, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) @@ -82860,6 +84189,19 @@ func awsEc2query_deserializeDocumentIpamPool(v **types.IpamPool, decoder smithyx sv.PoolDepth = ptr.Int32(int32(i64)) } + case strings.EqualFold("publicIpSource", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.PublicIpSource = types.IpamPoolPublicIpSource(xtv) + } + case strings.EqualFold("publiclyAdvertisable", t.Name.Local): val, err := decoder.Value() if err != nil { @@ -83171,6 +84513,36 @@ func awsEc2query_deserializeDocumentIpamPoolCidr(v **types.IpamPoolCidr, decoder return err } + case strings.EqualFold("ipamPoolCidrId", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.IpamPoolCidrId = ptr.String(xtv) + } + + case strings.EqualFold("netmaskLength", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + i64, err := strconv.ParseInt(xtv, 10, 64) + if err != nil { + return err + } + sv.NetmaskLength = ptr.Int32(int32(i64)) + } + case strings.EqualFold("state", t.Name.Local): val, err := decoder.Value() if err != nil { @@ -83692,6 +85064,459 @@ func awsEc2query_deserializeDocumentIpamResourceCidrSetUnwrapped(v *[]types.Ipam *v = sv return nil } +func awsEc2query_deserializeDocumentIpamResourceDiscovery(v **types.IpamResourceDiscovery, decoder smithyxml.NodeDecoder) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + var sv *types.IpamResourceDiscovery + if *v == nil { + sv = &types.IpamResourceDiscovery{} + } else { + sv = *v + } + + for { + t, done, err := decoder.Token() + if err != nil { + return err + } + if done { + break + } + originalDecoder := decoder + decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) + switch { + case strings.EqualFold("description", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.Description = ptr.String(xtv) + } + + case strings.EqualFold("ipamResourceDiscoveryArn", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.IpamResourceDiscoveryArn = ptr.String(xtv) + } + + case strings.EqualFold("ipamResourceDiscoveryId", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.IpamResourceDiscoveryId = ptr.String(xtv) + } + + case strings.EqualFold("ipamResourceDiscoveryRegion", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.IpamResourceDiscoveryRegion = ptr.String(xtv) + } + + case strings.EqualFold("isDefault", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv, err := strconv.ParseBool(string(val)) + if err != nil { + return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", val) + } + sv.IsDefault = ptr.Bool(xtv) + } + + case strings.EqualFold("operatingRegionSet", t.Name.Local): + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + if err := awsEc2query_deserializeDocumentIpamOperatingRegionSet(&sv.OperatingRegions, nodeDecoder); err != nil { + return err + } + + case strings.EqualFold("ownerId", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.OwnerId = ptr.String(xtv) + } + + case strings.EqualFold("state", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.State = types.IpamResourceDiscoveryState(xtv) + } + + case strings.EqualFold("tagSet", t.Name.Local): + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + if err := awsEc2query_deserializeDocumentTagList(&sv.Tags, nodeDecoder); err != nil { + return err + } + + default: + // Do nothing and ignore the unexpected tag element + err = decoder.Decoder.Skip() + if err != nil { + return err + } + + } + decoder = originalDecoder + } + *v = sv + return nil +} + +func awsEc2query_deserializeDocumentIpamResourceDiscoveryAssociation(v **types.IpamResourceDiscoveryAssociation, decoder smithyxml.NodeDecoder) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + var sv *types.IpamResourceDiscoveryAssociation + if *v == nil { + sv = &types.IpamResourceDiscoveryAssociation{} + } else { + sv = *v + } + + for { + t, done, err := decoder.Token() + if err != nil { + return err + } + if done { + break + } + originalDecoder := decoder + decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) + switch { + case strings.EqualFold("ipamArn", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.IpamArn = ptr.String(xtv) + } + + case strings.EqualFold("ipamId", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.IpamId = ptr.String(xtv) + } + + case strings.EqualFold("ipamRegion", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.IpamRegion = ptr.String(xtv) + } + + case strings.EqualFold("ipamResourceDiscoveryAssociationArn", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.IpamResourceDiscoveryAssociationArn = ptr.String(xtv) + } + + case strings.EqualFold("ipamResourceDiscoveryAssociationId", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.IpamResourceDiscoveryAssociationId = ptr.String(xtv) + } + + case strings.EqualFold("ipamResourceDiscoveryId", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.IpamResourceDiscoveryId = ptr.String(xtv) + } + + case strings.EqualFold("isDefault", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv, err := strconv.ParseBool(string(val)) + if err != nil { + return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", val) + } + sv.IsDefault = ptr.Bool(xtv) + } + + case strings.EqualFold("ownerId", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.OwnerId = ptr.String(xtv) + } + + case strings.EqualFold("resourceDiscoveryStatus", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.ResourceDiscoveryStatus = types.IpamAssociatedResourceDiscoveryStatus(xtv) + } + + case strings.EqualFold("state", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.State = types.IpamResourceDiscoveryAssociationState(xtv) + } + + case strings.EqualFold("tagSet", t.Name.Local): + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + if err := awsEc2query_deserializeDocumentTagList(&sv.Tags, nodeDecoder); err != nil { + return err + } + + default: + // Do nothing and ignore the unexpected tag element + err = decoder.Decoder.Skip() + if err != nil { + return err + } + + } + decoder = originalDecoder + } + *v = sv + return nil +} + +func awsEc2query_deserializeDocumentIpamResourceDiscoveryAssociationSet(v *[]types.IpamResourceDiscoveryAssociation, decoder smithyxml.NodeDecoder) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + var sv []types.IpamResourceDiscoveryAssociation + if *v == nil { + sv = make([]types.IpamResourceDiscoveryAssociation, 0) + } else { + sv = *v + } + + originalDecoder := decoder + for { + t, done, err := decoder.Token() + if err != nil { + return err + } + if done { + break + } + switch { + case strings.EqualFold("item", t.Name.Local): + var col types.IpamResourceDiscoveryAssociation + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + destAddr := &col + if err := awsEc2query_deserializeDocumentIpamResourceDiscoveryAssociation(&destAddr, nodeDecoder); err != nil { + return err + } + col = *destAddr + sv = append(sv, col) + + default: + err = decoder.Decoder.Skip() + if err != nil { + return err + } + + } + decoder = originalDecoder + } + *v = sv + return nil +} + +func awsEc2query_deserializeDocumentIpamResourceDiscoveryAssociationSetUnwrapped(v *[]types.IpamResourceDiscoveryAssociation, decoder smithyxml.NodeDecoder) error { + var sv []types.IpamResourceDiscoveryAssociation + if *v == nil { + sv = make([]types.IpamResourceDiscoveryAssociation, 0) + } else { + sv = *v + } + + switch { + default: + var mv types.IpamResourceDiscoveryAssociation + t := decoder.StartEl + _ = t + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + destAddr := &mv + if err := awsEc2query_deserializeDocumentIpamResourceDiscoveryAssociation(&destAddr, nodeDecoder); err != nil { + return err + } + mv = *destAddr + sv = append(sv, mv) + } + *v = sv + return nil +} +func awsEc2query_deserializeDocumentIpamResourceDiscoverySet(v *[]types.IpamResourceDiscovery, decoder smithyxml.NodeDecoder) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + var sv []types.IpamResourceDiscovery + if *v == nil { + sv = make([]types.IpamResourceDiscovery, 0) + } else { + sv = *v + } + + originalDecoder := decoder + for { + t, done, err := decoder.Token() + if err != nil { + return err + } + if done { + break + } + switch { + case strings.EqualFold("item", t.Name.Local): + var col types.IpamResourceDiscovery + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + destAddr := &col + if err := awsEc2query_deserializeDocumentIpamResourceDiscovery(&destAddr, nodeDecoder); err != nil { + return err + } + col = *destAddr + sv = append(sv, col) + + default: + err = decoder.Decoder.Skip() + if err != nil { + return err + } + + } + decoder = originalDecoder + } + *v = sv + return nil +} + +func awsEc2query_deserializeDocumentIpamResourceDiscoverySetUnwrapped(v *[]types.IpamResourceDiscovery, decoder smithyxml.NodeDecoder) error { + var sv []types.IpamResourceDiscovery + if *v == nil { + sv = make([]types.IpamResourceDiscovery, 0) + } else { + sv = *v + } + + switch { + default: + var mv types.IpamResourceDiscovery + t := decoder.StartEl + _ = t + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + destAddr := &mv + if err := awsEc2query_deserializeDocumentIpamResourceDiscovery(&destAddr, nodeDecoder); err != nil { + return err + } + mv = *destAddr + sv = append(sv, mv) + } + *v = sv + return nil +} func awsEc2query_deserializeDocumentIpamResourceTag(v **types.IpamResourceTag, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) @@ -129622,6 +131447,48 @@ func awsEc2query_deserializeOpDocumentAssociateInstanceEventWindowOutput(v **Ass return nil } +func awsEc2query_deserializeOpDocumentAssociateIpamResourceDiscoveryOutput(v **AssociateIpamResourceDiscoveryOutput, decoder smithyxml.NodeDecoder) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + var sv *AssociateIpamResourceDiscoveryOutput + if *v == nil { + sv = &AssociateIpamResourceDiscoveryOutput{} + } else { + sv = *v + } + + for { + t, done, err := decoder.Token() + if err != nil { + return err + } + if done { + break + } + originalDecoder := decoder + decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) + switch { + case strings.EqualFold("ipamResourceDiscoveryAssociation", t.Name.Local): + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + if err := awsEc2query_deserializeDocumentIpamResourceDiscoveryAssociation(&sv.IpamResourceDiscoveryAssociation, nodeDecoder); err != nil { + return err + } + + default: + // Do nothing and ignore the unexpected tag element + err = decoder.Decoder.Skip() + if err != nil { + return err + } + + } + decoder = originalDecoder + } + *v = sv + return nil +} + func awsEc2query_deserializeOpDocumentAssociateRouteTableOutput(v **AssociateRouteTableOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) @@ -132247,6 +134114,48 @@ func awsEc2query_deserializeOpDocumentCreateIpamPoolOutput(v **CreateIpamPoolOut return nil } +func awsEc2query_deserializeOpDocumentCreateIpamResourceDiscoveryOutput(v **CreateIpamResourceDiscoveryOutput, decoder smithyxml.NodeDecoder) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + var sv *CreateIpamResourceDiscoveryOutput + if *v == nil { + sv = &CreateIpamResourceDiscoveryOutput{} + } else { + sv = *v + } + + for { + t, done, err := decoder.Token() + if err != nil { + return err + } + if done { + break + } + originalDecoder := decoder + decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) + switch { + case strings.EqualFold("ipamResourceDiscovery", t.Name.Local): + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + if err := awsEc2query_deserializeDocumentIpamResourceDiscovery(&sv.IpamResourceDiscovery, nodeDecoder); err != nil { + return err + } + + default: + // Do nothing and ignore the unexpected tag element + err = decoder.Decoder.Skip() + if err != nil { + return err + } + + } + decoder = originalDecoder + } + *v = sv + return nil +} + func awsEc2query_deserializeOpDocumentCreateIpamScopeOutput(v **CreateIpamScopeOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) @@ -135796,6 +137705,48 @@ func awsEc2query_deserializeOpDocumentDeleteIpamPoolOutput(v **DeleteIpamPoolOut return nil } +func awsEc2query_deserializeOpDocumentDeleteIpamResourceDiscoveryOutput(v **DeleteIpamResourceDiscoveryOutput, decoder smithyxml.NodeDecoder) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + var sv *DeleteIpamResourceDiscoveryOutput + if *v == nil { + sv = &DeleteIpamResourceDiscoveryOutput{} + } else { + sv = *v + } + + for { + t, done, err := decoder.Token() + if err != nil { + return err + } + if done { + break + } + originalDecoder := decoder + decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) + switch { + case strings.EqualFold("ipamResourceDiscovery", t.Name.Local): + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + if err := awsEc2query_deserializeDocumentIpamResourceDiscovery(&sv.IpamResourceDiscovery, nodeDecoder); err != nil { + return err + } + + default: + // Do nothing and ignore the unexpected tag element + err = decoder.Decoder.Skip() + if err != nil { + return err + } + + } + decoder = originalDecoder + } + *v = sv + return nil +} + func awsEc2query_deserializeOpDocumentDeleteIpamScopeOutput(v **DeleteIpamScopeOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) @@ -140482,13 +142433,110 @@ func awsEc2query_deserializeOpDocumentDescribeInstanceCreditSpecificationsOutput return nil } -func awsEc2query_deserializeOpDocumentDescribeInstanceEventNotificationAttributesOutput(v **DescribeInstanceEventNotificationAttributesOutput, decoder smithyxml.NodeDecoder) error { +func awsEc2query_deserializeOpDocumentDescribeInstanceEventNotificationAttributesOutput(v **DescribeInstanceEventNotificationAttributesOutput, decoder smithyxml.NodeDecoder) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + var sv *DescribeInstanceEventNotificationAttributesOutput + if *v == nil { + sv = &DescribeInstanceEventNotificationAttributesOutput{} + } else { + sv = *v + } + + for { + t, done, err := decoder.Token() + if err != nil { + return err + } + if done { + break + } + originalDecoder := decoder + decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) + switch { + case strings.EqualFold("instanceTagAttribute", t.Name.Local): + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + if err := awsEc2query_deserializeDocumentInstanceTagNotificationAttribute(&sv.InstanceTagAttribute, nodeDecoder); err != nil { + return err + } + + default: + // Do nothing and ignore the unexpected tag element + err = decoder.Decoder.Skip() + if err != nil { + return err + } + + } + decoder = originalDecoder + } + *v = sv + return nil +} + +func awsEc2query_deserializeOpDocumentDescribeInstanceEventWindowsOutput(v **DescribeInstanceEventWindowsOutput, decoder smithyxml.NodeDecoder) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + var sv *DescribeInstanceEventWindowsOutput + if *v == nil { + sv = &DescribeInstanceEventWindowsOutput{} + } else { + sv = *v + } + + for { + t, done, err := decoder.Token() + if err != nil { + return err + } + if done { + break + } + originalDecoder := decoder + decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) + switch { + case strings.EqualFold("instanceEventWindowSet", t.Name.Local): + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + if err := awsEc2query_deserializeDocumentInstanceEventWindowSet(&sv.InstanceEventWindows, nodeDecoder); err != nil { + return err + } + + case strings.EqualFold("nextToken", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.NextToken = ptr.String(xtv) + } + + default: + // Do nothing and ignore the unexpected tag element + err = decoder.Decoder.Skip() + if err != nil { + return err + } + + } + decoder = originalDecoder + } + *v = sv + return nil +} + +func awsEc2query_deserializeOpDocumentDescribeInstancesOutput(v **DescribeInstancesOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } - var sv *DescribeInstanceEventNotificationAttributesOutput + var sv *DescribeInstancesOutput if *v == nil { - sv = &DescribeInstanceEventNotificationAttributesOutput{} + sv = &DescribeInstancesOutput{} } else { sv = *v } @@ -140504,9 +142552,22 @@ func awsEc2query_deserializeOpDocumentDescribeInstanceEventNotificationAttribute originalDecoder := decoder decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) switch { - case strings.EqualFold("instanceTagAttribute", t.Name.Local): + case strings.EqualFold("nextToken", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.NextToken = ptr.String(xtv) + } + + case strings.EqualFold("reservationSet", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) - if err := awsEc2query_deserializeDocumentInstanceTagNotificationAttribute(&sv.InstanceTagAttribute, nodeDecoder); err != nil { + if err := awsEc2query_deserializeDocumentReservationList(&sv.Reservations, nodeDecoder); err != nil { return err } @@ -140524,13 +142585,13 @@ func awsEc2query_deserializeOpDocumentDescribeInstanceEventNotificationAttribute return nil } -func awsEc2query_deserializeOpDocumentDescribeInstanceEventWindowsOutput(v **DescribeInstanceEventWindowsOutput, decoder smithyxml.NodeDecoder) error { +func awsEc2query_deserializeOpDocumentDescribeInstanceStatusOutput(v **DescribeInstanceStatusOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } - var sv *DescribeInstanceEventWindowsOutput + var sv *DescribeInstanceStatusOutput if *v == nil { - sv = &DescribeInstanceEventWindowsOutput{} + sv = &DescribeInstanceStatusOutput{} } else { sv = *v } @@ -140546,9 +142607,9 @@ func awsEc2query_deserializeOpDocumentDescribeInstanceEventWindowsOutput(v **Des originalDecoder := decoder decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) switch { - case strings.EqualFold("instanceEventWindowSet", t.Name.Local): + case strings.EqualFold("instanceStatusSet", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) - if err := awsEc2query_deserializeDocumentInstanceEventWindowSet(&sv.InstanceEventWindows, nodeDecoder); err != nil { + if err := awsEc2query_deserializeDocumentInstanceStatusList(&sv.InstanceStatuses, nodeDecoder); err != nil { return err } @@ -140579,13 +142640,13 @@ func awsEc2query_deserializeOpDocumentDescribeInstanceEventWindowsOutput(v **Des return nil } -func awsEc2query_deserializeOpDocumentDescribeInstancesOutput(v **DescribeInstancesOutput, decoder smithyxml.NodeDecoder) error { +func awsEc2query_deserializeOpDocumentDescribeInstanceTypeOfferingsOutput(v **DescribeInstanceTypeOfferingsOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } - var sv *DescribeInstancesOutput + var sv *DescribeInstanceTypeOfferingsOutput if *v == nil { - sv = &DescribeInstancesOutput{} + sv = &DescribeInstanceTypeOfferingsOutput{} } else { sv = *v } @@ -140601,6 +142662,12 @@ func awsEc2query_deserializeOpDocumentDescribeInstancesOutput(v **DescribeInstan originalDecoder := decoder decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) switch { + case strings.EqualFold("instanceTypeOfferingSet", t.Name.Local): + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + if err := awsEc2query_deserializeDocumentInstanceTypeOfferingsList(&sv.InstanceTypeOfferings, nodeDecoder); err != nil { + return err + } + case strings.EqualFold("nextToken", t.Name.Local): val, err := decoder.Value() if err != nil { @@ -140614,12 +142681,6 @@ func awsEc2query_deserializeOpDocumentDescribeInstancesOutput(v **DescribeInstan sv.NextToken = ptr.String(xtv) } - case strings.EqualFold("reservationSet", t.Name.Local): - nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) - if err := awsEc2query_deserializeDocumentReservationList(&sv.Reservations, nodeDecoder); err != nil { - return err - } - default: // Do nothing and ignore the unexpected tag element err = decoder.Decoder.Skip() @@ -140634,13 +142695,13 @@ func awsEc2query_deserializeOpDocumentDescribeInstancesOutput(v **DescribeInstan return nil } -func awsEc2query_deserializeOpDocumentDescribeInstanceStatusOutput(v **DescribeInstanceStatusOutput, decoder smithyxml.NodeDecoder) error { +func awsEc2query_deserializeOpDocumentDescribeInstanceTypesOutput(v **DescribeInstanceTypesOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } - var sv *DescribeInstanceStatusOutput + var sv *DescribeInstanceTypesOutput if *v == nil { - sv = &DescribeInstanceStatusOutput{} + sv = &DescribeInstanceTypesOutput{} } else { sv = *v } @@ -140656,9 +142717,9 @@ func awsEc2query_deserializeOpDocumentDescribeInstanceStatusOutput(v **DescribeI originalDecoder := decoder decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) switch { - case strings.EqualFold("instanceStatusSet", t.Name.Local): + case strings.EqualFold("instanceTypeSet", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) - if err := awsEc2query_deserializeDocumentInstanceStatusList(&sv.InstanceStatuses, nodeDecoder); err != nil { + if err := awsEc2query_deserializeDocumentInstanceTypeInfoList(&sv.InstanceTypes, nodeDecoder); err != nil { return err } @@ -140689,13 +142750,13 @@ func awsEc2query_deserializeOpDocumentDescribeInstanceStatusOutput(v **DescribeI return nil } -func awsEc2query_deserializeOpDocumentDescribeInstanceTypeOfferingsOutput(v **DescribeInstanceTypeOfferingsOutput, decoder smithyxml.NodeDecoder) error { +func awsEc2query_deserializeOpDocumentDescribeInternetGatewaysOutput(v **DescribeInternetGatewaysOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } - var sv *DescribeInstanceTypeOfferingsOutput + var sv *DescribeInternetGatewaysOutput if *v == nil { - sv = &DescribeInstanceTypeOfferingsOutput{} + sv = &DescribeInternetGatewaysOutput{} } else { sv = *v } @@ -140711,9 +142772,9 @@ func awsEc2query_deserializeOpDocumentDescribeInstanceTypeOfferingsOutput(v **De originalDecoder := decoder decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) switch { - case strings.EqualFold("instanceTypeOfferingSet", t.Name.Local): + case strings.EqualFold("internetGatewaySet", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) - if err := awsEc2query_deserializeDocumentInstanceTypeOfferingsList(&sv.InstanceTypeOfferings, nodeDecoder); err != nil { + if err := awsEc2query_deserializeDocumentInternetGatewayList(&sv.InternetGateways, nodeDecoder); err != nil { return err } @@ -140744,13 +142805,13 @@ func awsEc2query_deserializeOpDocumentDescribeInstanceTypeOfferingsOutput(v **De return nil } -func awsEc2query_deserializeOpDocumentDescribeInstanceTypesOutput(v **DescribeInstanceTypesOutput, decoder smithyxml.NodeDecoder) error { +func awsEc2query_deserializeOpDocumentDescribeIpamPoolsOutput(v **DescribeIpamPoolsOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } - var sv *DescribeInstanceTypesOutput + var sv *DescribeIpamPoolsOutput if *v == nil { - sv = &DescribeInstanceTypesOutput{} + sv = &DescribeIpamPoolsOutput{} } else { sv = *v } @@ -140766,9 +142827,9 @@ func awsEc2query_deserializeOpDocumentDescribeInstanceTypesOutput(v **DescribeIn originalDecoder := decoder decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) switch { - case strings.EqualFold("instanceTypeSet", t.Name.Local): + case strings.EqualFold("ipamPoolSet", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) - if err := awsEc2query_deserializeDocumentInstanceTypeInfoList(&sv.InstanceTypes, nodeDecoder); err != nil { + if err := awsEc2query_deserializeDocumentIpamPoolSet(&sv.IpamPools, nodeDecoder); err != nil { return err } @@ -140799,13 +142860,13 @@ func awsEc2query_deserializeOpDocumentDescribeInstanceTypesOutput(v **DescribeIn return nil } -func awsEc2query_deserializeOpDocumentDescribeInternetGatewaysOutput(v **DescribeInternetGatewaysOutput, decoder smithyxml.NodeDecoder) error { +func awsEc2query_deserializeOpDocumentDescribeIpamResourceDiscoveriesOutput(v **DescribeIpamResourceDiscoveriesOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } - var sv *DescribeInternetGatewaysOutput + var sv *DescribeIpamResourceDiscoveriesOutput if *v == nil { - sv = &DescribeInternetGatewaysOutput{} + sv = &DescribeIpamResourceDiscoveriesOutput{} } else { sv = *v } @@ -140821,9 +142882,9 @@ func awsEc2query_deserializeOpDocumentDescribeInternetGatewaysOutput(v **Describ originalDecoder := decoder decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) switch { - case strings.EqualFold("internetGatewaySet", t.Name.Local): + case strings.EqualFold("ipamResourceDiscoverySet", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) - if err := awsEc2query_deserializeDocumentInternetGatewayList(&sv.InternetGateways, nodeDecoder); err != nil { + if err := awsEc2query_deserializeDocumentIpamResourceDiscoverySet(&sv.IpamResourceDiscoveries, nodeDecoder); err != nil { return err } @@ -140854,13 +142915,13 @@ func awsEc2query_deserializeOpDocumentDescribeInternetGatewaysOutput(v **Describ return nil } -func awsEc2query_deserializeOpDocumentDescribeIpamPoolsOutput(v **DescribeIpamPoolsOutput, decoder smithyxml.NodeDecoder) error { +func awsEc2query_deserializeOpDocumentDescribeIpamResourceDiscoveryAssociationsOutput(v **DescribeIpamResourceDiscoveryAssociationsOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } - var sv *DescribeIpamPoolsOutput + var sv *DescribeIpamResourceDiscoveryAssociationsOutput if *v == nil { - sv = &DescribeIpamPoolsOutput{} + sv = &DescribeIpamResourceDiscoveryAssociationsOutput{} } else { sv = *v } @@ -140876,9 +142937,9 @@ func awsEc2query_deserializeOpDocumentDescribeIpamPoolsOutput(v **DescribeIpamPo originalDecoder := decoder decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) switch { - case strings.EqualFold("ipamPoolSet", t.Name.Local): + case strings.EqualFold("ipamResourceDiscoveryAssociationSet", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) - if err := awsEc2query_deserializeDocumentIpamPoolSet(&sv.IpamPools, nodeDecoder); err != nil { + if err := awsEc2query_deserializeDocumentIpamResourceDiscoveryAssociationSet(&sv.IpamResourceDiscoveryAssociations, nodeDecoder); err != nil { return err } @@ -146782,6 +148843,48 @@ func awsEc2query_deserializeOpDocumentDisassociateInstanceEventWindowOutput(v ** return nil } +func awsEc2query_deserializeOpDocumentDisassociateIpamResourceDiscoveryOutput(v **DisassociateIpamResourceDiscoveryOutput, decoder smithyxml.NodeDecoder) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + var sv *DisassociateIpamResourceDiscoveryOutput + if *v == nil { + sv = &DisassociateIpamResourceDiscoveryOutput{} + } else { + sv = *v + } + + for { + t, done, err := decoder.Token() + if err != nil { + return err + } + if done { + break + } + originalDecoder := decoder + decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) + switch { + case strings.EqualFold("ipamResourceDiscoveryAssociation", t.Name.Local): + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + if err := awsEc2query_deserializeDocumentIpamResourceDiscoveryAssociation(&sv.IpamResourceDiscoveryAssociation, nodeDecoder); err != nil { + return err + } + + default: + // Do nothing and ignore the unexpected tag element + err = decoder.Decoder.Skip() + if err != nil { + return err + } + + } + decoder = originalDecoder + } + *v = sv + return nil +} + func awsEc2query_deserializeOpDocumentDisassociateSubnetCidrBlockOutput(v **DisassociateSubnetCidrBlockOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) @@ -149078,6 +151181,116 @@ func awsEc2query_deserializeOpDocumentGetIpamAddressHistoryOutput(v **GetIpamAdd return nil } +func awsEc2query_deserializeOpDocumentGetIpamDiscoveredAccountsOutput(v **GetIpamDiscoveredAccountsOutput, decoder smithyxml.NodeDecoder) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + var sv *GetIpamDiscoveredAccountsOutput + if *v == nil { + sv = &GetIpamDiscoveredAccountsOutput{} + } else { + sv = *v + } + + for { + t, done, err := decoder.Token() + if err != nil { + return err + } + if done { + break + } + originalDecoder := decoder + decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) + switch { + case strings.EqualFold("ipamDiscoveredAccountSet", t.Name.Local): + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + if err := awsEc2query_deserializeDocumentIpamDiscoveredAccountSet(&sv.IpamDiscoveredAccounts, nodeDecoder); err != nil { + return err + } + + case strings.EqualFold("nextToken", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.NextToken = ptr.String(xtv) + } + + default: + // Do nothing and ignore the unexpected tag element + err = decoder.Decoder.Skip() + if err != nil { + return err + } + + } + decoder = originalDecoder + } + *v = sv + return nil +} + +func awsEc2query_deserializeOpDocumentGetIpamDiscoveredResourceCidrsOutput(v **GetIpamDiscoveredResourceCidrsOutput, decoder smithyxml.NodeDecoder) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + var sv *GetIpamDiscoveredResourceCidrsOutput + if *v == nil { + sv = &GetIpamDiscoveredResourceCidrsOutput{} + } else { + sv = *v + } + + for { + t, done, err := decoder.Token() + if err != nil { + return err + } + if done { + break + } + originalDecoder := decoder + decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) + switch { + case strings.EqualFold("ipamDiscoveredResourceCidrSet", t.Name.Local): + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + if err := awsEc2query_deserializeDocumentIpamDiscoveredResourceCidrSet(&sv.IpamDiscoveredResourceCidrs, nodeDecoder); err != nil { + return err + } + + case strings.EqualFold("nextToken", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.NextToken = ptr.String(xtv) + } + + default: + // Do nothing and ignore the unexpected tag element + err = decoder.Decoder.Skip() + if err != nil { + return err + } + + } + decoder = originalDecoder + } + *v = sv + return nil +} + func awsEc2query_deserializeOpDocumentGetIpamPoolAllocationsOutput(v **GetIpamPoolAllocationsOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) @@ -152092,6 +154305,48 @@ func awsEc2query_deserializeOpDocumentModifyIpamResourceCidrOutput(v **ModifyIpa return nil } +func awsEc2query_deserializeOpDocumentModifyIpamResourceDiscoveryOutput(v **ModifyIpamResourceDiscoveryOutput, decoder smithyxml.NodeDecoder) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + var sv *ModifyIpamResourceDiscoveryOutput + if *v == nil { + sv = &ModifyIpamResourceDiscoveryOutput{} + } else { + sv = *v + } + + for { + t, done, err := decoder.Token() + if err != nil { + return err + } + if done { + break + } + originalDecoder := decoder + decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) + switch { + case strings.EqualFold("ipamResourceDiscovery", t.Name.Local): + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + if err := awsEc2query_deserializeDocumentIpamResourceDiscovery(&sv.IpamResourceDiscovery, nodeDecoder); err != nil { + return err + } + + default: + // Do nothing and ignore the unexpected tag element + err = decoder.Decoder.Skip() + if err != nil { + return err + } + + } + decoder = originalDecoder + } + *v = sv + return nil +} + func awsEc2query_deserializeOpDocumentModifyIpamScopeOutput(v **ModifyIpamScopeOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) diff --git a/service/ec2/generated.json b/service/ec2/generated.json index 7e8782b5476..6874e585df7 100644 --- a/service/ec2/generated.json +++ b/service/ec2/generated.json @@ -30,6 +30,7 @@ "api_op_AssociateEnclaveCertificateIamRole.go", "api_op_AssociateIamInstanceProfile.go", "api_op_AssociateInstanceEventWindow.go", + "api_op_AssociateIpamResourceDiscovery.go", "api_op_AssociateRouteTable.go", "api_op_AssociateSubnetCidrBlock.go", "api_op_AssociateTransitGatewayMulticastDomain.go", @@ -83,6 +84,7 @@ "api_op_CreateInternetGateway.go", "api_op_CreateIpam.go", "api_op_CreateIpamPool.go", + "api_op_CreateIpamResourceDiscovery.go", "api_op_CreateIpamScope.go", "api_op_CreateKeyPair.go", "api_op_CreateLaunchTemplate.go", @@ -157,6 +159,7 @@ "api_op_DeleteInternetGateway.go", "api_op_DeleteIpam.go", "api_op_DeleteIpamPool.go", + "api_op_DeleteIpamResourceDiscovery.go", "api_op_DeleteIpamScope.go", "api_op_DeleteKeyPair.go", "api_op_DeleteLaunchTemplate.go", @@ -275,6 +278,8 @@ "api_op_DescribeInstances.go", "api_op_DescribeInternetGateways.go", "api_op_DescribeIpamPools.go", + "api_op_DescribeIpamResourceDiscoveries.go", + "api_op_DescribeIpamResourceDiscoveryAssociations.go", "api_op_DescribeIpamScopes.go", "api_op_DescribeIpams.go", "api_op_DescribeIpv6Pools.go", @@ -386,6 +391,7 @@ "api_op_DisassociateEnclaveCertificateIamRole.go", "api_op_DisassociateIamInstanceProfile.go", "api_op_DisassociateInstanceEventWindow.go", + "api_op_DisassociateIpamResourceDiscovery.go", "api_op_DisassociateRouteTable.go", "api_op_DisassociateSubnetCidrBlock.go", "api_op_DisassociateTransitGatewayMulticastDomain.go", @@ -427,6 +433,8 @@ "api_op_GetInstanceTypesFromInstanceRequirements.go", "api_op_GetInstanceUefiData.go", "api_op_GetIpamAddressHistory.go", + "api_op_GetIpamDiscoveredAccounts.go", + "api_op_GetIpamDiscoveredResourceCidrs.go", "api_op_GetIpamPoolAllocations.go", "api_op_GetIpamPoolCidrs.go", "api_op_GetIpamResourceCidrs.go", @@ -483,6 +491,7 @@ "api_op_ModifyIpam.go", "api_op_ModifyIpamPool.go", "api_op_ModifyIpamResourceCidr.go", + "api_op_ModifyIpamResourceDiscovery.go", "api_op_ModifyIpamScope.go", "api_op_ModifyLaunchTemplate.go", "api_op_ModifyLocalGatewayRoute.go", diff --git a/service/ec2/serializers.go b/service/ec2/serializers.go index 08bae41022f..82f3223b6d1 100644 --- a/service/ec2/serializers.go +++ b/service/ec2/serializers.go @@ -1297,6 +1297,70 @@ func (m *awsEc2query_serializeOpAssociateInstanceEventWindow) HandleSerialize(ct return next.HandleSerialize(ctx, in) } +type awsEc2query_serializeOpAssociateIpamResourceDiscovery struct { +} + +func (*awsEc2query_serializeOpAssociateIpamResourceDiscovery) ID() string { + return "OperationSerializer" +} + +func (m *awsEc2query_serializeOpAssociateIpamResourceDiscovery) 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.(*AssociateIpamResourceDiscoveryInput) + _ = input + if !ok { + return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} + } + + operationPath := "/" + if len(request.Request.URL.Path) == 0 { + request.Request.URL.Path = operationPath + } else { + request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath) + if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' { + request.Request.URL.Path += "/" + } + } + request.Request.Method = "POST" + httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) + if err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") + + bodyWriter := bytes.NewBuffer(nil) + bodyEncoder := query.NewEncoder(bodyWriter) + body := bodyEncoder.Object() + body.Key("Action").String("AssociateIpamResourceDiscovery") + body.Key("Version").String("2016-11-15") + + if err := awsEc2query_serializeOpDocumentAssociateIpamResourceDiscoveryInput(input, bodyEncoder.Value); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + err = bodyEncoder.Encode() + if err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + in.Request = request + + return next.HandleSerialize(ctx, in) +} + type awsEc2query_serializeOpAssociateRouteTable struct { } @@ -4625,6 +4689,70 @@ func (m *awsEc2query_serializeOpCreateIpamPool) HandleSerialize(ctx context.Cont return next.HandleSerialize(ctx, in) } +type awsEc2query_serializeOpCreateIpamResourceDiscovery struct { +} + +func (*awsEc2query_serializeOpCreateIpamResourceDiscovery) ID() string { + return "OperationSerializer" +} + +func (m *awsEc2query_serializeOpCreateIpamResourceDiscovery) 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.(*CreateIpamResourceDiscoveryInput) + _ = input + if !ok { + return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} + } + + operationPath := "/" + if len(request.Request.URL.Path) == 0 { + request.Request.URL.Path = operationPath + } else { + request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath) + if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' { + request.Request.URL.Path += "/" + } + } + request.Request.Method = "POST" + httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) + if err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") + + bodyWriter := bytes.NewBuffer(nil) + bodyEncoder := query.NewEncoder(bodyWriter) + body := bodyEncoder.Object() + body.Key("Action").String("CreateIpamResourceDiscovery") + body.Key("Version").String("2016-11-15") + + if err := awsEc2query_serializeOpDocumentCreateIpamResourceDiscoveryInput(input, bodyEncoder.Value); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + err = bodyEncoder.Encode() + if err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + in.Request = request + + return next.HandleSerialize(ctx, in) +} + type awsEc2query_serializeOpCreateIpamScope struct { } @@ -9361,6 +9489,70 @@ func (m *awsEc2query_serializeOpDeleteIpamPool) HandleSerialize(ctx context.Cont return next.HandleSerialize(ctx, in) } +type awsEc2query_serializeOpDeleteIpamResourceDiscovery struct { +} + +func (*awsEc2query_serializeOpDeleteIpamResourceDiscovery) ID() string { + return "OperationSerializer" +} + +func (m *awsEc2query_serializeOpDeleteIpamResourceDiscovery) 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.(*DeleteIpamResourceDiscoveryInput) + _ = input + if !ok { + return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} + } + + operationPath := "/" + if len(request.Request.URL.Path) == 0 { + request.Request.URL.Path = operationPath + } else { + request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath) + if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' { + request.Request.URL.Path += "/" + } + } + request.Request.Method = "POST" + httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) + if err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") + + bodyWriter := bytes.NewBuffer(nil) + bodyEncoder := query.NewEncoder(bodyWriter) + body := bodyEncoder.Object() + body.Key("Action").String("DeleteIpamResourceDiscovery") + body.Key("Version").String("2016-11-15") + + if err := awsEc2query_serializeOpDocumentDeleteIpamResourceDiscoveryInput(input, bodyEncoder.Value); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + err = bodyEncoder.Encode() + if err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + in.Request = request + + return next.HandleSerialize(ctx, in) +} + type awsEc2query_serializeOpDeleteIpamScope struct { } @@ -16913,14 +17105,14 @@ func (m *awsEc2query_serializeOpDescribeIpamPools) HandleSerialize(ctx context.C return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpDescribeIpams struct { +type awsEc2query_serializeOpDescribeIpamResourceDiscoveries struct { } -func (*awsEc2query_serializeOpDescribeIpams) ID() string { +func (*awsEc2query_serializeOpDescribeIpamResourceDiscoveries) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpDescribeIpams) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDescribeIpamResourceDiscoveries) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { request, ok := in.Request.(*smithyhttp.Request) @@ -16928,7 +17120,7 @@ func (m *awsEc2query_serializeOpDescribeIpams) HandleSerialize(ctx context.Conte return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DescribeIpamsInput) + input, ok := in.Parameters.(*DescribeIpamResourceDiscoveriesInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -16953,10 +17145,10 @@ func (m *awsEc2query_serializeOpDescribeIpams) HandleSerialize(ctx context.Conte bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("DescribeIpams") + body.Key("Action").String("DescribeIpamResourceDiscoveries") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentDescribeIpamsInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentDescribeIpamResourceDiscoveriesInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -16977,14 +17169,14 @@ func (m *awsEc2query_serializeOpDescribeIpams) HandleSerialize(ctx context.Conte return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpDescribeIpamScopes struct { +type awsEc2query_serializeOpDescribeIpamResourceDiscoveryAssociations struct { } -func (*awsEc2query_serializeOpDescribeIpamScopes) ID() string { +func (*awsEc2query_serializeOpDescribeIpamResourceDiscoveryAssociations) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpDescribeIpamScopes) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDescribeIpamResourceDiscoveryAssociations) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { request, ok := in.Request.(*smithyhttp.Request) @@ -16992,7 +17184,7 @@ func (m *awsEc2query_serializeOpDescribeIpamScopes) HandleSerialize(ctx context. return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DescribeIpamScopesInput) + input, ok := in.Parameters.(*DescribeIpamResourceDiscoveryAssociationsInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -17017,10 +17209,10 @@ func (m *awsEc2query_serializeOpDescribeIpamScopes) HandleSerialize(ctx context. bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("DescribeIpamScopes") + body.Key("Action").String("DescribeIpamResourceDiscoveryAssociations") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentDescribeIpamScopesInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentDescribeIpamResourceDiscoveryAssociationsInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -17041,14 +17233,14 @@ func (m *awsEc2query_serializeOpDescribeIpamScopes) HandleSerialize(ctx context. return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpDescribeIpv6Pools struct { +type awsEc2query_serializeOpDescribeIpams struct { } -func (*awsEc2query_serializeOpDescribeIpv6Pools) ID() string { +func (*awsEc2query_serializeOpDescribeIpams) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpDescribeIpv6Pools) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDescribeIpams) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { request, ok := in.Request.(*smithyhttp.Request) @@ -17056,7 +17248,7 @@ func (m *awsEc2query_serializeOpDescribeIpv6Pools) HandleSerialize(ctx context.C return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DescribeIpv6PoolsInput) + input, ok := in.Parameters.(*DescribeIpamsInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -17081,10 +17273,10 @@ func (m *awsEc2query_serializeOpDescribeIpv6Pools) HandleSerialize(ctx context.C bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("DescribeIpv6Pools") + body.Key("Action").String("DescribeIpams") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentDescribeIpv6PoolsInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentDescribeIpamsInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -17105,14 +17297,14 @@ func (m *awsEc2query_serializeOpDescribeIpv6Pools) HandleSerialize(ctx context.C return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpDescribeKeyPairs struct { +type awsEc2query_serializeOpDescribeIpamScopes struct { } -func (*awsEc2query_serializeOpDescribeKeyPairs) ID() string { +func (*awsEc2query_serializeOpDescribeIpamScopes) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpDescribeKeyPairs) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDescribeIpamScopes) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { request, ok := in.Request.(*smithyhttp.Request) @@ -17120,7 +17312,7 @@ func (m *awsEc2query_serializeOpDescribeKeyPairs) HandleSerialize(ctx context.Co return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DescribeKeyPairsInput) + input, ok := in.Parameters.(*DescribeIpamScopesInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -17145,10 +17337,10 @@ func (m *awsEc2query_serializeOpDescribeKeyPairs) HandleSerialize(ctx context.Co bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("DescribeKeyPairs") + body.Key("Action").String("DescribeIpamScopes") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentDescribeKeyPairsInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentDescribeIpamScopesInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -17169,14 +17361,14 @@ func (m *awsEc2query_serializeOpDescribeKeyPairs) HandleSerialize(ctx context.Co return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpDescribeLaunchTemplates struct { +type awsEc2query_serializeOpDescribeIpv6Pools struct { } -func (*awsEc2query_serializeOpDescribeLaunchTemplates) ID() string { +func (*awsEc2query_serializeOpDescribeIpv6Pools) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpDescribeLaunchTemplates) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDescribeIpv6Pools) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { request, ok := in.Request.(*smithyhttp.Request) @@ -17184,7 +17376,7 @@ func (m *awsEc2query_serializeOpDescribeLaunchTemplates) HandleSerialize(ctx con return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DescribeLaunchTemplatesInput) + input, ok := in.Parameters.(*DescribeIpv6PoolsInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -17209,10 +17401,10 @@ func (m *awsEc2query_serializeOpDescribeLaunchTemplates) HandleSerialize(ctx con bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("DescribeLaunchTemplates") + body.Key("Action").String("DescribeIpv6Pools") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentDescribeLaunchTemplatesInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentDescribeIpv6PoolsInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -17233,14 +17425,14 @@ func (m *awsEc2query_serializeOpDescribeLaunchTemplates) HandleSerialize(ctx con return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpDescribeLaunchTemplateVersions struct { +type awsEc2query_serializeOpDescribeKeyPairs struct { } -func (*awsEc2query_serializeOpDescribeLaunchTemplateVersions) ID() string { +func (*awsEc2query_serializeOpDescribeKeyPairs) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpDescribeLaunchTemplateVersions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDescribeKeyPairs) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { request, ok := in.Request.(*smithyhttp.Request) @@ -17248,7 +17440,7 @@ func (m *awsEc2query_serializeOpDescribeLaunchTemplateVersions) HandleSerialize( return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DescribeLaunchTemplateVersionsInput) + input, ok := in.Parameters.(*DescribeKeyPairsInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -17273,10 +17465,10 @@ func (m *awsEc2query_serializeOpDescribeLaunchTemplateVersions) HandleSerialize( bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("DescribeLaunchTemplateVersions") + body.Key("Action").String("DescribeKeyPairs") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentDescribeLaunchTemplateVersionsInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentDescribeKeyPairsInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -17297,14 +17489,14 @@ func (m *awsEc2query_serializeOpDescribeLaunchTemplateVersions) HandleSerialize( return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpDescribeLocalGatewayRouteTables struct { +type awsEc2query_serializeOpDescribeLaunchTemplates struct { } -func (*awsEc2query_serializeOpDescribeLocalGatewayRouteTables) ID() string { +func (*awsEc2query_serializeOpDescribeLaunchTemplates) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpDescribeLocalGatewayRouteTables) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDescribeLaunchTemplates) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { request, ok := in.Request.(*smithyhttp.Request) @@ -17312,7 +17504,7 @@ func (m *awsEc2query_serializeOpDescribeLocalGatewayRouteTables) HandleSerialize return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DescribeLocalGatewayRouteTablesInput) + input, ok := in.Parameters.(*DescribeLaunchTemplatesInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -17337,10 +17529,10 @@ func (m *awsEc2query_serializeOpDescribeLocalGatewayRouteTables) HandleSerialize bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("DescribeLocalGatewayRouteTables") + body.Key("Action").String("DescribeLaunchTemplates") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentDescribeLocalGatewayRouteTablesInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentDescribeLaunchTemplatesInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -17361,14 +17553,14 @@ func (m *awsEc2query_serializeOpDescribeLocalGatewayRouteTables) HandleSerialize return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpDescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociations struct { +type awsEc2query_serializeOpDescribeLaunchTemplateVersions struct { } -func (*awsEc2query_serializeOpDescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociations) ID() string { +func (*awsEc2query_serializeOpDescribeLaunchTemplateVersions) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpDescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociations) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDescribeLaunchTemplateVersions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { request, ok := in.Request.(*smithyhttp.Request) @@ -17376,7 +17568,7 @@ func (m *awsEc2query_serializeOpDescribeLocalGatewayRouteTableVirtualInterfaceGr return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsInput) + input, ok := in.Parameters.(*DescribeLaunchTemplateVersionsInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -17401,10 +17593,10 @@ func (m *awsEc2query_serializeOpDescribeLocalGatewayRouteTableVirtualInterfaceGr bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociations") + body.Key("Action").String("DescribeLaunchTemplateVersions") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentDescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentDescribeLaunchTemplateVersionsInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -17425,14 +17617,14 @@ func (m *awsEc2query_serializeOpDescribeLocalGatewayRouteTableVirtualInterfaceGr return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpDescribeLocalGatewayRouteTableVpcAssociations struct { +type awsEc2query_serializeOpDescribeLocalGatewayRouteTables struct { } -func (*awsEc2query_serializeOpDescribeLocalGatewayRouteTableVpcAssociations) ID() string { +func (*awsEc2query_serializeOpDescribeLocalGatewayRouteTables) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpDescribeLocalGatewayRouteTableVpcAssociations) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDescribeLocalGatewayRouteTables) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { request, ok := in.Request.(*smithyhttp.Request) @@ -17440,7 +17632,135 @@ func (m *awsEc2query_serializeOpDescribeLocalGatewayRouteTableVpcAssociations) H return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DescribeLocalGatewayRouteTableVpcAssociationsInput) + input, ok := in.Parameters.(*DescribeLocalGatewayRouteTablesInput) + _ = input + if !ok { + return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} + } + + operationPath := "/" + if len(request.Request.URL.Path) == 0 { + request.Request.URL.Path = operationPath + } else { + request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath) + if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' { + request.Request.URL.Path += "/" + } + } + request.Request.Method = "POST" + httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) + if err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") + + bodyWriter := bytes.NewBuffer(nil) + bodyEncoder := query.NewEncoder(bodyWriter) + body := bodyEncoder.Object() + body.Key("Action").String("DescribeLocalGatewayRouteTables") + body.Key("Version").String("2016-11-15") + + if err := awsEc2query_serializeOpDocumentDescribeLocalGatewayRouteTablesInput(input, bodyEncoder.Value); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + err = bodyEncoder.Encode() + if err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + in.Request = request + + return next.HandleSerialize(ctx, in) +} + +type awsEc2query_serializeOpDescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociations struct { +} + +func (*awsEc2query_serializeOpDescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociations) ID() string { + return "OperationSerializer" +} + +func (m *awsEc2query_serializeOpDescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociations) 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.(*DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsInput) + _ = input + if !ok { + return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} + } + + operationPath := "/" + if len(request.Request.URL.Path) == 0 { + request.Request.URL.Path = operationPath + } else { + request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath) + if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' { + request.Request.URL.Path += "/" + } + } + request.Request.Method = "POST" + httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) + if err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") + + bodyWriter := bytes.NewBuffer(nil) + bodyEncoder := query.NewEncoder(bodyWriter) + body := bodyEncoder.Object() + body.Key("Action").String("DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociations") + body.Key("Version").String("2016-11-15") + + if err := awsEc2query_serializeOpDocumentDescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsInput(input, bodyEncoder.Value); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + err = bodyEncoder.Encode() + if err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + in.Request = request + + return next.HandleSerialize(ctx, in) +} + +type awsEc2query_serializeOpDescribeLocalGatewayRouteTableVpcAssociations struct { +} + +func (*awsEc2query_serializeOpDescribeLocalGatewayRouteTableVpcAssociations) ID() string { + return "OperationSerializer" +} + +func (m *awsEc2query_serializeOpDescribeLocalGatewayRouteTableVpcAssociations) 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.(*DescribeLocalGatewayRouteTableVpcAssociationsInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -24017,6 +24337,70 @@ func (m *awsEc2query_serializeOpDisassociateInstanceEventWindow) HandleSerialize return next.HandleSerialize(ctx, in) } +type awsEc2query_serializeOpDisassociateIpamResourceDiscovery struct { +} + +func (*awsEc2query_serializeOpDisassociateIpamResourceDiscovery) ID() string { + return "OperationSerializer" +} + +func (m *awsEc2query_serializeOpDisassociateIpamResourceDiscovery) 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.(*DisassociateIpamResourceDiscoveryInput) + _ = input + if !ok { + return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} + } + + operationPath := "/" + if len(request.Request.URL.Path) == 0 { + request.Request.URL.Path = operationPath + } else { + request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath) + if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' { + request.Request.URL.Path += "/" + } + } + request.Request.Method = "POST" + httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) + if err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") + + bodyWriter := bytes.NewBuffer(nil) + bodyEncoder := query.NewEncoder(bodyWriter) + body := bodyEncoder.Object() + body.Key("Action").String("DisassociateIpamResourceDiscovery") + body.Key("Version").String("2016-11-15") + + if err := awsEc2query_serializeOpDocumentDisassociateIpamResourceDiscoveryInput(input, bodyEncoder.Value); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + err = bodyEncoder.Encode() + if err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + in.Request = request + + return next.HandleSerialize(ctx, in) +} + type awsEc2query_serializeOpDisassociateRouteTable struct { } @@ -26641,14 +27025,14 @@ func (m *awsEc2query_serializeOpGetIpamAddressHistory) HandleSerialize(ctx conte return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpGetIpamPoolAllocations struct { +type awsEc2query_serializeOpGetIpamDiscoveredAccounts struct { } -func (*awsEc2query_serializeOpGetIpamPoolAllocations) ID() string { +func (*awsEc2query_serializeOpGetIpamDiscoveredAccounts) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpGetIpamPoolAllocations) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpGetIpamDiscoveredAccounts) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { request, ok := in.Request.(*smithyhttp.Request) @@ -26656,7 +27040,7 @@ func (m *awsEc2query_serializeOpGetIpamPoolAllocations) HandleSerialize(ctx cont return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*GetIpamPoolAllocationsInput) + input, ok := in.Parameters.(*GetIpamDiscoveredAccountsInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -26681,10 +27065,10 @@ func (m *awsEc2query_serializeOpGetIpamPoolAllocations) HandleSerialize(ctx cont bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("GetIpamPoolAllocations") + body.Key("Action").String("GetIpamDiscoveredAccounts") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentGetIpamPoolAllocationsInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentGetIpamDiscoveredAccountsInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -26705,14 +27089,14 @@ func (m *awsEc2query_serializeOpGetIpamPoolAllocations) HandleSerialize(ctx cont return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpGetIpamPoolCidrs struct { +type awsEc2query_serializeOpGetIpamDiscoveredResourceCidrs struct { } -func (*awsEc2query_serializeOpGetIpamPoolCidrs) ID() string { +func (*awsEc2query_serializeOpGetIpamDiscoveredResourceCidrs) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpGetIpamPoolCidrs) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpGetIpamDiscoveredResourceCidrs) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { request, ok := in.Request.(*smithyhttp.Request) @@ -26720,7 +27104,7 @@ func (m *awsEc2query_serializeOpGetIpamPoolCidrs) HandleSerialize(ctx context.Co return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*GetIpamPoolCidrsInput) + input, ok := in.Parameters.(*GetIpamDiscoveredResourceCidrsInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -26745,10 +27129,10 @@ func (m *awsEc2query_serializeOpGetIpamPoolCidrs) HandleSerialize(ctx context.Co bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("GetIpamPoolCidrs") + body.Key("Action").String("GetIpamDiscoveredResourceCidrs") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentGetIpamPoolCidrsInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentGetIpamDiscoveredResourceCidrsInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -26769,14 +27153,14 @@ func (m *awsEc2query_serializeOpGetIpamPoolCidrs) HandleSerialize(ctx context.Co return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpGetIpamResourceCidrs struct { +type awsEc2query_serializeOpGetIpamPoolAllocations struct { } -func (*awsEc2query_serializeOpGetIpamResourceCidrs) ID() string { +func (*awsEc2query_serializeOpGetIpamPoolAllocations) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpGetIpamResourceCidrs) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpGetIpamPoolAllocations) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { request, ok := in.Request.(*smithyhttp.Request) @@ -26784,7 +27168,7 @@ func (m *awsEc2query_serializeOpGetIpamResourceCidrs) HandleSerialize(ctx contex return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*GetIpamResourceCidrsInput) + input, ok := in.Parameters.(*GetIpamPoolAllocationsInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -26809,10 +27193,10 @@ func (m *awsEc2query_serializeOpGetIpamResourceCidrs) HandleSerialize(ctx contex bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("GetIpamResourceCidrs") + body.Key("Action").String("GetIpamPoolAllocations") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentGetIpamResourceCidrsInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentGetIpamPoolAllocationsInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -26833,14 +27217,14 @@ func (m *awsEc2query_serializeOpGetIpamResourceCidrs) HandleSerialize(ctx contex return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpGetLaunchTemplateData struct { +type awsEc2query_serializeOpGetIpamPoolCidrs struct { } -func (*awsEc2query_serializeOpGetLaunchTemplateData) ID() string { +func (*awsEc2query_serializeOpGetIpamPoolCidrs) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpGetLaunchTemplateData) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpGetIpamPoolCidrs) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { request, ok := in.Request.(*smithyhttp.Request) @@ -26848,7 +27232,7 @@ func (m *awsEc2query_serializeOpGetLaunchTemplateData) HandleSerialize(ctx conte return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*GetLaunchTemplateDataInput) + input, ok := in.Parameters.(*GetIpamPoolCidrsInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -26873,10 +27257,10 @@ func (m *awsEc2query_serializeOpGetLaunchTemplateData) HandleSerialize(ctx conte bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("GetLaunchTemplateData") + body.Key("Action").String("GetIpamPoolCidrs") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentGetLaunchTemplateDataInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentGetIpamPoolCidrsInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -26897,14 +27281,14 @@ func (m *awsEc2query_serializeOpGetLaunchTemplateData) HandleSerialize(ctx conte return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpGetManagedPrefixListAssociations struct { +type awsEc2query_serializeOpGetIpamResourceCidrs struct { } -func (*awsEc2query_serializeOpGetManagedPrefixListAssociations) ID() string { +func (*awsEc2query_serializeOpGetIpamResourceCidrs) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpGetManagedPrefixListAssociations) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpGetIpamResourceCidrs) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { request, ok := in.Request.(*smithyhttp.Request) @@ -26912,7 +27296,7 @@ func (m *awsEc2query_serializeOpGetManagedPrefixListAssociations) HandleSerializ return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*GetManagedPrefixListAssociationsInput) + input, ok := in.Parameters.(*GetIpamResourceCidrsInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -26937,10 +27321,10 @@ func (m *awsEc2query_serializeOpGetManagedPrefixListAssociations) HandleSerializ bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("GetManagedPrefixListAssociations") + body.Key("Action").String("GetIpamResourceCidrs") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentGetManagedPrefixListAssociationsInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentGetIpamResourceCidrsInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -26961,14 +27345,14 @@ func (m *awsEc2query_serializeOpGetManagedPrefixListAssociations) HandleSerializ return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpGetManagedPrefixListEntries struct { +type awsEc2query_serializeOpGetLaunchTemplateData struct { } -func (*awsEc2query_serializeOpGetManagedPrefixListEntries) ID() string { +func (*awsEc2query_serializeOpGetLaunchTemplateData) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpGetManagedPrefixListEntries) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpGetLaunchTemplateData) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { request, ok := in.Request.(*smithyhttp.Request) @@ -26976,7 +27360,7 @@ func (m *awsEc2query_serializeOpGetManagedPrefixListEntries) HandleSerialize(ctx return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*GetManagedPrefixListEntriesInput) + input, ok := in.Parameters.(*GetLaunchTemplateDataInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -27001,10 +27385,10 @@ func (m *awsEc2query_serializeOpGetManagedPrefixListEntries) HandleSerialize(ctx bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("GetManagedPrefixListEntries") + body.Key("Action").String("GetLaunchTemplateData") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentGetManagedPrefixListEntriesInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentGetLaunchTemplateDataInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -27025,14 +27409,14 @@ func (m *awsEc2query_serializeOpGetManagedPrefixListEntries) HandleSerialize(ctx return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpGetNetworkInsightsAccessScopeAnalysisFindings struct { +type awsEc2query_serializeOpGetManagedPrefixListAssociations struct { } -func (*awsEc2query_serializeOpGetNetworkInsightsAccessScopeAnalysisFindings) ID() string { +func (*awsEc2query_serializeOpGetManagedPrefixListAssociations) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpGetNetworkInsightsAccessScopeAnalysisFindings) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpGetManagedPrefixListAssociations) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { request, ok := in.Request.(*smithyhttp.Request) @@ -27040,7 +27424,7 @@ func (m *awsEc2query_serializeOpGetNetworkInsightsAccessScopeAnalysisFindings) H return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*GetNetworkInsightsAccessScopeAnalysisFindingsInput) + input, ok := in.Parameters.(*GetManagedPrefixListAssociationsInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -27065,10 +27449,10 @@ func (m *awsEc2query_serializeOpGetNetworkInsightsAccessScopeAnalysisFindings) H bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("GetNetworkInsightsAccessScopeAnalysisFindings") + body.Key("Action").String("GetManagedPrefixListAssociations") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentGetNetworkInsightsAccessScopeAnalysisFindingsInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentGetManagedPrefixListAssociationsInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -27089,14 +27473,14 @@ func (m *awsEc2query_serializeOpGetNetworkInsightsAccessScopeAnalysisFindings) H return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpGetNetworkInsightsAccessScopeContent struct { +type awsEc2query_serializeOpGetManagedPrefixListEntries struct { } -func (*awsEc2query_serializeOpGetNetworkInsightsAccessScopeContent) ID() string { +func (*awsEc2query_serializeOpGetManagedPrefixListEntries) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpGetNetworkInsightsAccessScopeContent) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpGetManagedPrefixListEntries) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { request, ok := in.Request.(*smithyhttp.Request) @@ -27104,7 +27488,135 @@ func (m *awsEc2query_serializeOpGetNetworkInsightsAccessScopeContent) HandleSeri return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*GetNetworkInsightsAccessScopeContentInput) + input, ok := in.Parameters.(*GetManagedPrefixListEntriesInput) + _ = input + if !ok { + return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} + } + + operationPath := "/" + if len(request.Request.URL.Path) == 0 { + request.Request.URL.Path = operationPath + } else { + request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath) + if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' { + request.Request.URL.Path += "/" + } + } + request.Request.Method = "POST" + httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) + if err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") + + bodyWriter := bytes.NewBuffer(nil) + bodyEncoder := query.NewEncoder(bodyWriter) + body := bodyEncoder.Object() + body.Key("Action").String("GetManagedPrefixListEntries") + body.Key("Version").String("2016-11-15") + + if err := awsEc2query_serializeOpDocumentGetManagedPrefixListEntriesInput(input, bodyEncoder.Value); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + err = bodyEncoder.Encode() + if err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + in.Request = request + + return next.HandleSerialize(ctx, in) +} + +type awsEc2query_serializeOpGetNetworkInsightsAccessScopeAnalysisFindings struct { +} + +func (*awsEc2query_serializeOpGetNetworkInsightsAccessScopeAnalysisFindings) ID() string { + return "OperationSerializer" +} + +func (m *awsEc2query_serializeOpGetNetworkInsightsAccessScopeAnalysisFindings) 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.(*GetNetworkInsightsAccessScopeAnalysisFindingsInput) + _ = input + if !ok { + return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} + } + + operationPath := "/" + if len(request.Request.URL.Path) == 0 { + request.Request.URL.Path = operationPath + } else { + request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath) + if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' { + request.Request.URL.Path += "/" + } + } + request.Request.Method = "POST" + httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) + if err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") + + bodyWriter := bytes.NewBuffer(nil) + bodyEncoder := query.NewEncoder(bodyWriter) + body := bodyEncoder.Object() + body.Key("Action").String("GetNetworkInsightsAccessScopeAnalysisFindings") + body.Key("Version").String("2016-11-15") + + if err := awsEc2query_serializeOpDocumentGetNetworkInsightsAccessScopeAnalysisFindingsInput(input, bodyEncoder.Value); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + err = bodyEncoder.Encode() + if err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + in.Request = request + + return next.HandleSerialize(ctx, in) +} + +type awsEc2query_serializeOpGetNetworkInsightsAccessScopeContent struct { +} + +func (*awsEc2query_serializeOpGetNetworkInsightsAccessScopeContent) ID() string { + return "OperationSerializer" +} + +func (m *awsEc2query_serializeOpGetNetworkInsightsAccessScopeContent) 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.(*GetNetworkInsightsAccessScopeContentInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -30225,6 +30737,70 @@ func (m *awsEc2query_serializeOpModifyIpamResourceCidr) HandleSerialize(ctx cont return next.HandleSerialize(ctx, in) } +type awsEc2query_serializeOpModifyIpamResourceDiscovery struct { +} + +func (*awsEc2query_serializeOpModifyIpamResourceDiscovery) ID() string { + return "OperationSerializer" +} + +func (m *awsEc2query_serializeOpModifyIpamResourceDiscovery) 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.(*ModifyIpamResourceDiscoveryInput) + _ = input + if !ok { + return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} + } + + operationPath := "/" + if len(request.Request.URL.Path) == 0 { + request.Request.URL.Path = operationPath + } else { + request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath) + if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' { + request.Request.URL.Path += "/" + } + } + request.Request.Method = "POST" + httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) + if err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") + + bodyWriter := bytes.NewBuffer(nil) + bodyEncoder := query.NewEncoder(bodyWriter) + body := bodyEncoder.Object() + body.Key("Action").String("ModifyIpamResourceDiscovery") + body.Key("Version").String("2016-11-15") + + if err := awsEc2query_serializeOpDocumentModifyIpamResourceDiscoveryInput(input, bodyEncoder.Value); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + err = bodyEncoder.Encode() + if err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + in.Request = request + + return next.HandleSerialize(ctx, in) +} + type awsEc2query_serializeOpModifyIpamScope struct { } @@ -46874,6 +47450,40 @@ func awsEc2query_serializeOpDocumentAssociateInstanceEventWindowInput(v *Associa return nil } +func awsEc2query_serializeOpDocumentAssociateIpamResourceDiscoveryInput(v *AssociateIpamResourceDiscoveryInput, value query.Value) error { + object := value.Object() + _ = object + + if v.ClientToken != nil { + objectKey := object.Key("ClientToken") + objectKey.String(*v.ClientToken) + } + + if v.DryRun != nil { + objectKey := object.Key("DryRun") + objectKey.Boolean(*v.DryRun) + } + + if v.IpamId != nil { + objectKey := object.Key("IpamId") + objectKey.String(*v.IpamId) + } + + if v.IpamResourceDiscoveryId != nil { + objectKey := object.Key("IpamResourceDiscoveryId") + objectKey.String(*v.IpamResourceDiscoveryId) + } + + if v.TagSpecifications != nil { + objectKey := object.FlatKey("TagSpecification") + if err := awsEc2query_serializeDocumentTagSpecificationList(v.TagSpecifications, objectKey); err != nil { + return err + } + } + + return nil +} + func awsEc2query_serializeOpDocumentAssociateRouteTableInput(v *AssociateRouteTableInput, value query.Value) error { object := value.Object() _ = object @@ -48763,6 +49373,11 @@ func awsEc2query_serializeOpDocumentCreateIpamPoolInput(v *CreateIpamPoolInput, objectKey.String(*v.Locale) } + if len(v.PublicIpSource) > 0 { + objectKey := object.Key("PublicIpSource") + objectKey.String(string(v.PublicIpSource)) + } + if v.PubliclyAdvertisable != nil { objectKey := object.Key("PubliclyAdvertisable") objectKey.Boolean(*v.PubliclyAdvertisable) @@ -48783,6 +49398,42 @@ func awsEc2query_serializeOpDocumentCreateIpamPoolInput(v *CreateIpamPoolInput, return nil } +func awsEc2query_serializeOpDocumentCreateIpamResourceDiscoveryInput(v *CreateIpamResourceDiscoveryInput, value query.Value) error { + object := value.Object() + _ = object + + if v.ClientToken != nil { + objectKey := object.Key("ClientToken") + objectKey.String(*v.ClientToken) + } + + if v.Description != nil { + objectKey := object.Key("Description") + objectKey.String(*v.Description) + } + + if v.DryRun != nil { + objectKey := object.Key("DryRun") + objectKey.Boolean(*v.DryRun) + } + + if v.OperatingRegions != nil { + objectKey := object.FlatKey("OperatingRegion") + if err := awsEc2query_serializeDocumentAddIpamOperatingRegionSet(v.OperatingRegions, objectKey); err != nil { + return err + } + } + + if v.TagSpecifications != nil { + objectKey := object.FlatKey("TagSpecification") + if err := awsEc2query_serializeDocumentTagSpecificationList(v.TagSpecifications, objectKey); err != nil { + return err + } + } + + return nil +} + func awsEc2query_serializeOpDocumentCreateIpamScopeInput(v *CreateIpamScopeInput, value query.Value) error { object := value.Object() _ = object @@ -51547,6 +52198,23 @@ func awsEc2query_serializeOpDocumentDeleteIpamPoolInput(v *DeleteIpamPoolInput, return nil } +func awsEc2query_serializeOpDocumentDeleteIpamResourceDiscoveryInput(v *DeleteIpamResourceDiscoveryInput, value query.Value) error { + object := value.Object() + _ = object + + if v.DryRun != nil { + objectKey := object.Key("DryRun") + objectKey.Boolean(*v.DryRun) + } + + if v.IpamResourceDiscoveryId != nil { + objectKey := object.Key("IpamResourceDiscoveryId") + objectKey.String(*v.IpamResourceDiscoveryId) + } + + return nil +} + func awsEc2query_serializeOpDocumentDeleteIpamScopeInput(v *DeleteIpamScopeInput, value query.Value) error { object := value.Object() _ = object @@ -54494,6 +55162,78 @@ func awsEc2query_serializeOpDocumentDescribeIpamPoolsInput(v *DescribeIpamPoolsI return nil } +func awsEc2query_serializeOpDocumentDescribeIpamResourceDiscoveriesInput(v *DescribeIpamResourceDiscoveriesInput, value query.Value) error { + object := value.Object() + _ = object + + if v.DryRun != nil { + objectKey := object.Key("DryRun") + objectKey.Boolean(*v.DryRun) + } + + if v.Filters != nil { + objectKey := object.FlatKey("Filter") + if err := awsEc2query_serializeDocumentFilterList(v.Filters, objectKey); err != nil { + return err + } + } + + if v.IpamResourceDiscoveryIds != nil { + objectKey := object.FlatKey("IpamResourceDiscoveryId") + if err := awsEc2query_serializeDocumentValueStringList(v.IpamResourceDiscoveryIds, objectKey); err != nil { + return err + } + } + + if v.MaxResults != nil { + objectKey := object.Key("MaxResults") + objectKey.Integer(*v.MaxResults) + } + + if v.NextToken != nil { + objectKey := object.Key("NextToken") + objectKey.String(*v.NextToken) + } + + return nil +} + +func awsEc2query_serializeOpDocumentDescribeIpamResourceDiscoveryAssociationsInput(v *DescribeIpamResourceDiscoveryAssociationsInput, value query.Value) error { + object := value.Object() + _ = object + + if v.DryRun != nil { + objectKey := object.Key("DryRun") + objectKey.Boolean(*v.DryRun) + } + + if v.Filters != nil { + objectKey := object.FlatKey("Filter") + if err := awsEc2query_serializeDocumentFilterList(v.Filters, objectKey); err != nil { + return err + } + } + + if v.IpamResourceDiscoveryAssociationIds != nil { + objectKey := object.FlatKey("IpamResourceDiscoveryAssociationId") + if err := awsEc2query_serializeDocumentValueStringList(v.IpamResourceDiscoveryAssociationIds, objectKey); err != nil { + return err + } + } + + if v.MaxResults != nil { + objectKey := object.Key("MaxResults") + objectKey.Integer(*v.MaxResults) + } + + if v.NextToken != nil { + objectKey := object.Key("NextToken") + objectKey.String(*v.NextToken) + } + + return nil +} + func awsEc2query_serializeOpDocumentDescribeIpamScopesInput(v *DescribeIpamScopesInput, value query.Value) error { object := value.Object() _ = object @@ -58105,6 +58845,23 @@ func awsEc2query_serializeOpDocumentDisassociateInstanceEventWindowInput(v *Disa return nil } +func awsEc2query_serializeOpDocumentDisassociateIpamResourceDiscoveryInput(v *DisassociateIpamResourceDiscoveryInput, value query.Value) error { + object := value.Object() + _ = object + + if v.DryRun != nil { + objectKey := object.Key("DryRun") + objectKey.Boolean(*v.DryRun) + } + + if v.IpamResourceDiscoveryAssociationId != nil { + objectKey := object.Key("IpamResourceDiscoveryAssociationId") + objectKey.String(*v.IpamResourceDiscoveryAssociationId) + } + + return nil +} + func awsEc2query_serializeOpDocumentDisassociateRouteTableInput(v *DisassociateRouteTableInput, value query.Value) error { object := value.Object() _ = object @@ -59057,6 +59814,84 @@ func awsEc2query_serializeOpDocumentGetIpamAddressHistoryInput(v *GetIpamAddress return nil } +func awsEc2query_serializeOpDocumentGetIpamDiscoveredAccountsInput(v *GetIpamDiscoveredAccountsInput, value query.Value) error { + object := value.Object() + _ = object + + if v.DiscoveryRegion != nil { + objectKey := object.Key("DiscoveryRegion") + objectKey.String(*v.DiscoveryRegion) + } + + if v.DryRun != nil { + objectKey := object.Key("DryRun") + objectKey.Boolean(*v.DryRun) + } + + if v.Filters != nil { + objectKey := object.FlatKey("Filter") + if err := awsEc2query_serializeDocumentFilterList(v.Filters, objectKey); err != nil { + return err + } + } + + if v.IpamResourceDiscoveryId != nil { + objectKey := object.Key("IpamResourceDiscoveryId") + objectKey.String(*v.IpamResourceDiscoveryId) + } + + if v.MaxResults != nil { + objectKey := object.Key("MaxResults") + objectKey.Integer(*v.MaxResults) + } + + if v.NextToken != nil { + objectKey := object.Key("NextToken") + objectKey.String(*v.NextToken) + } + + return nil +} + +func awsEc2query_serializeOpDocumentGetIpamDiscoveredResourceCidrsInput(v *GetIpamDiscoveredResourceCidrsInput, value query.Value) error { + object := value.Object() + _ = object + + if v.DryRun != nil { + objectKey := object.Key("DryRun") + objectKey.Boolean(*v.DryRun) + } + + if v.Filters != nil { + objectKey := object.FlatKey("Filter") + if err := awsEc2query_serializeDocumentFilterList(v.Filters, objectKey); err != nil { + return err + } + } + + if v.IpamResourceDiscoveryId != nil { + objectKey := object.Key("IpamResourceDiscoveryId") + objectKey.String(*v.IpamResourceDiscoveryId) + } + + if v.MaxResults != nil { + objectKey := object.Key("MaxResults") + objectKey.Integer(*v.MaxResults) + } + + if v.NextToken != nil { + objectKey := object.Key("NextToken") + objectKey.String(*v.NextToken) + } + + if v.ResourceRegion != nil { + objectKey := object.Key("ResourceRegion") + objectKey.String(*v.ResourceRegion) + } + + return nil +} + func awsEc2query_serializeOpDocumentGetIpamPoolAllocationsInput(v *GetIpamPoolAllocationsInput, value query.Value) error { object := value.Object() _ = object @@ -61094,6 +61929,42 @@ func awsEc2query_serializeOpDocumentModifyIpamResourceCidrInput(v *ModifyIpamRes return nil } +func awsEc2query_serializeOpDocumentModifyIpamResourceDiscoveryInput(v *ModifyIpamResourceDiscoveryInput, value query.Value) error { + object := value.Object() + _ = object + + if v.AddOperatingRegions != nil { + objectKey := object.FlatKey("AddOperatingRegion") + if err := awsEc2query_serializeDocumentAddIpamOperatingRegionSet(v.AddOperatingRegions, objectKey); err != nil { + return err + } + } + + if v.Description != nil { + objectKey := object.Key("Description") + objectKey.String(*v.Description) + } + + if v.DryRun != nil { + objectKey := object.Key("DryRun") + objectKey.Boolean(*v.DryRun) + } + + if v.IpamResourceDiscoveryId != nil { + objectKey := object.Key("IpamResourceDiscoveryId") + objectKey.String(*v.IpamResourceDiscoveryId) + } + + if v.RemoveOperatingRegions != nil { + objectKey := object.FlatKey("RemoveOperatingRegion") + if err := awsEc2query_serializeDocumentRemoveIpamOperatingRegionSet(v.RemoveOperatingRegions, objectKey); err != nil { + return err + } + } + + return nil +} + func awsEc2query_serializeOpDocumentModifyIpamScopeInput(v *ModifyIpamScopeInput, value query.Value) error { object := value.Object() _ = object @@ -62673,6 +63544,11 @@ func awsEc2query_serializeOpDocumentProvisionIpamPoolCidrInput(v *ProvisionIpamP } } + if v.ClientToken != nil { + objectKey := object.Key("ClientToken") + objectKey.String(*v.ClientToken) + } + if v.DryRun != nil { objectKey := object.Key("DryRun") objectKey.Boolean(*v.DryRun) @@ -62683,6 +63559,11 @@ func awsEc2query_serializeOpDocumentProvisionIpamPoolCidrInput(v *ProvisionIpamP objectKey.String(*v.IpamPoolId) } + if v.NetmaskLength != nil { + objectKey := object.Key("NetmaskLength") + objectKey.Integer(*v.NetmaskLength) + } + return nil } diff --git a/service/ec2/types/enums.go b/service/ec2/types/enums.go index 43579cce7ac..12045d92ac7 100644 --- a/service/ec2/types/enums.go +++ b/service/ec2/types/enums.go @@ -4049,6 +4049,25 @@ func (IpamAddressHistoryResourceType) Values() []IpamAddressHistoryResourceType } } +type IpamAssociatedResourceDiscoveryStatus string + +// Enum values for IpamAssociatedResourceDiscoveryStatus +const ( + IpamAssociatedResourceDiscoveryStatusActive IpamAssociatedResourceDiscoveryStatus = "active" + IpamAssociatedResourceDiscoveryStatusNotFound IpamAssociatedResourceDiscoveryStatus = "not-found" +) + +// Values returns all known values for IpamAssociatedResourceDiscoveryStatus. 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 (IpamAssociatedResourceDiscoveryStatus) Values() []IpamAssociatedResourceDiscoveryStatus { + return []IpamAssociatedResourceDiscoveryStatus{ + "active", + "not-found", + } +} + type IpamComplianceStatus string // Enum values for IpamComplianceStatus @@ -4071,6 +4090,26 @@ func (IpamComplianceStatus) Values() []IpamComplianceStatus { } } +type IpamDiscoveryFailureCode string + +// Enum values for IpamDiscoveryFailureCode +const ( + IpamDiscoveryFailureCodeAssumeRoleFailure IpamDiscoveryFailureCode = "assume-role-failure" + IpamDiscoveryFailureCodeThrottlingFailure IpamDiscoveryFailureCode = "throttling-failure" + IpamDiscoveryFailureCodeUnauthorizedFailure IpamDiscoveryFailureCode = "unauthorized-failure" +) + +// Values returns all known values for IpamDiscoveryFailureCode. 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 (IpamDiscoveryFailureCode) Values() []IpamDiscoveryFailureCode { + return []IpamDiscoveryFailureCode{ + "assume-role-failure", + "throttling-failure", + "unauthorized-failure", + } +} + type IpamManagementState string // Enum values for IpamManagementState @@ -4155,6 +4194,7 @@ type IpamPoolCidrFailureCode string // Enum values for IpamPoolCidrFailureCode const ( IpamPoolCidrFailureCodeCidrNotAvailable IpamPoolCidrFailureCode = "cidr-not-available" + IpamPoolCidrFailureCodeLimitExceeded IpamPoolCidrFailureCode = "limit-exceeded" ) // Values returns all known values for IpamPoolCidrFailureCode. Note that this can @@ -4163,6 +4203,7 @@ const ( func (IpamPoolCidrFailureCode) Values() []IpamPoolCidrFailureCode { return []IpamPoolCidrFailureCode{ "cidr-not-available", + "limit-exceeded", } } @@ -4196,6 +4237,24 @@ func (IpamPoolCidrState) Values() []IpamPoolCidrState { } } +type IpamPoolPublicIpSource string + +// Enum values for IpamPoolPublicIpSource +const ( + IpamPoolPublicIpSourceAmazon IpamPoolPublicIpSource = "amazon" + IpamPoolPublicIpSourceByoip IpamPoolPublicIpSource = "byoip" +) + +// Values returns all known values for IpamPoolPublicIpSource. 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 (IpamPoolPublicIpSource) Values() []IpamPoolPublicIpSource { + return []IpamPoolPublicIpSource{ + "amazon", + "byoip", + } +} + type IpamPoolState string // Enum values for IpamPoolState @@ -4234,6 +4293,77 @@ func (IpamPoolState) Values() []IpamPoolState { } } +type IpamResourceDiscoveryAssociationState string + +// Enum values for IpamResourceDiscoveryAssociationState +const ( + IpamResourceDiscoveryAssociationStateAssociateInProgress IpamResourceDiscoveryAssociationState = "associate-in-progress" + IpamResourceDiscoveryAssociationStateAssociateComplete IpamResourceDiscoveryAssociationState = "associate-complete" + IpamResourceDiscoveryAssociationStateAssociateFailed IpamResourceDiscoveryAssociationState = "associate-failed" + IpamResourceDiscoveryAssociationStateDisassociateInProgress IpamResourceDiscoveryAssociationState = "disassociate-in-progress" + IpamResourceDiscoveryAssociationStateDisassociateComplete IpamResourceDiscoveryAssociationState = "disassociate-complete" + IpamResourceDiscoveryAssociationStateDisassociateFailed IpamResourceDiscoveryAssociationState = "disassociate-failed" + IpamResourceDiscoveryAssociationStateIsolateInProgress IpamResourceDiscoveryAssociationState = "isolate-in-progress" + IpamResourceDiscoveryAssociationStateIsolateComplete IpamResourceDiscoveryAssociationState = "isolate-complete" + IpamResourceDiscoveryAssociationStateRestoreInProgress IpamResourceDiscoveryAssociationState = "restore-in-progress" +) + +// Values returns all known values for IpamResourceDiscoveryAssociationState. 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 (IpamResourceDiscoveryAssociationState) Values() []IpamResourceDiscoveryAssociationState { + return []IpamResourceDiscoveryAssociationState{ + "associate-in-progress", + "associate-complete", + "associate-failed", + "disassociate-in-progress", + "disassociate-complete", + "disassociate-failed", + "isolate-in-progress", + "isolate-complete", + "restore-in-progress", + } +} + +type IpamResourceDiscoveryState string + +// Enum values for IpamResourceDiscoveryState +const ( + IpamResourceDiscoveryStateCreateInProgress IpamResourceDiscoveryState = "create-in-progress" + IpamResourceDiscoveryStateCreateComplete IpamResourceDiscoveryState = "create-complete" + IpamResourceDiscoveryStateCreateFailed IpamResourceDiscoveryState = "create-failed" + IpamResourceDiscoveryStateModifyInProgress IpamResourceDiscoveryState = "modify-in-progress" + IpamResourceDiscoveryStateModifyComplete IpamResourceDiscoveryState = "modify-complete" + IpamResourceDiscoveryStateModifyFailed IpamResourceDiscoveryState = "modify-failed" + IpamResourceDiscoveryStateDeleteInProgress IpamResourceDiscoveryState = "delete-in-progress" + IpamResourceDiscoveryStateDeleteComplete IpamResourceDiscoveryState = "delete-complete" + IpamResourceDiscoveryStateDeleteFailed IpamResourceDiscoveryState = "delete-failed" + IpamResourceDiscoveryStateIsolateInProgress IpamResourceDiscoveryState = "isolate-in-progress" + IpamResourceDiscoveryStateIsolateComplete IpamResourceDiscoveryState = "isolate-complete" + IpamResourceDiscoveryStateRestoreInProgress IpamResourceDiscoveryState = "restore-in-progress" +) + +// Values returns all known values for IpamResourceDiscoveryState. 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 (IpamResourceDiscoveryState) Values() []IpamResourceDiscoveryState { + return []IpamResourceDiscoveryState{ + "create-in-progress", + "create-complete", + "create-failed", + "modify-in-progress", + "modify-complete", + "modify-failed", + "delete-in-progress", + "delete-complete", + "delete-failed", + "isolate-in-progress", + "isolate-complete", + "restore-in-progress", + } +} + type IpamResourceType string // Enum values for IpamResourceType @@ -5667,6 +5797,8 @@ const ( ResourceTypeVerifiedAccessTrustProvider ResourceType = "verified-access-trust-provider" ResourceTypeVpnConnectionDeviceType ResourceType = "vpn-connection-device-type" ResourceTypeVpcBlockPublicAccessExclusion ResourceType = "vpc-block-public-access-exclusion" + ResourceTypeIpamResourceDiscovery ResourceType = "ipam-resource-discovery" + ResourceTypeIpamResourceDiscoveryAssociation ResourceType = "ipam-resource-discovery-association" ) // Values returns all known values for ResourceType. Note that this can be expanded @@ -5757,6 +5889,8 @@ func (ResourceType) Values() []ResourceType { "verified-access-trust-provider", "vpn-connection-device-type", "vpc-block-public-access-exclusion", + "ipam-resource-discovery", + "ipam-resource-discovery-association", } } diff --git a/service/ec2/types/types.go b/service/ec2/types/types.go index 80393f0cac6..2ca6b01a6c4 100644 --- a/service/ec2/types/types.go +++ b/service/ec2/types/types.go @@ -7126,10 +7126,16 @@ type InternetGatewayAttachment struct { // VPC IPAM User Guide. type Ipam struct { + // The IPAM's default resource discovery association ID. + DefaultResourceDiscoveryAssociationId *string + + // The IPAM's default resource discovery ID. + DefaultResourceDiscoveryId *string + // The description for the IPAM. Description *string - // The ARN of the IPAM. + // The Amazon Resource Name (ARN) of the IPAM. IpamArn *string // The ID of the IPAM. @@ -7155,6 +7161,9 @@ type Ipam struct { // The ID of the IPAM's default public scope. PublicDefaultScopeId *string + // The IPAM's resource discovery association count. + ResourceDiscoveryAssociationCount *int32 + // The number of scopes in the IPAM. The scope quota is 5. For more information on // quotas, see Quotas in IPAM // (https://docs.aws.amazon.com/vpc/latest/ipam/quotas-ipam.html) in the Amazon VPC @@ -7239,6 +7248,121 @@ type IpamCidrAuthorizationContext struct { noSmithyDocumentSerde } +// An IPAM discovered account. A discovered account is an Amazon Web Services +// account that is monitored under a resource discovery. If you have integrated +// IPAM with Amazon Web Services Organizations, all accounts in the organization +// are discovered accounts. +type IpamDiscoveredAccount struct { + + // The account ID. + AccountId *string + + // The Amazon Web Services Region that the account information is returned from. An + // account can be discovered in multiple regions and will have a separate + // discovered account for each Region. + DiscoveryRegion *string + + // The resource discovery failure reason. + FailureReason *IpamDiscoveryFailureReason + + // The last attempted resource discovery time. + LastAttemptedDiscoveryTime *time.Time + + // The last successful resource discovery time. + LastSuccessfulDiscoveryTime *time.Time + + noSmithyDocumentSerde +} + +// An IPAM discovered resource CIDR. A discovered resource is a resource CIDR +// monitored under a resource discovery. The following resources can be discovered: +// VPCs, Public IPv4 pools, VPC subnets, and Elastic IP addresses. The discovered +// resource CIDR is the IP address range in CIDR notation that is associated with +// the resource. +type IpamDiscoveredResourceCidr struct { + + // The percentage of IP address space in use. To convert the decimal to a + // percentage, multiply the decimal by 100. Note the following: + // + // * For resources + // that are VPCs, this is the percentage of IP address space in the VPC that's + // taken up by subnet CIDRs. + // + // * For resources that are subnets, if the subnet has + // an IPv4 CIDR provisioned to it, this is the percentage of IPv4 address space in + // the subnet that's in use. If the subnet has an IPv6 CIDR provisioned to it, the + // percentage of IPv6 address space in use is not represented. The percentage of + // IPv6 address space in use cannot currently be calculated. + // + // * For resources that + // are public IPv4 pools, this is the percentage of IP address space in the pool + // that's been allocated to Elastic IP addresses (EIPs). + IpUsage *float64 + + // The resource discovery ID. + IpamResourceDiscoveryId *string + + // The resource CIDR. + ResourceCidr *string + + // The resource ID. + ResourceId *string + + // The resource owner ID. + ResourceOwnerId *string + + // The resource Region. + ResourceRegion *string + + // The resource tags. + ResourceTags []IpamResourceTag + + // The resource type. + ResourceType IpamResourceType + + // The last successful resource discovery time. + SampleTime *time.Time + + // The VPC ID. + VpcId *string + + noSmithyDocumentSerde +} + +// The discovery failure reason. +type IpamDiscoveryFailureReason struct { + + // The discovery failure code. + // + // * assume-role-failure - IPAM could not assume the + // Amazon Web Services IAM service-linked role. This could be because of any of the + // following: + // + // * SLR has not been created yet and IPAM is still creating it. + // + // * You + // have opted-out of the IPAM home Region. + // + // * Account you are using as your IPAM + // account has been suspended. + // + // * throttling-failure - IPAM account is already + // using the allotted transactions per second and IPAM is receiving a throttling + // error when assuming the Amazon Web Services IAM SLR. + // + // * unauthorized-failure - + // Amazon Web Services account making the request is not authorized. For more + // information, see AuthFailure + // (https://docs.aws.amazon.com/AWSEC2/latest/APIReference/errors-overview.html) in + // the Amazon Elastic Compute Cloud API Reference. + Code IpamDiscoveryFailureCode + + // The discovery failure message. + Message *string + + noSmithyDocumentSerde +} + // The operating Regions for an IPAM. Operating Regions are Amazon Web Services // Regions where the IPAM is allowed to manage IP address CIDRs. IPAM only // discovers and monitors resources in the Amazon Web Services Regions you select @@ -7307,7 +7431,7 @@ type IpamPool struct { // The ARN of the IPAM. IpamArn *string - // The ARN of the IPAM pool. + // The Amazon Resource Name (ARN) of the IPAM pool. IpamPoolArn *string // The ID of the IPAM pool. @@ -7346,6 +7470,17 @@ type IpamPool struct { // IPAM User Guide. PoolDepth *int32 + // The IP address source for pools in the public scope. Only used for provisioning + // IP address CIDRs to pools in the public scope. Default is BYOIP. For more + // information, see Create IPv6 pools + // (https://docs.aws.amazon.com/vpc/latest/ipam/intro-create-ipv6-pools.html) in + // the Amazon VPC IPAM User Guide. By default, you can add only one Amazon-provided + // IPv6 CIDR block to a top-level IPv6 pool. For information on increasing the + // default limit, see Quotas for your IPAM + // (https://docs.aws.amazon.com/vpc/latest/ipam/quotas-ipam.html) in the Amazon VPC + // IPAM User Guide. + PublicIpSource IpamPoolPublicIpSource + // Determines if a pool is publicly advertisable. This option is not available for // pools with AddressFamily set to ipv4. PubliclyAdvertisable *bool @@ -7369,8 +7504,8 @@ type IpamPool struct { noSmithyDocumentSerde } -// In IPAM, an allocation is a CIDR assignment from an IPAM pool to another -// resource or IPAM pool. +// In IPAM, an allocation is a CIDR assignment from an IPAM pool to another IPAM +// pool or to a resource. type IpamPoolAllocation struct { // The CIDR for the allocation. A CIDR is a representation of an IP address and its @@ -7411,6 +7546,15 @@ type IpamPoolCidr struct { // Details related to why an IPAM pool CIDR failed to be provisioned. FailureReason *IpamPoolCidrFailureReason + // The IPAM pool CIDR ID. + IpamPoolCidrId *string + + // The netmask length of the CIDR you'd like to provision to a pool. Can be used + // for provisioning Amazon-provided IPv6 CIDRs to top-level pools and for + // provisioning CIDRs to pools with source pools. Cannot be used to provision BYOIP + // CIDRs to top-level pools. "NetmaskLength" or "Cidr" is required. + NetmaskLength *int32 + // The state of the CIDR. State IpamPoolCidrState @@ -7441,7 +7585,7 @@ type IpamResourceCidr struct { // The percentage of IP address space in use. To convert the decimal to a // percentage, multiply the decimal by 100. Note the following: // - // * For a resources + // * For resources // that are VPCs, this is the percentage of IP address space in the VPC that's // taken up by subnet CIDRs. // @@ -7505,6 +7649,163 @@ type IpamResourceCidr struct { noSmithyDocumentSerde } +// A resource discovery is an IPAM component that enables IPAM Service to manage +// and monitor resources that belong to the owning account. +type IpamResourceDiscovery struct { + + // The resource discovery description. + Description *string + + // The resource discovery Amazon Resource Name (ARN). + IpamResourceDiscoveryArn *string + + // The resource discovery ID. + IpamResourceDiscoveryId *string + + // The resource discovery Region. + IpamResourceDiscoveryRegion *string + + // Defines if the resource discovery is the default. The default resource discovery + // is the resource discovery automatically created when you create an IPAM. + IsDefault *bool + + // The operating Regions for the resource discovery. Operating Regions are Amazon + // Web Services Regions where the IPAM is allowed to manage IP address CIDRs. IPAM + // only discovers and monitors resources in the Amazon Web Services Regions you + // select as operating Regions. + OperatingRegions []IpamOperatingRegion + + // The ID of the owner. + OwnerId *string + + // The lifecycle state of the resource discovery. + // + // * create-in-progress - Resource + // discovery is being created. + // + // * create-complete - Resource discovery creation is + // complete. + // + // * create-failed - Resource discovery creation has failed. + // + // * + // modify-in-progress - Resource discovery is being modified. + // + // * modify-complete - + // Resource discovery modification is complete. + // + // * modify-failed - Resource + // discovery modification has failed. + // + // * delete-in-progress - Resource discovery is + // being deleted. + // + // * delete-complete - Resource discovery deletion is complete. + // + // * + // delete-failed - Resource discovery deletion has failed. + // + // * isolate-in-progress - + // Amazon Web Services account that created the resource discovery has been removed + // and the resource discovery is being isolated. + // + // * isolate-complete - Resource + // discovery isolation is complete. + // + // * restore-in-progress - Amazon Web Services + // account that created the resource discovery and was isolated has been restored. + State IpamResourceDiscoveryState + + // A tag is a label that you assign to an Amazon Web Services resource. Each tag + // consists of a key and an optional value. You can use tags to search and filter + // your resources or track your Amazon Web Services costs. + Tags []Tag + + noSmithyDocumentSerde +} + +// An IPAM resource discovery association. An associated resource discovery is a +// resource discovery that has been associated with an IPAM. IPAM aggregates the +// resource CIDRs discovered by the associated resource discovery. +type IpamResourceDiscoveryAssociation struct { + + // The IPAM ARN. + IpamArn *string + + // The IPAM ID. + IpamId *string + + // The IPAM home Region. + IpamRegion *string + + // The resource discovery association Amazon Resource Name (ARN). + IpamResourceDiscoveryAssociationArn *string + + // The resource discovery association ID. + IpamResourceDiscoveryAssociationId *string + + // The resource discovery ID. + IpamResourceDiscoveryId *string + + // Defines if the resource discovery is the default. When you create an IPAM, a + // default resource discovery is created for your IPAM and it's associated with + // your IPAM. + IsDefault *bool + + // The Amazon Web Services account ID of the resource discovery owner. + OwnerId *string + + // The resource discovery status. + // + // * active - Connection or permissions required to + // read the results of the resource discovery are intact. + // + // * not-found - Connection + // or permissions required to read the results of the resource discovery are + // broken. This may happen if the owner of the resource discovery stopped sharing + // it or deleted the resource discovery. Verify the resource discovery still exists + // and the Amazon Web Services RAM resource share is still intact. + ResourceDiscoveryStatus IpamAssociatedResourceDiscoveryStatus + + // The lifecycle state of the association when you associate or disassociate a + // resource discovery. + // + // * associate-in-progress - Resource discovery is being + // associated. + // + // * associate-complete - Resource discovery association is + // complete. + // + // * associate-failed - Resource discovery association has failed. + // + // * + // disassociate-in-progress - Resource discovery is being disassociated. + // + // * + // disassociate-complete - Resource discovery disassociation is complete. + // + // * + // disassociate-failed - Resource discovery disassociation has failed. + // + // * + // isolate-in-progress - Amazon Web Services account that created the resource + // discovery association has been removed and the resource discovery associatation + // is being isolated. + // + // * isolate-complete - Resource discovery isolation is + // complete.. + // + // * restore-in-progress - Resource discovery is being restored. + State IpamResourceDiscoveryAssociationState + + // A tag is a label that you assign to an Amazon Web Services resource. Each tag + // consists of a key and an optional value. You can use tags to search and filter + // your resources or track your Amazon Web Services costs. + Tags []Tag + + noSmithyDocumentSerde +} + // The key/value combination of a tag assigned to the resource. Use the tag key in // the filter name and the tag value as the filter value. For example, to find all // resources that have a tag with the key Owner and the value TeamA, specify @@ -7540,7 +7841,7 @@ type IpamScope struct { // The Amazon Web Services Region of the IPAM scope. IpamRegion *string - // The ARN of the scope. + // The Amazon Resource Name (ARN) of the scope. IpamScopeArn *string // The ID of the scope. diff --git a/service/ec2/validators.go b/service/ec2/validators.go index 776dad12f93..90796e50408 100644 --- a/service/ec2/validators.go +++ b/service/ec2/validators.go @@ -310,6 +310,26 @@ func (m *validateOpAssociateInstanceEventWindow) HandleInitialize(ctx context.Co return next.HandleInitialize(ctx, in) } +type validateOpAssociateIpamResourceDiscovery struct { +} + +func (*validateOpAssociateIpamResourceDiscovery) ID() string { + return "OperationInputValidation" +} + +func (m *validateOpAssociateIpamResourceDiscovery) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + input, ok := in.Parameters.(*AssociateIpamResourceDiscoveryInput) + if !ok { + return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) + } + if err := validateOpAssociateIpamResourceDiscoveryInput(input); err != nil { + return out, metadata, err + } + return next.HandleInitialize(ctx, in) +} + type validateOpAssociateRouteTable struct { } @@ -2510,6 +2530,26 @@ func (m *validateOpDeleteIpamPool) HandleInitialize(ctx context.Context, in midd return next.HandleInitialize(ctx, in) } +type validateOpDeleteIpamResourceDiscovery struct { +} + +func (*validateOpDeleteIpamResourceDiscovery) ID() string { + return "OperationInputValidation" +} + +func (m *validateOpDeleteIpamResourceDiscovery) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + input, ok := in.Parameters.(*DeleteIpamResourceDiscoveryInput) + if !ok { + return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) + } + if err := validateOpDeleteIpamResourceDiscoveryInput(input); err != nil { + return out, metadata, err + } + return next.HandleInitialize(ctx, in) +} + type validateOpDeleteIpamScope struct { } @@ -4410,6 +4450,26 @@ func (m *validateOpDisassociateInstanceEventWindow) HandleInitialize(ctx context return next.HandleInitialize(ctx, in) } +type validateOpDisassociateIpamResourceDiscovery struct { +} + +func (*validateOpDisassociateIpamResourceDiscovery) ID() string { + return "OperationInputValidation" +} + +func (m *validateOpDisassociateIpamResourceDiscovery) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + input, ok := in.Parameters.(*DisassociateIpamResourceDiscoveryInput) + if !ok { + return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) + } + if err := validateOpDisassociateIpamResourceDiscoveryInput(input); err != nil { + return out, metadata, err + } + return next.HandleInitialize(ctx, in) +} + type validateOpDisassociateRouteTable struct { } @@ -5030,6 +5090,46 @@ func (m *validateOpGetIpamAddressHistory) HandleInitialize(ctx context.Context, return next.HandleInitialize(ctx, in) } +type validateOpGetIpamDiscoveredAccounts struct { +} + +func (*validateOpGetIpamDiscoveredAccounts) ID() string { + return "OperationInputValidation" +} + +func (m *validateOpGetIpamDiscoveredAccounts) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + input, ok := in.Parameters.(*GetIpamDiscoveredAccountsInput) + if !ok { + return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) + } + if err := validateOpGetIpamDiscoveredAccountsInput(input); err != nil { + return out, metadata, err + } + return next.HandleInitialize(ctx, in) +} + +type validateOpGetIpamDiscoveredResourceCidrs struct { +} + +func (*validateOpGetIpamDiscoveredResourceCidrs) ID() string { + return "OperationInputValidation" +} + +func (m *validateOpGetIpamDiscoveredResourceCidrs) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + input, ok := in.Parameters.(*GetIpamDiscoveredResourceCidrsInput) + if !ok { + return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) + } + if err := validateOpGetIpamDiscoveredResourceCidrsInput(input); err != nil { + return out, metadata, err + } + return next.HandleInitialize(ctx, in) +} + type validateOpGetIpamPoolAllocations struct { } @@ -6010,6 +6110,26 @@ func (m *validateOpModifyIpamResourceCidr) HandleInitialize(ctx context.Context, return next.HandleInitialize(ctx, in) } +type validateOpModifyIpamResourceDiscovery struct { +} + +func (*validateOpModifyIpamResourceDiscovery) ID() string { + return "OperationInputValidation" +} + +func (m *validateOpModifyIpamResourceDiscovery) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + input, ok := in.Parameters.(*ModifyIpamResourceDiscoveryInput) + if !ok { + return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) + } + if err := validateOpModifyIpamResourceDiscoveryInput(input); err != nil { + return out, metadata, err + } + return next.HandleInitialize(ctx, in) +} + type validateOpModifyIpamScope struct { } @@ -7910,6 +8030,10 @@ func addOpAssociateInstanceEventWindowValidationMiddleware(stack *middleware.Sta return stack.Initialize.Add(&validateOpAssociateInstanceEventWindow{}, middleware.After) } +func addOpAssociateIpamResourceDiscoveryValidationMiddleware(stack *middleware.Stack) error { + return stack.Initialize.Add(&validateOpAssociateIpamResourceDiscovery{}, middleware.After) +} + func addOpAssociateRouteTableValidationMiddleware(stack *middleware.Stack) error { return stack.Initialize.Add(&validateOpAssociateRouteTable{}, middleware.After) } @@ -8350,6 +8474,10 @@ func addOpDeleteIpamPoolValidationMiddleware(stack *middleware.Stack) error { return stack.Initialize.Add(&validateOpDeleteIpamPool{}, middleware.After) } +func addOpDeleteIpamResourceDiscoveryValidationMiddleware(stack *middleware.Stack) error { + return stack.Initialize.Add(&validateOpDeleteIpamResourceDiscovery{}, middleware.After) +} + func addOpDeleteIpamScopeValidationMiddleware(stack *middleware.Stack) error { return stack.Initialize.Add(&validateOpDeleteIpamScope{}, middleware.After) } @@ -8730,6 +8858,10 @@ func addOpDisassociateInstanceEventWindowValidationMiddleware(stack *middleware. return stack.Initialize.Add(&validateOpDisassociateInstanceEventWindow{}, middleware.After) } +func addOpDisassociateIpamResourceDiscoveryValidationMiddleware(stack *middleware.Stack) error { + return stack.Initialize.Add(&validateOpDisassociateIpamResourceDiscovery{}, middleware.After) +} + func addOpDisassociateRouteTableValidationMiddleware(stack *middleware.Stack) error { return stack.Initialize.Add(&validateOpDisassociateRouteTable{}, middleware.After) } @@ -8854,6 +8986,14 @@ func addOpGetIpamAddressHistoryValidationMiddleware(stack *middleware.Stack) err return stack.Initialize.Add(&validateOpGetIpamAddressHistory{}, middleware.After) } +func addOpGetIpamDiscoveredAccountsValidationMiddleware(stack *middleware.Stack) error { + return stack.Initialize.Add(&validateOpGetIpamDiscoveredAccounts{}, middleware.After) +} + +func addOpGetIpamDiscoveredResourceCidrsValidationMiddleware(stack *middleware.Stack) error { + return stack.Initialize.Add(&validateOpGetIpamDiscoveredResourceCidrs{}, middleware.After) +} + func addOpGetIpamPoolAllocationsValidationMiddleware(stack *middleware.Stack) error { return stack.Initialize.Add(&validateOpGetIpamPoolAllocations{}, middleware.After) } @@ -9050,6 +9190,10 @@ func addOpModifyIpamResourceCidrValidationMiddleware(stack *middleware.Stack) er return stack.Initialize.Add(&validateOpModifyIpamResourceCidr{}, middleware.After) } +func addOpModifyIpamResourceDiscoveryValidationMiddleware(stack *middleware.Stack) error { + return stack.Initialize.Add(&validateOpModifyIpamResourceDiscovery{}, middleware.After) +} + func addOpModifyIpamScopeValidationMiddleware(stack *middleware.Stack) error { return stack.Initialize.Add(&validateOpModifyIpamScope{}, middleware.After) } @@ -10464,6 +10608,24 @@ func validateOpAssociateInstanceEventWindowInput(v *AssociateInstanceEventWindow } } +func validateOpAssociateIpamResourceDiscoveryInput(v *AssociateIpamResourceDiscoveryInput) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "AssociateIpamResourceDiscoveryInput"} + if v.IpamId == nil { + invalidParams.Add(smithy.NewErrParamRequired("IpamId")) + } + if v.IpamResourceDiscoveryId == nil { + invalidParams.Add(smithy.NewErrParamRequired("IpamResourceDiscoveryId")) + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + func validateOpAssociateRouteTableInput(v *AssociateRouteTableInput) error { if v == nil { return nil @@ -12415,6 +12577,21 @@ func validateOpDeleteIpamPoolInput(v *DeleteIpamPoolInput) error { } } +func validateOpDeleteIpamResourceDiscoveryInput(v *DeleteIpamResourceDiscoveryInput) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "DeleteIpamResourceDiscoveryInput"} + if v.IpamResourceDiscoveryId == nil { + invalidParams.Add(smithy.NewErrParamRequired("IpamResourceDiscoveryId")) + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + func validateOpDeleteIpamScopeInput(v *DeleteIpamScopeInput) error { if v == nil { return nil @@ -13916,6 +14093,21 @@ func validateOpDisassociateInstanceEventWindowInput(v *DisassociateInstanceEvent } } +func validateOpDisassociateIpamResourceDiscoveryInput(v *DisassociateIpamResourceDiscoveryInput) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "DisassociateIpamResourceDiscoveryInput"} + if v.IpamResourceDiscoveryAssociationId == nil { + invalidParams.Add(smithy.NewErrParamRequired("IpamResourceDiscoveryAssociationId")) + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + func validateOpDisassociateRouteTableInput(v *DisassociateRouteTableInput) error { if v == nil { return nil @@ -14443,6 +14635,42 @@ func validateOpGetIpamAddressHistoryInput(v *GetIpamAddressHistoryInput) error { } } +func validateOpGetIpamDiscoveredAccountsInput(v *GetIpamDiscoveredAccountsInput) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "GetIpamDiscoveredAccountsInput"} + if v.IpamResourceDiscoveryId == nil { + invalidParams.Add(smithy.NewErrParamRequired("IpamResourceDiscoveryId")) + } + if v.DiscoveryRegion == nil { + invalidParams.Add(smithy.NewErrParamRequired("DiscoveryRegion")) + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + +func validateOpGetIpamDiscoveredResourceCidrsInput(v *GetIpamDiscoveredResourceCidrsInput) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "GetIpamDiscoveredResourceCidrsInput"} + if v.IpamResourceDiscoveryId == nil { + invalidParams.Add(smithy.NewErrParamRequired("IpamResourceDiscoveryId")) + } + if v.ResourceRegion == nil { + invalidParams.Add(smithy.NewErrParamRequired("ResourceRegion")) + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + func validateOpGetIpamPoolAllocationsInput(v *GetIpamPoolAllocationsInput) error { if v == nil { return nil @@ -15262,6 +15490,21 @@ func validateOpModifyIpamResourceCidrInput(v *ModifyIpamResourceCidrInput) error } } +func validateOpModifyIpamResourceDiscoveryInput(v *ModifyIpamResourceDiscoveryInput) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "ModifyIpamResourceDiscoveryInput"} + if v.IpamResourceDiscoveryId == nil { + invalidParams.Add(smithy.NewErrParamRequired("IpamResourceDiscoveryId")) + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + func validateOpModifyIpamScopeInput(v *ModifyIpamScopeInput) error { if v == nil { return nil diff --git a/service/m2/api_op_GetBatchJobExecution.go b/service/m2/api_op_GetBatchJobExecution.go index 08974003f00..19342989387 100644 --- a/service/m2/api_op_GetBatchJobExecution.go +++ b/service/m2/api_op_GetBatchJobExecution.go @@ -65,6 +65,9 @@ type GetBatchJobExecutionOutput struct { // This member is required. Status types.BatchJobExecutionStatus + // Identifies a specific batch job. + BatchJobIdentifier types.BatchJobIdentifier + // The timestamp when the batch job execution ended. EndTime *time.Time @@ -80,6 +83,9 @@ type GetBatchJobExecutionOutput struct { // The user for the job. JobUser *string + // + ReturnCode *string + // The reason for the reported status. StatusReason *string diff --git a/service/m2/deserializers.go b/service/m2/deserializers.go index cef579769f8..ace6cb4a6eb 100644 --- a/service/m2/deserializers.go +++ b/service/m2/deserializers.go @@ -1791,6 +1791,11 @@ func awsRestjson1_deserializeOpDocumentGetBatchJobExecutionOutput(v **GetBatchJo sv.ApplicationId = ptr.String(jtv) } + case "batchJobIdentifier": + if err := awsRestjson1_deserializeDocumentBatchJobIdentifier(&sv.BatchJobIdentifier, value); err != nil { + return err + } + case "endTime": if value != nil { switch jtv := value.(type) { @@ -1852,6 +1857,15 @@ func awsRestjson1_deserializeOpDocumentGetBatchJobExecutionOutput(v **GetBatchJo sv.JobUser = ptr.String(jtv) } + case "returnCode": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected String to be of type string, got %T instead", value) + } + sv.ReturnCode = ptr.String(jtv) + } + case "startTime": if value != nil { switch jtv := value.(type) { @@ -6339,6 +6353,11 @@ func awsRestjson1_deserializeDocumentBatchJobExecutionSummary(v **types.BatchJob sv.ApplicationId = ptr.String(jtv) } + case "batchJobIdentifier": + if err := awsRestjson1_deserializeDocumentBatchJobIdentifier(&sv.BatchJobIdentifier, value); err != nil { + return err + } + case "endTime": if value != nil { switch jtv := value.(type) { @@ -6391,6 +6410,15 @@ func awsRestjson1_deserializeDocumentBatchJobExecutionSummary(v **types.BatchJob sv.JobType = types.BatchJobType(jtv) } + case "returnCode": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected String to be of type string, got %T instead", value) + } + sv.ReturnCode = ptr.String(jtv) + } + case "startTime": if value != nil { switch jtv := value.(type) { @@ -6459,6 +6487,56 @@ func awsRestjson1_deserializeDocumentBatchJobExecutionSummaryList(v *[]types.Bat return nil } +func awsRestjson1_deserializeDocumentBatchJobIdentifier(v *types.BatchJobIdentifier, value interface{}) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + if value == nil { + return nil + } + + shape, ok := value.(map[string]interface{}) + if !ok { + return fmt.Errorf("unexpected JSON type %v", value) + } + + var uv types.BatchJobIdentifier +loop: + for key, value := range shape { + if value == nil { + continue + } + switch key { + case "fileBatchJobIdentifier": + var mv types.FileBatchJobIdentifier + destAddr := &mv + if err := awsRestjson1_deserializeDocumentFileBatchJobIdentifier(&destAddr, value); err != nil { + return err + } + mv = *destAddr + uv = &types.BatchJobIdentifierMemberFileBatchJobIdentifier{Value: mv} + break loop + + case "scriptBatchJobIdentifier": + var mv types.ScriptBatchJobIdentifier + destAddr := &mv + if err := awsRestjson1_deserializeDocumentScriptBatchJobIdentifier(&destAddr, value); err != nil { + return err + } + mv = *destAddr + uv = &types.BatchJobIdentifierMemberScriptBatchJobIdentifier{Value: mv} + break loop + + default: + uv = &types.UnknownUnionMember{Tag: key} + break loop + + } + } + *v = uv + return nil +} + func awsRestjson1_deserializeDocumentConflictException(v **types.ConflictException, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) @@ -7417,6 +7495,55 @@ func awsRestjson1_deserializeDocumentFileBatchJobDefinition(v **types.FileBatchJ return nil } +func awsRestjson1_deserializeDocumentFileBatchJobIdentifier(v **types.FileBatchJobIdentifier, value interface{}) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", 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.FileBatchJobIdentifier + if *v == nil { + sv = &types.FileBatchJobIdentifier{} + } else { + sv = *v + } + + for key, value := range shape { + switch key { + case "fileName": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected String to be of type string, got %T instead", value) + } + sv.FileName = ptr.String(jtv) + } + + case "folderPath": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected String to be of type string, got %T instead", value) + } + sv.FolderPath = ptr.String(jtv) + } + + default: + _, _ = key, value + + } + } + *v = sv + return nil +} + func awsRestjson1_deserializeDocumentFsxStorageConfiguration(v **types.FsxStorageConfiguration, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) @@ -8011,6 +8138,46 @@ func awsRestjson1_deserializeDocumentScriptBatchJobDefinition(v **types.ScriptBa return nil } +func awsRestjson1_deserializeDocumentScriptBatchJobIdentifier(v **types.ScriptBatchJobIdentifier, value interface{}) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", 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.ScriptBatchJobIdentifier + if *v == nil { + sv = &types.ScriptBatchJobIdentifier{} + } else { + sv = *v + } + + for key, value := range shape { + switch key { + case "scriptName": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected String to be of type string, got %T instead", value) + } + sv.ScriptName = ptr.String(jtv) + } + + default: + _, _ = key, value + + } + } + *v = sv + return nil +} + func awsRestjson1_deserializeDocumentServiceQuotaExceededException(v **types.ServiceQuotaExceededException, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) diff --git a/service/m2/types/types.go b/service/m2/types/types.go index ea47773bb15..b2ca582d448 100644 --- a/service/m2/types/types.go +++ b/service/m2/types/types.go @@ -166,6 +166,9 @@ type BatchJobExecutionSummary struct { // This member is required. Status BatchJobExecutionStatus + // Identifies a specific batch job. + BatchJobIdentifier BatchJobIdentifier + // The timestamp when this batch job execution ended. EndTime *time.Time @@ -178,6 +181,9 @@ type BatchJobExecutionSummary struct { // The type of a particular batch job execution. JobType BatchJobType + // + ReturnCode *string + noSmithyDocumentSerde } diff --git a/service/opensearchserverless/internal/endpoints/endpoints.go b/service/opensearchserverless/internal/endpoints/endpoints.go index 5925a41bd5d..86e71aba166 100644 --- a/service/opensearchserverless/internal/endpoints/endpoints.go +++ b/service/opensearchserverless/internal/endpoints/endpoints.go @@ -138,6 +138,15 @@ var defaultPartitions = endpoints.Partitions{ endpoints.EndpointKey{ Region: "ap-northeast-1", }: endpoints.Endpoint{}, + endpoints.EndpointKey{ + Region: "ap-southeast-1", + }: endpoints.Endpoint{}, + endpoints.EndpointKey{ + Region: "ap-southeast-2", + }: endpoints.Endpoint{}, + endpoints.EndpointKey{ + Region: "eu-central-1", + }: endpoints.Endpoint{}, endpoints.EndpointKey{ Region: "eu-west-1", }: endpoints.Endpoint{}, diff --git a/service/polly/types/enums.go b/service/polly/types/enums.go index fb5e837ea2b..c3635638183 100644 --- a/service/polly/types/enums.go +++ b/service/polly/types/enums.go @@ -291,6 +291,11 @@ const ( VoiceIdSuvi VoiceId = "Suvi" VoiceIdOla VoiceId = "Ola" VoiceIdHala VoiceId = "Hala" + VoiceIdAndres VoiceId = "Andres" + VoiceIdSergio VoiceId = "Sergio" + VoiceIdRemi VoiceId = "Remi" + VoiceIdAdriano VoiceId = "Adriano" + VoiceIdThiago VoiceId = "Thiago" ) // Values returns all known values for VoiceId. Note that this can be expanded in @@ -377,5 +382,10 @@ func (VoiceId) Values() []VoiceId { "Suvi", "Ola", "Hala", + "Andres", + "Sergio", + "Remi", + "Adriano", + "Thiago", } } diff --git a/service/redshiftserverless/api_op_CreateWorkgroup.go b/service/redshiftserverless/api_op_CreateWorkgroup.go index e1d72b25466..a0e8b129fdc 100644 --- a/service/redshiftserverless/api_op_CreateWorkgroup.go +++ b/service/redshiftserverless/api_op_CreateWorkgroup.go @@ -43,9 +43,13 @@ type CreateWorkgroupInput struct { // (RPUs). BaseCapacity *int32 - // An array of parameters to set for more control over a serverless database. The - // options are datestyle, enable_user_activity_logging, query_group, search_path, - // and max_query_execution_time. + // An array of parameters to set for advanced control over a database. The options + // are auto_mv, datestyle, enable_case_sensitivity_identifier, + // enable_user_activity_logging, query_group, search_path, and query monitoring + // metrics that let you define performance boundaries. For more information about + // query monitoring rules and available metrics, see Query monitoring metrics for + // Amazon Redshift Serverless + // (https://docs.aws.amazon.com/redshift/latest/dg/cm-c-wlm-query-monitoring-rules.html#cm-c-wlm-query-monitoring-metrics-serverless). ConfigParameters []types.ConfigParameter // The value that specifies whether to turn on enhanced virtual private cloud (VPC) diff --git a/service/redshiftserverless/api_op_RestoreTableFromSnapshot.go b/service/redshiftserverless/api_op_RestoreTableFromSnapshot.go index baa41eef577..ada9d7a1bf5 100644 --- a/service/redshiftserverless/api_op_RestoreTableFromSnapshot.go +++ b/service/redshiftserverless/api_op_RestoreTableFromSnapshot.go @@ -12,6 +12,8 @@ import ( ) // Restores a table from a snapshot to your Amazon Redshift Serverless instance. +// You can't use this operation to restore tables with interleaved sort keys +// (https://docs.aws.amazon.com/redshift/latest/dg/t_Sorting_data.html#t_Sorting_data-interleaved). func (c *Client) RestoreTableFromSnapshot(ctx context.Context, params *RestoreTableFromSnapshotInput, optFns ...func(*Options)) (*RestoreTableFromSnapshotOutput, error) { if params == nil { params = &RestoreTableFromSnapshotInput{} diff --git a/service/redshiftserverless/api_op_UpdateNamespace.go b/service/redshiftserverless/api_op_UpdateNamespace.go index ffc7605dad1..e5bb802c4ce 100644 --- a/service/redshiftserverless/api_op_UpdateNamespace.go +++ b/service/redshiftserverless/api_op_UpdateNamespace.go @@ -11,7 +11,10 @@ import ( smithyhttp "github.com/aws/smithy-go/transport/http" ) -// Updates a namespace with the specified settings. +// Updates a namespace with the specified settings. Unless required, you can't +// update multiple parameters in one request. For example, you must specify both +// adminUsername and adminUserPassword to update either field, but you can't update +// both kmsKeyId and logExports in a single request. func (c *Client) UpdateNamespace(ctx context.Context, params *UpdateNamespaceInput, optFns ...func(*Options)) (*UpdateNamespaceOutput, error) { if params == nil { params = &UpdateNamespaceInput{} @@ -29,24 +32,26 @@ func (c *Client) UpdateNamespace(ctx context.Context, params *UpdateNamespaceInp type UpdateNamespaceInput struct { - // The name of the namespace. + // The name of the namespace to update. You can't update the name of a namespace + // once it is created. // // This member is required. NamespaceName *string // The password of the administrator for the first database created in the - // namespace. + // namespace. This parameter must be updated together with adminUsername. AdminUserPassword *string // The username of the administrator for the first database created in the - // namespace. + // namespace. This parameter must be updated together with adminUserPassword. AdminUsername *string // The Amazon Resource Name (ARN) of the IAM role to set as a default in the - // namespace. + // namespace. This parameter must be updated together with iamRoles. DefaultIamRoleArn *string - // A list of IAM roles to associate with the namespace. + // A list of IAM roles to associate with the namespace. This parameter must be + // updated together with defaultIamRoleArn. IamRoles []string // The ID of the Amazon Web Services Key Management Service key used to encrypt diff --git a/service/redshiftserverless/api_op_UpdateWorkgroup.go b/service/redshiftserverless/api_op_UpdateWorkgroup.go index 6db14b344a5..ebe4e77b291 100644 --- a/service/redshiftserverless/api_op_UpdateWorkgroup.go +++ b/service/redshiftserverless/api_op_UpdateWorkgroup.go @@ -11,7 +11,9 @@ import ( smithyhttp "github.com/aws/smithy-go/transport/http" ) -// Updates a workgroup with the specified configuration settings. +// Updates a workgroup with the specified configuration settings. You can't update +// multiple parameters in one request. For example, you can update baseCapacity or +// port in a single request, but you can't update both in the same request. func (c *Client) UpdateWorkgroup(ctx context.Context, params *UpdateWorkgroupInput, optFns ...func(*Options)) (*UpdateWorkgroupOutput, error) { if params == nil { params = &UpdateWorkgroupInput{} @@ -29,7 +31,8 @@ func (c *Client) UpdateWorkgroup(ctx context.Context, params *UpdateWorkgroupInp type UpdateWorkgroupInput struct { - // The name of the workgroup to update. + // The name of the workgroup to update. You can't update the name of a workgroup + // once it is created. // // This member is required. WorkgroupName *string @@ -38,8 +41,12 @@ type UpdateWorkgroupInput struct { BaseCapacity *int32 // An array of parameters to set for advanced control over a database. The options - // are datestyle, enable_user_activity_logging, query_group, search_path, and - // max_query_execution_time. + // are auto_mv, datestyle, enable_case_sensitivity_identifier, + // enable_user_activity_logging, query_group, search_path, and query monitoring + // metrics that let you define performance boundaries. For more information about + // query monitoring rules and available metrics, see Query monitoring metrics for + // Amazon Redshift Serverless + // (https://docs.aws.amazon.com/redshift/latest/dg/cm-c-wlm-query-monitoring-rules.html#cm-c-wlm-query-monitoring-metrics-serverless). ConfigParameters []types.ConfigParameter // The value that specifies whether to turn on enhanced virtual private cloud (VPC) diff --git a/service/redshiftserverless/types/types.go b/service/redshiftserverless/types/types.go index 9cab34fe8eb..9b9cbfa16e3 100644 --- a/service/redshiftserverless/types/types.go +++ b/service/redshiftserverless/types/types.go @@ -11,9 +11,12 @@ import ( // Serverless. type ConfigParameter struct { - // The key of the parameter. The options are datestyle, - // enable_user_activity_logging, query_group, search_path, and - // max_query_execution_time. + // The key of the parameter. The options are auto_mv, datestyle, + // enable_case_sensitivity_identifier, enable_user_activity_logging, query_group, + // search_path, and query monitoring metrics that let you define performance + // boundaries. For more information about query monitoring rules and available + // metrics, see Query monitoring metrics for Amazon Redshift Serverless + // (https://docs.aws.amazon.com/redshift/latest/dg/cm-c-wlm-query-monitoring-rules.html#cm-c-wlm-query-monitoring-metrics-serverless). ParameterKey *string // The value of the parameter to set. @@ -385,9 +388,13 @@ type Workgroup struct { // (RPUs). BaseCapacity *int32 - // An array of parameters to set for finer control over a database. The options are - // datestyle, enable_user_activity_logging, query_group, search_path, and - // max_query_execution_time. + // An array of parameters to set for advanced control over a database. The options + // are auto_mv, datestyle, enable_case_sensitivity_identifier, + // enable_user_activity_logging, query_group, , search_path, and query monitoring + // metrics that let you define performance boundaries. For more information about + // query monitoring rules and available metrics, see Query monitoring metrics for + // Amazon Redshift Serverless + // (https://docs.aws.amazon.com/redshift/latest/dg/cm-c-wlm-query-monitoring-rules.html#cm-c-wlm-query-monitoring-metrics-serverless). ConfigParameters []ConfigParameter // The creation date of the workgroup. diff --git a/service/sagemaker/deserializers.go b/service/sagemaker/deserializers.go index 28f4d698f9e..8b1604a4516 100644 --- a/service/sagemaker/deserializers.go +++ b/service/sagemaker/deserializers.go @@ -21683,6 +21683,9 @@ func awsAwsjson11_deserializeOpErrorListInferenceRecommendationsJobSteps(respons } switch { + case strings.EqualFold("ResourceNotFound", errorCode): + return awsAwsjson11_deserializeErrorResourceNotFound(response, errorBody) + default: genericError := &smithy.GenericAPIError{ Code: errorCode, @@ -48400,6 +48403,15 @@ func awsAwsjson11_deserializeDocumentInferenceRecommendation(v **types.Inference return err } + case "RecommendationId": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected String to be of type string, got %T instead", value) + } + sv.RecommendationId = ptr.String(jtv) + } + default: _, _ = key, value @@ -52249,6 +52261,15 @@ func awsAwsjson11_deserializeDocumentModelConfiguration(v **types.ModelConfigura for key, value := range shape { switch key { + case "CompilationJobName": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected RecommendationJobCompilationJobName to be of type string, got %T instead", value) + } + sv.CompilationJobName = ptr.String(jtv) + } + case "EnvironmentParameters": if err := awsAwsjson11_deserializeDocumentEnvironmentParameters(&sv.EnvironmentParameters, value); err != nil { return err @@ -62476,6 +62497,15 @@ func awsAwsjson11_deserializeDocumentRecommendationJobContainerConfig(v **types. for key, value := range shape { switch key { + case "DataInputConfig": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected RecommendationJobDataInputConfig to be of type string, got %T instead", value) + } + sv.DataInputConfig = ptr.String(jtv) + } + case "Domain": if value != nil { jtv, ok := value.(string) @@ -62645,6 +62675,15 @@ func awsAwsjson11_deserializeDocumentRecommendationJobInputConfig(v **types.Reco sv.JobDurationInSeconds = ptr.Int32(int32(i64)) } + case "ModelName": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected ModelName to be of type string, got %T instead", value) + } + sv.ModelName = ptr.String(jtv) + } + case "ModelPackageVersionArn": if value != nil { jtv, ok := value.(string) @@ -63113,6 +63152,40 @@ func awsAwsjson11_deserializeDocumentRecommendationMetrics(v **types.Recommendat } } + case "CpuUtilization": + if value != nil { + switch jtv := value.(type) { + case json.Number: + f64, err := jtv.Float64() + if err != nil { + return err + } + sv.CpuUtilization = ptr.Float32(float32(f64)) + + case string: + var f64 float64 + switch { + case strings.EqualFold(jtv, "NaN"): + f64 = math.NaN() + + case strings.EqualFold(jtv, "Infinity"): + f64 = math.Inf(1) + + case strings.EqualFold(jtv, "-Infinity"): + f64 = math.Inf(-1) + + default: + return fmt.Errorf("unknown JSON number value: %s", jtv) + + } + sv.CpuUtilization = ptr.Float32(float32(f64)) + + default: + return fmt.Errorf("expected UtilizationMetric to be a JSON Number, got %T instead", value) + + } + } + case "MaxInvocations": if value != nil { jtv, ok := value.(json.Number) @@ -63126,6 +63199,40 @@ func awsAwsjson11_deserializeDocumentRecommendationMetrics(v **types.Recommendat sv.MaxInvocations = int32(i64) } + case "MemoryUtilization": + if value != nil { + switch jtv := value.(type) { + case json.Number: + f64, err := jtv.Float64() + if err != nil { + return err + } + sv.MemoryUtilization = ptr.Float32(float32(f64)) + + case string: + var f64 float64 + switch { + case strings.EqualFold(jtv, "NaN"): + f64 = math.NaN() + + case strings.EqualFold(jtv, "Infinity"): + f64 = math.Inf(1) + + case strings.EqualFold(jtv, "-Infinity"): + f64 = math.Inf(-1) + + default: + return fmt.Errorf("unknown JSON number value: %s", jtv) + + } + sv.MemoryUtilization = ptr.Float32(float32(f64)) + + default: + return fmt.Errorf("expected UtilizationMetric to be a JSON Number, got %T instead", value) + + } + } + case "ModelLatency": if value != nil { jtv, ok := value.(json.Number) diff --git a/service/sagemaker/internal/endpoints/endpoints.go b/service/sagemaker/internal/endpoints/endpoints.go index 370414fecca..5382943c591 100644 --- a/service/sagemaker/internal/endpoints/endpoints.go +++ b/service/sagemaker/internal/endpoints/endpoints.go @@ -391,6 +391,9 @@ var defaultPartitions = endpoints.Partitions{ RegionRegex: partitionRegexp.AwsUsGov, IsRegionalized: true, Endpoints: endpoints.Endpoints{ + endpoints.EndpointKey{ + Region: "us-gov-east-1", + }: endpoints.Endpoint{}, endpoints.EndpointKey{ Region: "us-gov-west-1", }: endpoints.Endpoint{}, diff --git a/service/sagemaker/serializers.go b/service/sagemaker/serializers.go index 855f2d4161a..83108595be8 100644 --- a/service/sagemaker/serializers.go +++ b/service/sagemaker/serializers.go @@ -23254,6 +23254,11 @@ func awsAwsjson11_serializeDocumentRecommendationJobContainerConfig(v *types.Rec object := value.Object() defer object.Close() + if v.DataInputConfig != nil { + ok := object.Key("DataInputConfig") + ok.String(*v.DataInputConfig) + } + if v.Domain != nil { ok := object.Key("Domain") ok.String(*v.Domain) @@ -23326,6 +23331,11 @@ func awsAwsjson11_serializeDocumentRecommendationJobInputConfig(v *types.Recomme ok.Integer(*v.JobDurationInSeconds) } + if v.ModelName != nil { + ok := object.Key("ModelName") + ok.String(*v.ModelName) + } + if v.ModelPackageVersionArn != nil { ok := object.Key("ModelPackageVersionArn") ok.String(*v.ModelPackageVersionArn) diff --git a/service/sagemaker/types/types.go b/service/sagemaker/types/types.go index edf4f111df5..cb97806774a 100644 --- a/service/sagemaker/types/types.go +++ b/service/sagemaker/types/types.go @@ -7454,6 +7454,9 @@ type InferenceRecommendation struct { // This member is required. ModelConfiguration *ModelConfiguration + // The recommendation ID which uniquely identifies each recommendation. + RecommendationId *string + noSmithyDocumentSerde } @@ -8835,6 +8838,9 @@ type ModelClientConfig struct { // parameters. type ModelConfiguration struct { + // The name of the compilation job used to create the recommended model artifacts. + CompilationJobName *string + // Defines the environment parameters that includes key, value types, and values. EnvironmentParameters []EnvironmentParameter @@ -12620,6 +12626,12 @@ type RecommendationJobCompiledOutputConfig struct { // for the recommendation job but don't want to edit them in your model package. type RecommendationJobContainerConfig struct { + // Specifies the name and shape of the expected data inputs for your trained model + // with a JSON dictionary form. This field is used for optimizing your model using + // SageMaker Neo. For more information, see DataInputConfig + // (https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_InputConfig.html#sagemaker-Type-InputConfig-DataInputConfig). + DataInputConfig *string + // The machine learning domain of the model and its components. Valid Values: // COMPUTER_VISION | NATURAL_LANGUAGE_PROCESSING | MACHINE_LEARNING Domain *string @@ -12678,11 +12690,6 @@ type RecommendationJobInferenceBenchmark struct { // The input configuration of the recommendation job. type RecommendationJobInputConfig struct { - // The Amazon Resource Name (ARN) of a versioned model package. - // - // This member is required. - ModelPackageVersionArn *string - // Specifies mandatory fields for running an Inference Recommender job. The fields // specified in ContainerConfig override the corresponding fields in the model // package. @@ -12697,6 +12704,12 @@ type RecommendationJobInputConfig struct { // Specifies the maximum duration of the job, in seconds.> JobDurationInSeconds *int32 + // The name of the created model. + ModelName *string + + // The Amazon Resource Name (ARN) of a versioned model package. + ModelPackageVersionArn *string + // Defines the resource limit of the job. ResourceLimit *RecommendationJobResourceLimit @@ -12855,6 +12868,14 @@ type RecommendationMetrics struct { // This member is required. ModelLatency int32 + // The expected CPU utilization at maximum invocations per minute for the instance. + // NaN indicates that the value is not available. + CpuUtilization *float32 + + // The expected memory utilization at maximum invocations per minute for the + // instance. NaN indicates that the value is not available. + MemoryUtilization *float32 + noSmithyDocumentSerde } diff --git a/service/sagemaker/validators.go b/service/sagemaker/validators.go index ad4c433d4f9..db370948ff9 100644 --- a/service/sagemaker/validators.go +++ b/service/sagemaker/validators.go @@ -9924,9 +9924,6 @@ func validateRecommendationJobInputConfig(v *types.RecommendationJobInputConfig) return nil } invalidParams := smithy.InvalidParamsError{Context: "RecommendationJobInputConfig"} - if v.ModelPackageVersionArn == nil { - invalidParams.Add(smithy.NewErrParamRequired("ModelPackageVersionArn")) - } if v.EndpointConfigurations != nil { if err := validateEndpointInputConfigurations(v.EndpointConfigurations); err != nil { invalidParams.AddNested("EndpointConfigurations", err.(smithy.InvalidParamsError)) diff --git a/service/sts/api_op_AssumeRole.go b/service/sts/api_op_AssumeRole.go index f4f4f46f442..4cbb046b62b 100644 --- a/service/sts/api_op_AssumeRole.go +++ b/service/sts/api_op_AssumeRole.go @@ -12,12 +12,11 @@ import ( ) // Returns a set of temporary security credentials that you can use to access -// Amazon Web Services resources that you might not normally have access to. These -// temporary credentials consist of an access key ID, a secret access key, and a -// security token. Typically, you use AssumeRole within your account or for -// cross-account access. For a comparison of AssumeRole with other API operations -// that produce temporary credentials, see Requesting Temporary Security -// Credentials +// Amazon Web Services resources. These temporary credentials consist of an access +// key ID, a secret access key, and a security token. Typically, you use AssumeRole +// within your account or for cross-account access. For a comparison of AssumeRole +// with other API operations that produce temporary credentials, see Requesting +// Temporary Security Credentials // (https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_request.html) // and Comparing the Amazon Web Services STS API operations // (https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_request.html#stsapi_comparison) diff --git a/service/sts/api_op_GetFederationToken.go b/service/sts/api_op_GetFederationToken.go index 60026a13939..8acb5acaacb 100644 --- a/service/sts/api_op_GetFederationToken.go +++ b/service/sts/api_op_GetFederationToken.go @@ -43,16 +43,17 @@ import ( // Temporary credentials obtained by using the Amazon Web Services account root // user credentials have a maximum duration of 3,600 seconds (1 hour). Permissions // You can use the temporary credentials created by GetFederationToken in any -// Amazon Web Services service except the following: +// Amazon Web Services service with the following exceptions: // -// * You cannot call any IAM -// operations using the CLI or the Amazon Web Services API. +// * You cannot call +// any IAM operations using the CLI or the Amazon Web Services API. This limitation +// does not apply to console sessions. // -// * You cannot call any -// STS operations except GetCallerIdentity. +// * You cannot call any STS operations except +// GetCallerIdentity. // -// You must pass an inline or managed -// session policy +// You can use temporary credentials for single sign-on (SSO) +// to the console. You must pass an inline or managed session policy // (https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html#policies_session) // to this operation. You can pass a single JSON policy document to use as an // inline session policy. You can also specify up to 10 managed policy Amazon