diff --git a/go.mod b/go.mod index 7972e144e..98598a8e7 100644 --- a/go.mod +++ b/go.mod @@ -8,12 +8,12 @@ require ( github.com/AlecAivazis/survey/v2 v2.3.7 github.com/Masterminds/semver v1.5.0 github.com/Masterminds/sprig/v3 v3.3.0 - github.com/aws/aws-sdk-go-v2 v1.41.1 + github.com/aws/aws-sdk-go-v2 v1.41.3 github.com/aws/aws-sdk-go-v2/config v1.32.7 - github.com/aws/aws-sdk-go-v2/service/ec2 v1.285.0 + github.com/aws/aws-sdk-go-v2/service/ec2 v1.294.0 github.com/aws/aws-sdk-go-v2/service/eks v1.80.0 github.com/aws/aws-sdk-go-v2/service/sts v1.41.6 - github.com/aws/smithy-go v1.24.1 + github.com/aws/smithy-go v1.24.2 github.com/bbalet/stopwords v1.0.0 github.com/bgentry/go-netrc v0.0.0-20140422174119-9fd32a8b3d3d github.com/enescakir/emoji v1.0.0 @@ -107,13 +107,13 @@ require ( github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.7.4 // indirect github.com/aws/aws-sdk-go-v2/credentials v1.19.7 // indirect github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.18.17 // indirect - github.com/aws/aws-sdk-go-v2/internal/configsources v1.4.17 // indirect - github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.7.17 // indirect + github.com/aws/aws-sdk-go-v2/internal/configsources v1.4.19 // indirect + github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.7.19 // indirect github.com/aws/aws-sdk-go-v2/internal/ini v1.8.4 // indirect github.com/aws/aws-sdk-go-v2/internal/v4a v1.4.16 // indirect - github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.4 // indirect + github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.6 // indirect github.com/aws/aws-sdk-go-v2/service/internal/checksum v1.9.7 // indirect - github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.13.17 // indirect + github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.13.19 // indirect github.com/aws/aws-sdk-go-v2/service/internal/s3shared v1.19.16 // indirect github.com/aws/aws-sdk-go-v2/service/s3 v1.95.0 // indirect github.com/aws/aws-sdk-go-v2/service/signin v1.0.5 // indirect diff --git a/go.sum b/go.sum index 09f1a9240..c9b429be7 100644 --- a/go.sum +++ b/go.sum @@ -104,8 +104,8 @@ github.com/ashanbrown/forbidigo v1.6.0 h1:D3aewfM37Yb3pxHujIPSpTf6oQk9sc9WZi8ger github.com/ashanbrown/forbidigo v1.6.0/go.mod h1:Y8j9jy9ZYAEHXdu723cUlraTqbzjKF1MUyfOKL+AjcU= github.com/ashanbrown/makezero v1.2.0 h1:/2Lp1bypdmK9wDIq7uWBlDF1iMUpIIS4A+pF6C9IEUU= github.com/ashanbrown/makezero v1.2.0/go.mod h1:dxlPhHbDMC6N6xICzFBSK+4njQDdK8euNO0qjQMtGY4= -github.com/aws/aws-sdk-go-v2 v1.41.1 h1:ABlyEARCDLN034NhxlRUSZr4l71mh+T5KAeGh6cerhU= -github.com/aws/aws-sdk-go-v2 v1.41.1/go.mod h1:MayyLB8y+buD9hZqkCW3kX1AKq07Y5pXxtgB+rRFhz0= +github.com/aws/aws-sdk-go-v2 v1.41.3 h1:4kQ/fa22KjDt13QCy1+bYADvdgcxpfH18f0zP542kZA= +github.com/aws/aws-sdk-go-v2 v1.41.3/go.mod h1:mwsPRE8ceUUpiTgF7QmQIJ7lgsKUPQOUl3o72QBrE1o= github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.7.4 h1:489krEF9xIGkOaaX3CE/Be2uWjiXrkCH6gUX+bZA/BU= github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.7.4/go.mod h1:IOAPF6oT9KCsceNTvvYMNHy0+kMF8akOjeDvPENWxp4= github.com/aws/aws-sdk-go-v2/config v1.32.7 h1:vxUyWGUwmkQ2g19n7JY/9YL8MfAIl7bTesIUykECXmY= @@ -114,24 +114,24 @@ github.com/aws/aws-sdk-go-v2/credentials v1.19.7 h1:tHK47VqqtJxOymRrNtUXN5SP/zUT github.com/aws/aws-sdk-go-v2/credentials v1.19.7/go.mod h1:qOZk8sPDrxhf+4Wf4oT2urYJrYt3RejHSzgAquYeppw= github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.18.17 h1:I0GyV8wiYrP8XpA70g1HBcQO1JlQxCMTW9npl5UbDHY= github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.18.17/go.mod h1:tyw7BOl5bBe/oqvoIeECFJjMdzXoa/dfVz3QQ5lgHGA= -github.com/aws/aws-sdk-go-v2/internal/configsources v1.4.17 h1:xOLELNKGp2vsiteLsvLPwxC+mYmO6OZ8PYgiuPJzF8U= -github.com/aws/aws-sdk-go-v2/internal/configsources v1.4.17/go.mod h1:5M5CI3D12dNOtH3/mk6minaRwI2/37ifCURZISxA/IQ= -github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.7.17 h1:WWLqlh79iO48yLkj1v3ISRNiv+3KdQoZ6JWyfcsyQik= -github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.7.17/go.mod h1:EhG22vHRrvF8oXSTYStZhJc1aUgKtnJe+aOiFEV90cM= +github.com/aws/aws-sdk-go-v2/internal/configsources v1.4.19 h1:/sECfyq2JTifMI2JPyZ4bdRN77zJmr6SrS1eL3augIA= +github.com/aws/aws-sdk-go-v2/internal/configsources v1.4.19/go.mod h1:dMf8A5oAqr9/oxOfLkC/c2LU/uMcALP0Rgn2BD5LWn0= +github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.7.19 h1:AWeJMk33GTBf6J20XJe6qZoRSJo0WfUhsMdUKhoODXE= +github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.7.19/go.mod h1:+GWrYoaAsV7/4pNHpwh1kiNLXkKaSoppxQq9lbH8Ejw= github.com/aws/aws-sdk-go-v2/internal/ini v1.8.4 h1:WKuaxf++XKWlHWu9ECbMlha8WOEGm0OUEZqm4K/Gcfk= github.com/aws/aws-sdk-go-v2/internal/ini v1.8.4/go.mod h1:ZWy7j6v1vWGmPReu0iSGvRiise4YI5SkR3OHKTZ6Wuc= github.com/aws/aws-sdk-go-v2/internal/v4a v1.4.16 h1:CjMzUs78RDDv4ROu3JnJn/Ig1r6ZD7/T2DXLLRpejic= github.com/aws/aws-sdk-go-v2/internal/v4a v1.4.16/go.mod h1:uVW4OLBqbJXSHJYA9svT9BluSvvwbzLQ2Crf6UPzR3c= -github.com/aws/aws-sdk-go-v2/service/ec2 v1.285.0 h1:cRZQsqCy59DSJmvmUYzi9K+dutysXzfx6F+fkcIHtOk= -github.com/aws/aws-sdk-go-v2/service/ec2 v1.285.0/go.mod h1:Uy+C+Sc58jozdoL1McQr8bDsEvNFx+/nBY+vpO1HVUY= +github.com/aws/aws-sdk-go-v2/service/ec2 v1.294.0 h1:776KnBqePBBR6zEDi0bUIHXzUBOISa2WgAKEgckUF8M= +github.com/aws/aws-sdk-go-v2/service/ec2 v1.294.0/go.mod h1:rB577GvkmJADVOFGY8/j9sPv/ewcsEtQNsd9Lrn7Zx0= github.com/aws/aws-sdk-go-v2/service/eks v1.80.0 h1:moQGV8cPbVTN7r2Xte1Mybku35QDePSJEd3onYVmBtY= github.com/aws/aws-sdk-go-v2/service/eks v1.80.0/go.mod h1:Qg678m+87sCuJhcsZojenz8mblYG+Tq86V4m3hjVz0s= -github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.4 h1:0ryTNEdJbzUCEWkVXEXoqlXV72J5keC1GvILMOuD00E= -github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.4/go.mod h1:HQ4qwNZh32C3CBeO6iJLQlgtMzqeG17ziAA/3KDJFow= +github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.6 h1:XAq62tBTJP/85lFD5oqOOe7YYgWxY9LvWq8plyDvDVg= +github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.6/go.mod h1:x0nZssQ3qZSnIcePWLvcoFisRXJzcTVvYpAAdYX8+GI= github.com/aws/aws-sdk-go-v2/service/internal/checksum v1.9.7 h1:DIBqIrJ7hv+e4CmIk2z3pyKT+3B6qVMgRsawHiR3qso= github.com/aws/aws-sdk-go-v2/service/internal/checksum v1.9.7/go.mod h1:vLm00xmBke75UmpNvOcZQ/Q30ZFjbczeLFqGx5urmGo= -github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.13.17 h1:RuNSMoozM8oXlgLG/n6WLaFGoea7/CddrCfIiSA+xdY= -github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.13.17/go.mod h1:F2xxQ9TZz5gDWsclCtPQscGpP0VUOc8RqgFM3vDENmU= +github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.13.19 h1:X1Tow7suZk9UCJHE1Iw9GMZJJl0dAnKXXP1NaSDHwmw= +github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.13.19/go.mod h1:/rARO8psX+4sfjUQXp5LLifjUt8DuATZ31WptNJTyQA= github.com/aws/aws-sdk-go-v2/service/internal/s3shared v1.19.16 h1:NSbvS17MlI2lurYgXnCOLvCFX38sBW4eiVER7+kkgsU= github.com/aws/aws-sdk-go-v2/service/internal/s3shared v1.19.16/go.mod h1:SwT8Tmqd4sA6G1qaGdzWCJN99bUmPGHfRwwq3G5Qb+A= github.com/aws/aws-sdk-go-v2/service/s3 v1.95.0 h1:MIWra+MSq53CFaXXAywB2qg9YvVZifkk6vEGl/1Qor0= @@ -144,8 +144,8 @@ github.com/aws/aws-sdk-go-v2/service/ssooidc v1.35.13 h1:gd84Omyu9JLriJVCbGApcLz github.com/aws/aws-sdk-go-v2/service/ssooidc v1.35.13/go.mod h1:sTGThjphYE4Ohw8vJiRStAcu3rbjtXRsdNB0TvZ5wwo= github.com/aws/aws-sdk-go-v2/service/sts v1.41.6 h1:5fFjR/ToSOzB2OQ/XqWpZBmNvmP/pJ1jOWYlFDJTjRQ= github.com/aws/aws-sdk-go-v2/service/sts v1.41.6/go.mod h1:qgFDZQSD/Kys7nJnVqYlWKnh0SSdMjAi0uSwON4wgYQ= -github.com/aws/smithy-go v1.24.1 h1:VbyeNfmYkWoxMVpGUAbQumkODcYmfMRfZ8yQiH30SK0= -github.com/aws/smithy-go v1.24.1/go.mod h1:LEj2LM3rBRQJxPZTB4KuzZkaZYnZPnvgIhb4pu07mx0= +github.com/aws/smithy-go v1.24.2 h1:FzA3bu/nt/vDvmnkg+R8Xl46gmzEDam6mZ1hzmwXFng= +github.com/aws/smithy-go v1.24.2/go.mod h1:YE2RhdIuDbA5E5bTdciG9KrW3+TiEONeUWCqxX9i1Fc= github.com/bbalet/stopwords v1.0.0 h1:0TnGycCtY0zZi4ltKoOGRFIlZHv0WqpoIGUsObjztfo= github.com/bbalet/stopwords v1.0.0/go.mod h1:sAWrQoDMfqARGIn4s6dp7OW7ISrshUD8IP2q3KoqPjc= github.com/beorn7/perks v0.0.0-20180321164747-3a771d992973/go.mod h1:Dwedo/Wpr24TaqPxmxbtue+5NUziq4I4S80YR8gNf3Q= diff --git a/vendor/github.com/aws/aws-sdk-go-v2/aws/go_module_metadata.go b/vendor/github.com/aws/aws-sdk-go-v2/aws/go_module_metadata.go index 0e6fb65a1..cc5140b70 100644 --- a/vendor/github.com/aws/aws-sdk-go-v2/aws/go_module_metadata.go +++ b/vendor/github.com/aws/aws-sdk-go-v2/aws/go_module_metadata.go @@ -3,4 +3,4 @@ package aws // goModuleVersion is the tagged release for this module -const goModuleVersion = "1.41.1" +const goModuleVersion = "1.41.3" diff --git a/vendor/github.com/aws/aws-sdk-go-v2/internal/configsources/CHANGELOG.md b/vendor/github.com/aws/aws-sdk-go-v2/internal/configsources/CHANGELOG.md index 552fb90a8..71066a9c6 100644 --- a/vendor/github.com/aws/aws-sdk-go-v2/internal/configsources/CHANGELOG.md +++ b/vendor/github.com/aws/aws-sdk-go-v2/internal/configsources/CHANGELOG.md @@ -1,3 +1,13 @@ +# v1.4.19 (2026-03-03) + +* **Bug Fix**: Modernize non codegen files with go fix +* **Dependency Update**: Bump minimum Go version to 1.24 +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.4.18 (2026-02-23) + +* **Dependency Update**: Updated to the latest SDK module versions + # v1.4.17 (2026-01-09) * **Dependency Update**: Updated to the latest SDK module versions diff --git a/vendor/github.com/aws/aws-sdk-go-v2/internal/configsources/config.go b/vendor/github.com/aws/aws-sdk-go-v2/internal/configsources/config.go index cd4d19b89..bd731e5f5 100644 --- a/vendor/github.com/aws/aws-sdk-go-v2/internal/configsources/config.go +++ b/vendor/github.com/aws/aws-sdk-go-v2/internal/configsources/config.go @@ -14,7 +14,7 @@ type EnableEndpointDiscoveryProvider interface { // ResolveEnableEndpointDiscovery extracts the first instance of a EnableEndpointDiscoveryProvider from the config slice. // Additionally returns a aws.EndpointDiscoveryEnableState to indicate if the value was found in provided configs, // and error if one is encountered. -func ResolveEnableEndpointDiscovery(ctx context.Context, configs []interface{}) (value aws.EndpointDiscoveryEnableState, found bool, err error) { +func ResolveEnableEndpointDiscovery(ctx context.Context, configs []any) (value aws.EndpointDiscoveryEnableState, found bool, err error) { for _, cfg := range configs { if p, ok := cfg.(EnableEndpointDiscoveryProvider); ok { value, found, err = p.GetEnableEndpointDiscovery(ctx) @@ -33,7 +33,7 @@ type UseDualStackEndpointProvider interface { // ResolveUseDualStackEndpoint extracts the first instance of a UseDualStackEndpoint from the config slice. // Additionally returns a boolean to indicate if the value was found in provided configs, and error if one is encountered. -func ResolveUseDualStackEndpoint(ctx context.Context, configs []interface{}) (value aws.DualStackEndpointState, found bool, err error) { +func ResolveUseDualStackEndpoint(ctx context.Context, configs []any) (value aws.DualStackEndpointState, found bool, err error) { for _, cfg := range configs { if p, ok := cfg.(UseDualStackEndpointProvider); ok { value, found, err = p.GetUseDualStackEndpoint(ctx) @@ -52,7 +52,7 @@ type UseFIPSEndpointProvider interface { // ResolveUseFIPSEndpoint extracts the first instance of a UseFIPSEndpointProvider from the config slice. // Additionally, returns a boolean to indicate if the value was found in provided configs, and error if one is encountered. -func ResolveUseFIPSEndpoint(ctx context.Context, configs []interface{}) (value aws.FIPSEndpointState, found bool, err error) { +func ResolveUseFIPSEndpoint(ctx context.Context, configs []any) (value aws.FIPSEndpointState, found bool, err error) { for _, cfg := range configs { if p, ok := cfg.(UseFIPSEndpointProvider); ok { value, found, err = p.GetUseFIPSEndpoint(ctx) diff --git a/vendor/github.com/aws/aws-sdk-go-v2/internal/configsources/endpoints.go b/vendor/github.com/aws/aws-sdk-go-v2/internal/configsources/endpoints.go index e7835f852..1ebe8f4a8 100644 --- a/vendor/github.com/aws/aws-sdk-go-v2/internal/configsources/endpoints.go +++ b/vendor/github.com/aws/aws-sdk-go-v2/internal/configsources/endpoints.go @@ -26,7 +26,7 @@ type IgnoreConfiguredEndpointsProvider interface { // Currently duplicated from github.com/aws/aws-sdk-go-v2/config because // service packages cannot import github.com/aws/aws-sdk-go-v2/config // due to result import cycle error. -func GetIgnoreConfiguredEndpoints(ctx context.Context, configs []interface{}) (value bool, found bool, err error) { +func GetIgnoreConfiguredEndpoints(ctx context.Context, configs []any) (value bool, found bool, err error) { for _, cfg := range configs { if p, ok := cfg.(IgnoreConfiguredEndpointsProvider); ok { value, found, err = p.GetIgnoreConfiguredEndpoints(ctx) @@ -40,7 +40,7 @@ func GetIgnoreConfiguredEndpoints(ctx context.Context, configs []interface{}) (v // ResolveServiceBaseEndpoint is used to retrieve service endpoints from configured sources // while allowing for configured endpoints to be disabled -func ResolveServiceBaseEndpoint(ctx context.Context, sdkID string, configs []interface{}) (value string, found bool, err error) { +func ResolveServiceBaseEndpoint(ctx context.Context, sdkID string, configs []any) (value string, found bool, err error) { if val, found, _ := GetIgnoreConfiguredEndpoints(ctx, configs); found && val { return "", false, nil } diff --git a/vendor/github.com/aws/aws-sdk-go-v2/internal/configsources/go_module_metadata.go b/vendor/github.com/aws/aws-sdk-go-v2/internal/configsources/go_module_metadata.go index 59dbd389b..c42653ca4 100644 --- a/vendor/github.com/aws/aws-sdk-go-v2/internal/configsources/go_module_metadata.go +++ b/vendor/github.com/aws/aws-sdk-go-v2/internal/configsources/go_module_metadata.go @@ -3,4 +3,4 @@ package configsources // goModuleVersion is the tagged release for this module -const goModuleVersion = "1.4.17" +const goModuleVersion = "1.4.19" diff --git a/vendor/github.com/aws/aws-sdk-go-v2/internal/endpoints/awsrulesfn/partitions.json b/vendor/github.com/aws/aws-sdk-go-v2/internal/endpoints/awsrulesfn/partitions.json index c789264d2..fb9ebb1fa 100644 --- a/vendor/github.com/aws/aws-sdk-go-v2/internal/endpoints/awsrulesfn/partitions.json +++ b/vendor/github.com/aws/aws-sdk-go-v2/internal/endpoints/awsrulesfn/partitions.json @@ -152,7 +152,7 @@ "regionRegex" : "^eusc\\-(de)\\-\\w+\\-\\d+$", "regions" : { "eusc-de-east-1" : { - "description" : "EU (Germany)" + "description" : "AWS European Sovereign Cloud (Germany)" } } }, { diff --git a/vendor/github.com/aws/aws-sdk-go-v2/internal/endpoints/v2/CHANGELOG.md b/vendor/github.com/aws/aws-sdk-go-v2/internal/endpoints/v2/CHANGELOG.md index cdf46e69d..f1ea7ea00 100644 --- a/vendor/github.com/aws/aws-sdk-go-v2/internal/endpoints/v2/CHANGELOG.md +++ b/vendor/github.com/aws/aws-sdk-go-v2/internal/endpoints/v2/CHANGELOG.md @@ -1,3 +1,13 @@ +# v2.7.19 (2026-03-03) + +* **Bug Fix**: Modernize non codegen files with go fix +* **Dependency Update**: Bump minimum Go version to 1.24 +* **Dependency Update**: Updated to the latest SDK module versions + +# v2.7.18 (2026-02-23) + +* **Dependency Update**: Updated to the latest SDK module versions + # v2.7.17 (2026-01-09) * **Dependency Update**: Updated to the latest SDK module versions diff --git a/vendor/github.com/aws/aws-sdk-go-v2/internal/endpoints/v2/endpoints.go b/vendor/github.com/aws/aws-sdk-go-v2/internal/endpoints/v2/endpoints.go index 32251a7e3..b425031cb 100644 --- a/vendor/github.com/aws/aws-sdk-go-v2/internal/endpoints/v2/endpoints.go +++ b/vendor/github.com/aws/aws-sdk-go-v2/internal/endpoints/v2/endpoints.go @@ -101,7 +101,7 @@ func (ps Partitions) ResolveEndpoint(region string, opts Options) (aws.Endpoint, region = opts.ResolvedRegion } - for i := 0; i < len(ps); i++ { + for i := range ps { if !ps[i].canResolveEndpoint(region, opts) { continue } @@ -290,8 +290,8 @@ func getByPriority(s []string, p []string, def string) string { return def } - for i := 0; i < len(p); i++ { - for j := 0; j < len(s); j++ { + for i := range p { + for j := range s { if s[j] == p[i] { return s[j] } diff --git a/vendor/github.com/aws/aws-sdk-go-v2/internal/endpoints/v2/go_module_metadata.go b/vendor/github.com/aws/aws-sdk-go-v2/internal/endpoints/v2/go_module_metadata.go index 3d6ed9c6a..628a5269b 100644 --- a/vendor/github.com/aws/aws-sdk-go-v2/internal/endpoints/v2/go_module_metadata.go +++ b/vendor/github.com/aws/aws-sdk-go-v2/internal/endpoints/v2/go_module_metadata.go @@ -3,4 +3,4 @@ package endpoints // goModuleVersion is the tagged release for this module -const goModuleVersion = "2.7.17" +const goModuleVersion = "2.7.19" diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/CHANGELOG.md b/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/CHANGELOG.md index 6f3ae3876..e659edf76 100644 --- a/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/CHANGELOG.md +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/CHANGELOG.md @@ -1,3 +1,52 @@ +# v1.294.0 (2026-03-05) + +* **Feature**: Added metadata field to CapacityAllocation. + +# v1.293.1 (2026-03-03) + +* **Dependency Update**: Bump minimum Go version to 1.24 +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.293.0 (2026-02-26) + +* **Feature**: Add c8id, m8id and hpc8a instance types. + +# v1.292.0 (2026-02-25) + +* **Feature**: Add support for EC2 Capacity Blocks in Local Zones. + +# v1.291.0 (2026-02-24) + +* **Feature**: Adds httpTokensEnforced property to ModifyInstanceMetadataDefaults API. Set per account or manage organization-wide using declarative policies to prevent IMDSv1-enabled instance launch and block attempts to enable IMDSv1 on existing IMDSv2-only instances. + +# v1.290.1 (2026-02-23) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.290.0 (2026-02-17) + +* **Feature**: Add Operator field to CreatePlacementGroup and DescribePlacementGroup APIs. + +# v1.289.1 (2026-02-16) + +* **Documentation**: Documentation updates for EC2 Secondary Networks + +# v1.289.0 (2026-02-13) + +* **Feature**: This release adds geography information to EC2 region and availability zone APIs. DescribeRegions now includes a Geography field, while DescribeAvailabilityZones includes both Geography and SubGeography fields, enabling better geographic classification for AWS regions and zones. + +# v1.288.0 (2026-02-12) + +* **Feature**: Launching nested virtualization. This feature allows you to run nested VMs inside virtual (non-bare metal) EC2 instances. + +# v1.287.0 (2026-02-11) + +* **Feature**: R8i instances powered by custom Intel Xeon 6 processors available only on AWS with sustained all-core 3.9 GHz turbo frequency + +# v1.286.0 (2026-02-10) + +* **Feature**: Amazon Secondary Networks is a networking feature that provides high-performance, low-latency connectivity for specialized workloads. + # v1.285.0 (2026-01-29) * **Feature**: G7e instances feature up to 8 NVIDIA RTX PRO 6000 Blackwell Server Edition GPUs with 768 GB of memory and 5th generation Intel Xeon Scalable processors. Supporting up to 192 vCPUs, 1600 Gbps networking bandwidth with EFA, up to 2 TiB of system memory, and up to 15.2 TB of local NVMe SSD storage. diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/api_op_CreatePlacementGroup.go b/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/api_op_CreatePlacementGroup.go index 3ee74ecee..4f9e6626a 100644 --- a/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/api_op_CreatePlacementGroup.go +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/api_op_CreatePlacementGroup.go @@ -56,6 +56,9 @@ type CreatePlacementGroupInput struct { // Reserved for future use. LinkedGroupId *string + // Reserved for internal use. + Operator *types.OperatorRequest + // The number of partitions. Valid only when Strategy is set to partition . PartitionCount *int32 diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/api_op_CreateSecondaryNetwork.go b/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/api_op_CreateSecondaryNetwork.go new file mode 100644 index 000000000..cbdbd9d26 --- /dev/null +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/api_op_CreateSecondaryNetwork.go @@ -0,0 +1,221 @@ +// 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/service/ec2/types" + "github.com/aws/smithy-go/middleware" + smithyhttp "github.com/aws/smithy-go/transport/http" +) + +// Creates a secondary network. +// +// The allowed size for a secondary network CIDR block is between /28 netmask (16 +// IP addresses) and /12 netmask (1,048,576 IP addresses). +func (c *Client) CreateSecondaryNetwork(ctx context.Context, params *CreateSecondaryNetworkInput, optFns ...func(*Options)) (*CreateSecondaryNetworkOutput, error) { + if params == nil { + params = &CreateSecondaryNetworkInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "CreateSecondaryNetwork", params, optFns, c.addOperationCreateSecondaryNetworkMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*CreateSecondaryNetworkOutput) + out.ResultMetadata = metadata + return out, nil +} + +type CreateSecondaryNetworkInput struct { + + // The IPv4 CIDR block for the secondary network. The CIDR block size must be + // between /12 and /28. + // + // This member is required. + Ipv4CidrBlock *string + + // The type of secondary network. + // + // This member is required. + NetworkType types.SecondaryNetworkType + + // Unique, case-sensitive identifier that you provide to ensure the idempotency of + // the request. For more information, see [Ensure Idempotency]. + // + // [Ensure Idempotency]: https://docs.aws.amazon.com/ec2/latest/devguide/ec2-api-idempotency.html + ClientToken *string + + // Checks 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 tags to assign to the secondary network. + TagSpecifications []types.TagSpecification + + noSmithyDocumentSerde +} + +type CreateSecondaryNetworkOutput struct { + + // Unique, case-sensitive identifier to ensure the idempotency of the request. + // Only returned if a client token was provided in the request. + ClientToken *string + + // Information about the secondary network. + SecondaryNetwork *types.SecondaryNetwork + + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (c *Client) addOperationCreateSecondaryNetworkMiddlewares(stack *middleware.Stack, options Options) (err error) { + if err := stack.Serialize.Add(&setOperationInputMiddleware{}, middleware.After); err != nil { + return err + } + err = stack.Serialize.Add(&awsEc2query_serializeOpCreateSecondaryNetwork{}, middleware.After) + if err != nil { + return err + } + err = stack.Deserialize.Add(&awsEc2query_deserializeOpCreateSecondaryNetwork{}, middleware.After) + if err != nil { + return err + } + if err := addProtocolFinalizerMiddlewares(stack, options, "CreateSecondaryNetwork"); err != nil { + return fmt.Errorf("add protocol finalizers: %v", err) + } + + if err = addlegacyEndpointContextSetter(stack, options); err != nil { + return err + } + if err = addSetLoggerMiddleware(stack, options); err != nil { + return err + } + if err = addClientRequestID(stack); err != nil { + return err + } + if err = addComputeContentLength(stack); err != nil { + return err + } + if err = addResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = addComputePayloadSHA256(stack); err != nil { + return err + } + if err = addRetry(stack, options); err != nil { + return err + } + if err = addRawResponseToMetadata(stack); err != nil { + return err + } + if err = addRecordResponseTiming(stack); err != nil { + return err + } + if err = addSpanRetryLoop(stack, options); err != nil { + return err + } + if err = addClientUserAgent(stack, options); err != nil { + return err + } + if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil { + return err + } + if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { + return err + } + if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { + return err + } + if err = addTimeOffsetBuild(stack, c); err != nil { + return err + } + if err = addUserAgentRetryMode(stack, options); err != nil { + return err + } + if err = addCredentialSource(stack, options); err != nil { + return err + } + if err = addIdempotencyToken_opCreateSecondaryNetworkMiddleware(stack, options); err != nil { + return err + } + if err = addOpCreateSecondaryNetworkValidationMiddleware(stack); err != nil { + return err + } + if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateSecondaryNetwork(options.Region), middleware.Before); err != nil { + return err + } + if err = addRecursionDetection(stack); 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 + } + if err = addDisableHTTPSMiddleware(stack, options); err != nil { + return err + } + if err = addInterceptBeforeRetryLoop(stack, options); err != nil { + return err + } + if err = addInterceptAttempt(stack, options); err != nil { + return err + } + if err = addInterceptors(stack, options); err != nil { + return err + } + return nil +} + +type idempotencyToken_initializeOpCreateSecondaryNetwork struct { + tokenProvider IdempotencyTokenProvider +} + +func (*idempotencyToken_initializeOpCreateSecondaryNetwork) ID() string { + return "OperationIdempotencyTokenAutoFill" +} + +func (m *idempotencyToken_initializeOpCreateSecondaryNetwork) 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.(*CreateSecondaryNetworkInput) + if !ok { + return out, metadata, fmt.Errorf("expected middleware input to be of type *CreateSecondaryNetworkInput ") + } + + 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_opCreateSecondaryNetworkMiddleware(stack *middleware.Stack, cfg Options) error { + return stack.Initialize.Add(&idempotencyToken_initializeOpCreateSecondaryNetwork{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before) +} + +func newServiceMetadataMiddleware_opCreateSecondaryNetwork(region string) *awsmiddleware.RegisterServiceMetadata { + return &awsmiddleware.RegisterServiceMetadata{ + Region: region, + ServiceID: ServiceID, + OperationName: "CreateSecondaryNetwork", + } +} diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/api_op_CreateSecondarySubnet.go b/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/api_op_CreateSecondarySubnet.go new file mode 100644 index 000000000..dc308e5b2 --- /dev/null +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/api_op_CreateSecondarySubnet.go @@ -0,0 +1,237 @@ +// 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/service/ec2/types" + "github.com/aws/smithy-go/middleware" + smithyhttp "github.com/aws/smithy-go/transport/http" +) + +// Creates a secondary subnet in a secondary network. +// +// A secondary subnet CIDR block must not overlap with the CIDR block of an +// existing secondary subnet in the secondary network. After you create a secondary +// subnet, you can't change its CIDR block. +// +// The allowed size for a secondary subnet CIDR block is between /28 netmask (16 +// IP addresses) and /12 netmask (1,048,576 IP addresses). Amazon reserves the +// first four IP addresses and the last IP address in each secondary subnet for +// internal use. +func (c *Client) CreateSecondarySubnet(ctx context.Context, params *CreateSecondarySubnetInput, optFns ...func(*Options)) (*CreateSecondarySubnetOutput, error) { + if params == nil { + params = &CreateSecondarySubnetInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "CreateSecondarySubnet", params, optFns, c.addOperationCreateSecondarySubnetMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*CreateSecondarySubnetOutput) + out.ResultMetadata = metadata + return out, nil +} + +type CreateSecondarySubnetInput struct { + + // The IPv4 CIDR block for the secondary subnet. The CIDR block size must be + // between /12 and /28. + // + // This member is required. + Ipv4CidrBlock *string + + // The ID of the secondary network in which to create the secondary subnet. + // + // This member is required. + SecondaryNetworkId *string + + // The Availability Zone for the secondary subnet. You cannot specify both + // AvailabilityZone and AvailabilityZoneId in the same request. + AvailabilityZone *string + + // The ID of the Availability Zone for the secondary subnet. This option is + // preferred over AvailabilityZone as it provides a consistent identifier across + // Amazon Web Services accounts. You cannot specify both AvailabilityZone and + // AvailabilityZoneId in the same request. + AvailabilityZoneId *string + + // Unique, case-sensitive identifier that you provide to ensure the idempotency of + // the request. For more information, see [Ensure Idempotency]. + // + // [Ensure Idempotency]: https://docs.aws.amazon.com/ec2/latest/devguide/ec2-api-idempotency.html + ClientToken *string + + // Checks 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 tags to assign to the secondary subnet. + TagSpecifications []types.TagSpecification + + noSmithyDocumentSerde +} + +type CreateSecondarySubnetOutput struct { + + // Unique, case-sensitive identifier to ensure the idempotency of the request. + // Only returned if a client token was provided in the request. + ClientToken *string + + // Information about the secondary subnet. + SecondarySubnet *types.SecondarySubnet + + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (c *Client) addOperationCreateSecondarySubnetMiddlewares(stack *middleware.Stack, options Options) (err error) { + if err := stack.Serialize.Add(&setOperationInputMiddleware{}, middleware.After); err != nil { + return err + } + err = stack.Serialize.Add(&awsEc2query_serializeOpCreateSecondarySubnet{}, middleware.After) + if err != nil { + return err + } + err = stack.Deserialize.Add(&awsEc2query_deserializeOpCreateSecondarySubnet{}, middleware.After) + if err != nil { + return err + } + if err := addProtocolFinalizerMiddlewares(stack, options, "CreateSecondarySubnet"); err != nil { + return fmt.Errorf("add protocol finalizers: %v", err) + } + + if err = addlegacyEndpointContextSetter(stack, options); err != nil { + return err + } + if err = addSetLoggerMiddleware(stack, options); err != nil { + return err + } + if err = addClientRequestID(stack); err != nil { + return err + } + if err = addComputeContentLength(stack); err != nil { + return err + } + if err = addResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = addComputePayloadSHA256(stack); err != nil { + return err + } + if err = addRetry(stack, options); err != nil { + return err + } + if err = addRawResponseToMetadata(stack); err != nil { + return err + } + if err = addRecordResponseTiming(stack); err != nil { + return err + } + if err = addSpanRetryLoop(stack, options); err != nil { + return err + } + if err = addClientUserAgent(stack, options); err != nil { + return err + } + if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil { + return err + } + if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { + return err + } + if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { + return err + } + if err = addTimeOffsetBuild(stack, c); err != nil { + return err + } + if err = addUserAgentRetryMode(stack, options); err != nil { + return err + } + if err = addCredentialSource(stack, options); err != nil { + return err + } + if err = addIdempotencyToken_opCreateSecondarySubnetMiddleware(stack, options); err != nil { + return err + } + if err = addOpCreateSecondarySubnetValidationMiddleware(stack); err != nil { + return err + } + if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateSecondarySubnet(options.Region), middleware.Before); err != nil { + return err + } + if err = addRecursionDetection(stack); 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 + } + if err = addDisableHTTPSMiddleware(stack, options); err != nil { + return err + } + if err = addInterceptBeforeRetryLoop(stack, options); err != nil { + return err + } + if err = addInterceptAttempt(stack, options); err != nil { + return err + } + if err = addInterceptors(stack, options); err != nil { + return err + } + return nil +} + +type idempotencyToken_initializeOpCreateSecondarySubnet struct { + tokenProvider IdempotencyTokenProvider +} + +func (*idempotencyToken_initializeOpCreateSecondarySubnet) ID() string { + return "OperationIdempotencyTokenAutoFill" +} + +func (m *idempotencyToken_initializeOpCreateSecondarySubnet) 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.(*CreateSecondarySubnetInput) + if !ok { + return out, metadata, fmt.Errorf("expected middleware input to be of type *CreateSecondarySubnetInput ") + } + + 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_opCreateSecondarySubnetMiddleware(stack *middleware.Stack, cfg Options) error { + return stack.Initialize.Add(&idempotencyToken_initializeOpCreateSecondarySubnet{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before) +} + +func newServiceMetadataMiddleware_opCreateSecondarySubnet(region string) *awsmiddleware.RegisterServiceMetadata { + return &awsmiddleware.RegisterServiceMetadata{ + Region: region, + ServiceID: ServiceID, + OperationName: "CreateSecondarySubnet", + } +} diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/api_op_DeleteSecondaryNetwork.go b/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/api_op_DeleteSecondaryNetwork.go new file mode 100644 index 000000000..b8761c5b8 --- /dev/null +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/api_op_DeleteSecondaryNetwork.go @@ -0,0 +1,210 @@ +// 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/service/ec2/types" + "github.com/aws/smithy-go/middleware" + smithyhttp "github.com/aws/smithy-go/transport/http" +) + +// Deletes a secondary network. You must delete all secondary subnets in the +// secondary network before you can delete the secondary network. +func (c *Client) DeleteSecondaryNetwork(ctx context.Context, params *DeleteSecondaryNetworkInput, optFns ...func(*Options)) (*DeleteSecondaryNetworkOutput, error) { + if params == nil { + params = &DeleteSecondaryNetworkInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "DeleteSecondaryNetwork", params, optFns, c.addOperationDeleteSecondaryNetworkMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*DeleteSecondaryNetworkOutput) + out.ResultMetadata = metadata + return out, nil +} + +type DeleteSecondaryNetworkInput struct { + + // The ID of the secondary network. + // + // This member is required. + SecondaryNetworkId *string + + // Unique, case-sensitive identifier that you provide to ensure the idempotency of + // the request. For more information, see [Ensure Idempotency]. + // + // [Ensure Idempotency]: https://docs.aws.amazon.com/ec2/latest/devguide/ec2-api-idempotency.html + ClientToken *string + + // Checks 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 DeleteSecondaryNetworkOutput struct { + + // Unique, case-sensitive identifier to ensure the idempotency of the request. + // Only returned if a client token was provided in the request. + ClientToken *string + + // Information about the secondary network. + SecondaryNetwork *types.SecondaryNetwork + + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (c *Client) addOperationDeleteSecondaryNetworkMiddlewares(stack *middleware.Stack, options Options) (err error) { + if err := stack.Serialize.Add(&setOperationInputMiddleware{}, middleware.After); err != nil { + return err + } + err = stack.Serialize.Add(&awsEc2query_serializeOpDeleteSecondaryNetwork{}, middleware.After) + if err != nil { + return err + } + err = stack.Deserialize.Add(&awsEc2query_deserializeOpDeleteSecondaryNetwork{}, middleware.After) + if err != nil { + return err + } + if err := addProtocolFinalizerMiddlewares(stack, options, "DeleteSecondaryNetwork"); err != nil { + return fmt.Errorf("add protocol finalizers: %v", err) + } + + if err = addlegacyEndpointContextSetter(stack, options); err != nil { + return err + } + if err = addSetLoggerMiddleware(stack, options); err != nil { + return err + } + if err = addClientRequestID(stack); err != nil { + return err + } + if err = addComputeContentLength(stack); err != nil { + return err + } + if err = addResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = addComputePayloadSHA256(stack); err != nil { + return err + } + if err = addRetry(stack, options); err != nil { + return err + } + if err = addRawResponseToMetadata(stack); err != nil { + return err + } + if err = addRecordResponseTiming(stack); err != nil { + return err + } + if err = addSpanRetryLoop(stack, options); err != nil { + return err + } + if err = addClientUserAgent(stack, options); err != nil { + return err + } + if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil { + return err + } + if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { + return err + } + if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { + return err + } + if err = addTimeOffsetBuild(stack, c); err != nil { + return err + } + if err = addUserAgentRetryMode(stack, options); err != nil { + return err + } + if err = addCredentialSource(stack, options); err != nil { + return err + } + if err = addIdempotencyToken_opDeleteSecondaryNetworkMiddleware(stack, options); err != nil { + return err + } + if err = addOpDeleteSecondaryNetworkValidationMiddleware(stack); err != nil { + return err + } + if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteSecondaryNetwork(options.Region), middleware.Before); err != nil { + return err + } + if err = addRecursionDetection(stack); 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 + } + if err = addDisableHTTPSMiddleware(stack, options); err != nil { + return err + } + if err = addInterceptBeforeRetryLoop(stack, options); err != nil { + return err + } + if err = addInterceptAttempt(stack, options); err != nil { + return err + } + if err = addInterceptors(stack, options); err != nil { + return err + } + return nil +} + +type idempotencyToken_initializeOpDeleteSecondaryNetwork struct { + tokenProvider IdempotencyTokenProvider +} + +func (*idempotencyToken_initializeOpDeleteSecondaryNetwork) ID() string { + return "OperationIdempotencyTokenAutoFill" +} + +func (m *idempotencyToken_initializeOpDeleteSecondaryNetwork) 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.(*DeleteSecondaryNetworkInput) + if !ok { + return out, metadata, fmt.Errorf("expected middleware input to be of type *DeleteSecondaryNetworkInput ") + } + + 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_opDeleteSecondaryNetworkMiddleware(stack *middleware.Stack, cfg Options) error { + return stack.Initialize.Add(&idempotencyToken_initializeOpDeleteSecondaryNetwork{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before) +} + +func newServiceMetadataMiddleware_opDeleteSecondaryNetwork(region string) *awsmiddleware.RegisterServiceMetadata { + return &awsmiddleware.RegisterServiceMetadata{ + Region: region, + ServiceID: ServiceID, + OperationName: "DeleteSecondaryNetwork", + } +} diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/api_op_DeleteSecondarySubnet.go b/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/api_op_DeleteSecondarySubnet.go new file mode 100644 index 000000000..1d02dd050 --- /dev/null +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/api_op_DeleteSecondarySubnet.go @@ -0,0 +1,210 @@ +// 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/service/ec2/types" + "github.com/aws/smithy-go/middleware" + smithyhttp "github.com/aws/smithy-go/transport/http" +) + +// Deletes a secondary subnet. A secondary subnet must not contain any secondary +// interfaces prior to deletion. +func (c *Client) DeleteSecondarySubnet(ctx context.Context, params *DeleteSecondarySubnetInput, optFns ...func(*Options)) (*DeleteSecondarySubnetOutput, error) { + if params == nil { + params = &DeleteSecondarySubnetInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "DeleteSecondarySubnet", params, optFns, c.addOperationDeleteSecondarySubnetMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*DeleteSecondarySubnetOutput) + out.ResultMetadata = metadata + return out, nil +} + +type DeleteSecondarySubnetInput struct { + + // The ID of the secondary subnet to delete. + // + // This member is required. + SecondarySubnetId *string + + // Unique, case-sensitive identifier that you provide to ensure the idempotency of + // the request. For more information, see [Ensure Idempotency]. + // + // [Ensure Idempotency]: https://docs.aws.amazon.com/ec2/latest/devguide/ec2-api-idempotency.html + ClientToken *string + + // Checks 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 DeleteSecondarySubnetOutput struct { + + // Unique, case-sensitive identifier to ensure the idempotency of the request. + // Only returned if a client token was provided in the request. + ClientToken *string + + // Information about the secondary subnet being deleted. + SecondarySubnet *types.SecondarySubnet + + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (c *Client) addOperationDeleteSecondarySubnetMiddlewares(stack *middleware.Stack, options Options) (err error) { + if err := stack.Serialize.Add(&setOperationInputMiddleware{}, middleware.After); err != nil { + return err + } + err = stack.Serialize.Add(&awsEc2query_serializeOpDeleteSecondarySubnet{}, middleware.After) + if err != nil { + return err + } + err = stack.Deserialize.Add(&awsEc2query_deserializeOpDeleteSecondarySubnet{}, middleware.After) + if err != nil { + return err + } + if err := addProtocolFinalizerMiddlewares(stack, options, "DeleteSecondarySubnet"); err != nil { + return fmt.Errorf("add protocol finalizers: %v", err) + } + + if err = addlegacyEndpointContextSetter(stack, options); err != nil { + return err + } + if err = addSetLoggerMiddleware(stack, options); err != nil { + return err + } + if err = addClientRequestID(stack); err != nil { + return err + } + if err = addComputeContentLength(stack); err != nil { + return err + } + if err = addResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = addComputePayloadSHA256(stack); err != nil { + return err + } + if err = addRetry(stack, options); err != nil { + return err + } + if err = addRawResponseToMetadata(stack); err != nil { + return err + } + if err = addRecordResponseTiming(stack); err != nil { + return err + } + if err = addSpanRetryLoop(stack, options); err != nil { + return err + } + if err = addClientUserAgent(stack, options); err != nil { + return err + } + if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil { + return err + } + if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { + return err + } + if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { + return err + } + if err = addTimeOffsetBuild(stack, c); err != nil { + return err + } + if err = addUserAgentRetryMode(stack, options); err != nil { + return err + } + if err = addCredentialSource(stack, options); err != nil { + return err + } + if err = addIdempotencyToken_opDeleteSecondarySubnetMiddleware(stack, options); err != nil { + return err + } + if err = addOpDeleteSecondarySubnetValidationMiddleware(stack); err != nil { + return err + } + if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteSecondarySubnet(options.Region), middleware.Before); err != nil { + return err + } + if err = addRecursionDetection(stack); 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 + } + if err = addDisableHTTPSMiddleware(stack, options); err != nil { + return err + } + if err = addInterceptBeforeRetryLoop(stack, options); err != nil { + return err + } + if err = addInterceptAttempt(stack, options); err != nil { + return err + } + if err = addInterceptors(stack, options); err != nil { + return err + } + return nil +} + +type idempotencyToken_initializeOpDeleteSecondarySubnet struct { + tokenProvider IdempotencyTokenProvider +} + +func (*idempotencyToken_initializeOpDeleteSecondarySubnet) ID() string { + return "OperationIdempotencyTokenAutoFill" +} + +func (m *idempotencyToken_initializeOpDeleteSecondarySubnet) 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.(*DeleteSecondarySubnetInput) + if !ok { + return out, metadata, fmt.Errorf("expected middleware input to be of type *DeleteSecondarySubnetInput ") + } + + 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_opDeleteSecondarySubnetMiddleware(stack *middleware.Stack, cfg Options) error { + return stack.Initialize.Add(&idempotencyToken_initializeOpDeleteSecondarySubnet{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before) +} + +func newServiceMetadataMiddleware_opDeleteSecondarySubnet(region string) *awsmiddleware.RegisterServiceMetadata { + return &awsmiddleware.RegisterServiceMetadata{ + Region: region, + ServiceID: ServiceID, + OperationName: "DeleteSecondarySubnet", + } +} diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/api_op_DescribeCapacityBlockOfferings.go b/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/api_op_DescribeCapacityBlockOfferings.go index bac56211e..1062adcf8 100644 --- a/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/api_op_DescribeCapacityBlockOfferings.go +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/api_op_DescribeCapacityBlockOfferings.go @@ -41,6 +41,12 @@ type DescribeCapacityBlockOfferingsInput struct { // This member is required. CapacityDurationHours *int32 + // Include all Availability Zones and Local Zones, regardless of your opt-in + // status. If you do not use this parameter, the results include available + // offerings from all Availability Zones in the Amazon Web Services Region and + // Local Zones you are opted into. + AllAvailabilityZones *bool + // Checks 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 diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/api_op_DescribeSecondaryInterfaces.go b/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/api_op_DescribeSecondaryInterfaces.go new file mode 100644 index 000000000..4ea4dfb6c --- /dev/null +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/api_op_DescribeSecondaryInterfaces.go @@ -0,0 +1,308 @@ +// 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/service/ec2/types" + "github.com/aws/smithy-go/middleware" + smithyhttp "github.com/aws/smithy-go/transport/http" +) + +// Describes one or more of your secondary interfaces. +func (c *Client) DescribeSecondaryInterfaces(ctx context.Context, params *DescribeSecondaryInterfacesInput, optFns ...func(*Options)) (*DescribeSecondaryInterfacesOutput, error) { + if params == nil { + params = &DescribeSecondaryInterfacesInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "DescribeSecondaryInterfaces", params, optFns, c.addOperationDescribeSecondaryInterfacesMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*DescribeSecondaryInterfacesOutput) + out.ResultMetadata = metadata + return out, nil +} + +type DescribeSecondaryInterfacesInput struct { + + // Checks 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 filters. + // + // - attachment.attachment-id - The ID of the secondary interface attachment. + // + // - attachment.instance-id - The ID of the instance to which the secondary + // interface is attached. + // + // - attachment.instance-owner-id - The ID of the Amazon Web Services account + // that owns the instance to which the secondary interface is attached. + // + // - attachment.status - The attachment status ( attaching | attached | detaching + // | detached ). + // + // - private-ipv4-addresses.private-ip-address - The private IPv4 address + // associated with the secondary interface. + // + // - owner-id - The ID of the Amazon Web Services account that owns the secondary + // interface. + // + // - secondary-interface-arn - The ARN of the secondary interface. + // + // - secondary-interface-id - The ID of the secondary interface. + // + // - secondary-interface-type - The type of secondary interface ( secondary ). + // + // - secondary-network-id - The ID of the secondary network. + // + // - secondary-network-type - The type of the secondary network ( rdma ). + // + // - secondary-subnet-id - The ID of the secondary subnet. + // + // - status - The status of the secondary interface ( available | in-use ). + // + // - tag : - 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 tag:Owner for the filter name and TeamA for the filter value. + // + // - tag-key - The key of a tag assigned to the resource. Use this filter to find + // all resources assigned a tag with a specific key, regardless of the tag value. + Filters []types.Filter + + // The maximum number of results to return with a single call. To retrieve the + // remaining results, make another call with the returned nextToken value. + MaxResults *int32 + + // The token for the next page of results. + NextToken *string + + // The IDs of the secondary interfaces. + SecondaryInterfaceIds []string + + noSmithyDocumentSerde +} + +type DescribeSecondaryInterfacesOutput struct { + + // The token to use to retrieve the next page of results. This value is null when + // there are no more results to return. + NextToken *string + + // Information about the secondary interfaces. + SecondaryInterfaces []types.SecondaryInterface + + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (c *Client) addOperationDescribeSecondaryInterfacesMiddlewares(stack *middleware.Stack, options Options) (err error) { + if err := stack.Serialize.Add(&setOperationInputMiddleware{}, middleware.After); err != nil { + return err + } + err = stack.Serialize.Add(&awsEc2query_serializeOpDescribeSecondaryInterfaces{}, middleware.After) + if err != nil { + return err + } + err = stack.Deserialize.Add(&awsEc2query_deserializeOpDescribeSecondaryInterfaces{}, middleware.After) + if err != nil { + return err + } + if err := addProtocolFinalizerMiddlewares(stack, options, "DescribeSecondaryInterfaces"); err != nil { + return fmt.Errorf("add protocol finalizers: %v", err) + } + + if err = addlegacyEndpointContextSetter(stack, options); err != nil { + return err + } + if err = addSetLoggerMiddleware(stack, options); err != nil { + return err + } + if err = addClientRequestID(stack); err != nil { + return err + } + if err = addComputeContentLength(stack); err != nil { + return err + } + if err = addResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = addComputePayloadSHA256(stack); err != nil { + return err + } + if err = addRetry(stack, options); err != nil { + return err + } + if err = addRawResponseToMetadata(stack); err != nil { + return err + } + if err = addRecordResponseTiming(stack); err != nil { + return err + } + if err = addSpanRetryLoop(stack, options); err != nil { + return err + } + if err = addClientUserAgent(stack, options); err != nil { + return err + } + if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil { + return err + } + if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { + return err + } + if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { + return err + } + if err = addTimeOffsetBuild(stack, c); err != nil { + return err + } + if err = addUserAgentRetryMode(stack, options); err != nil { + return err + } + if err = addCredentialSource(stack, options); err != nil { + return err + } + if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeSecondaryInterfaces(options.Region), middleware.Before); err != nil { + return err + } + if err = addRecursionDetection(stack); 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 + } + if err = addDisableHTTPSMiddleware(stack, options); err != nil { + return err + } + if err = addInterceptBeforeRetryLoop(stack, options); err != nil { + return err + } + if err = addInterceptAttempt(stack, options); err != nil { + return err + } + if err = addInterceptors(stack, options); err != nil { + return err + } + return nil +} + +// DescribeSecondaryInterfacesPaginatorOptions is the paginator options for +// DescribeSecondaryInterfaces +type DescribeSecondaryInterfacesPaginatorOptions struct { + // The maximum number of results to return with a single call. To retrieve the + // remaining results, make another call with the returned nextToken value. + 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 +} + +// DescribeSecondaryInterfacesPaginator is a paginator for +// DescribeSecondaryInterfaces +type DescribeSecondaryInterfacesPaginator struct { + options DescribeSecondaryInterfacesPaginatorOptions + client DescribeSecondaryInterfacesAPIClient + params *DescribeSecondaryInterfacesInput + nextToken *string + firstPage bool +} + +// NewDescribeSecondaryInterfacesPaginator returns a new +// DescribeSecondaryInterfacesPaginator +func NewDescribeSecondaryInterfacesPaginator(client DescribeSecondaryInterfacesAPIClient, params *DescribeSecondaryInterfacesInput, optFns ...func(*DescribeSecondaryInterfacesPaginatorOptions)) *DescribeSecondaryInterfacesPaginator { + if params == nil { + params = &DescribeSecondaryInterfacesInput{} + } + + options := DescribeSecondaryInterfacesPaginatorOptions{} + if params.MaxResults != nil { + options.Limit = *params.MaxResults + } + + for _, fn := range optFns { + fn(&options) + } + + return &DescribeSecondaryInterfacesPaginator{ + options: options, + client: client, + params: params, + firstPage: true, + nextToken: params.NextToken, + } +} + +// HasMorePages returns a boolean indicating whether more pages are available +func (p *DescribeSecondaryInterfacesPaginator) HasMorePages() bool { + return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0) +} + +// NextPage retrieves the next DescribeSecondaryInterfaces page. +func (p *DescribeSecondaryInterfacesPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*DescribeSecondaryInterfacesOutput, 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 + + optFns = append([]func(*Options){ + addIsPaginatorUserAgent, + }, optFns...) + result, err := p.client.DescribeSecondaryInterfaces(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 +} + +// DescribeSecondaryInterfacesAPIClient is a client that implements the +// DescribeSecondaryInterfaces operation. +type DescribeSecondaryInterfacesAPIClient interface { + DescribeSecondaryInterfaces(context.Context, *DescribeSecondaryInterfacesInput, ...func(*Options)) (*DescribeSecondaryInterfacesOutput, error) +} + +var _ DescribeSecondaryInterfacesAPIClient = (*Client)(nil) + +func newServiceMetadataMiddleware_opDescribeSecondaryInterfaces(region string) *awsmiddleware.RegisterServiceMetadata { + return &awsmiddleware.RegisterServiceMetadata{ + Region: region, + ServiceID: ServiceID, + OperationName: "DescribeSecondaryInterfaces", + } +} diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/api_op_DescribeSecondaryNetworks.go b/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/api_op_DescribeSecondaryNetworks.go new file mode 100644 index 000000000..8028f7586 --- /dev/null +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/api_op_DescribeSecondaryNetworks.go @@ -0,0 +1,739 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package ec2 + +import ( + "context" + "errors" + "fmt" + awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" + "github.com/aws/aws-sdk-go-v2/service/ec2/types" + smithy "github.com/aws/smithy-go" + "github.com/aws/smithy-go/middleware" + smithytime "github.com/aws/smithy-go/time" + smithyhttp "github.com/aws/smithy-go/transport/http" + smithywaiter "github.com/aws/smithy-go/waiter" + "time" +) + +// Describes one or more secondary networks. +func (c *Client) DescribeSecondaryNetworks(ctx context.Context, params *DescribeSecondaryNetworksInput, optFns ...func(*Options)) (*DescribeSecondaryNetworksOutput, error) { + if params == nil { + params = &DescribeSecondaryNetworksInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "DescribeSecondaryNetworks", params, optFns, c.addOperationDescribeSecondaryNetworksMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*DescribeSecondaryNetworksOutput) + out.ResultMetadata = metadata + return out, nil +} + +type DescribeSecondaryNetworksInput struct { + + // Checks 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 filters. The following are the possible values: + // + // - ipv4-cidr-block-association.association-id - The association ID for an IPv4 + // CIDR block associated with the secondary network. + // + // - ipv4-cidr-block-association.cidr-block - An IPv4 CIDR block associated with + // the secondary network. + // + // - ipv4-cidr-block-association.state - The state of an IPv4 CIDR block + // associated with the secondary network. + // + // - owner-id - The ID of the Amazon Web Services account that owns the secondary + // network. + // + // - secondary-network-id - The ID of the secondary network. + // + // - secondary-network-arn - The ARN of the secondary network. + // + // - state - The state of the secondary network ( create-in-progress | + // create-complete | create-failed | delete-in-progress | delete-complete | + // delete-failed ). + // + // - tag : - 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 tag:Owner for the filter name and TeamA for the filter value. + // + // - tag-key - The key of a tag assigned to the resource. Use this filter to find + // all resources assigned a tag with a specific key, regardless of the tag value. + // + // - type - The type of the secondary network ( rdma ). + Filters []types.Filter + + // The maximum number of results to return with a single call. To retrieve the + // remaining results, make another call with the returned nextToken value. + MaxResults *int32 + + // The token for the next page of results. + NextToken *string + + // The IDs of the secondary networks. + SecondaryNetworkIds []string + + noSmithyDocumentSerde +} + +type DescribeSecondaryNetworksOutput struct { + + // The token to use to retrieve the next page of results. This value is null when + // there are no more results to return. + NextToken *string + + // Information about the secondary networks. + SecondaryNetworks []types.SecondaryNetwork + + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (c *Client) addOperationDescribeSecondaryNetworksMiddlewares(stack *middleware.Stack, options Options) (err error) { + if err := stack.Serialize.Add(&setOperationInputMiddleware{}, middleware.After); err != nil { + return err + } + err = stack.Serialize.Add(&awsEc2query_serializeOpDescribeSecondaryNetworks{}, middleware.After) + if err != nil { + return err + } + err = stack.Deserialize.Add(&awsEc2query_deserializeOpDescribeSecondaryNetworks{}, middleware.After) + if err != nil { + return err + } + if err := addProtocolFinalizerMiddlewares(stack, options, "DescribeSecondaryNetworks"); err != nil { + return fmt.Errorf("add protocol finalizers: %v", err) + } + + if err = addlegacyEndpointContextSetter(stack, options); err != nil { + return err + } + if err = addSetLoggerMiddleware(stack, options); err != nil { + return err + } + if err = addClientRequestID(stack); err != nil { + return err + } + if err = addComputeContentLength(stack); err != nil { + return err + } + if err = addResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = addComputePayloadSHA256(stack); err != nil { + return err + } + if err = addRetry(stack, options); err != nil { + return err + } + if err = addRawResponseToMetadata(stack); err != nil { + return err + } + if err = addRecordResponseTiming(stack); err != nil { + return err + } + if err = addSpanRetryLoop(stack, options); err != nil { + return err + } + if err = addClientUserAgent(stack, options); err != nil { + return err + } + if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil { + return err + } + if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { + return err + } + if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { + return err + } + if err = addTimeOffsetBuild(stack, c); err != nil { + return err + } + if err = addUserAgentRetryMode(stack, options); err != nil { + return err + } + if err = addCredentialSource(stack, options); err != nil { + return err + } + if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeSecondaryNetworks(options.Region), middleware.Before); err != nil { + return err + } + if err = addRecursionDetection(stack); 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 + } + if err = addDisableHTTPSMiddleware(stack, options); err != nil { + return err + } + if err = addInterceptBeforeRetryLoop(stack, options); err != nil { + return err + } + if err = addInterceptAttempt(stack, options); err != nil { + return err + } + if err = addInterceptors(stack, options); err != nil { + return err + } + return nil +} + +// SecondaryNetworkCreateCompleteWaiterOptions are waiter options for +// SecondaryNetworkCreateCompleteWaiter +type SecondaryNetworkCreateCompleteWaiterOptions struct { + + // Set of options to modify how an operation is invoked. These apply to all + // operations invoked for this client. Use functional options on operation call to + // modify this list for per operation behavior. + // + // Passing options here is functionally equivalent to passing values to this + // config's ClientOptions field that extend the inner client's APIOptions directly. + APIOptions []func(*middleware.Stack) error + + // Functional options to be passed to all operations invoked by this client. + // + // Function values that modify the inner APIOptions are applied after the waiter + // config's own APIOptions modifiers. + ClientOptions []func(*Options) + + // MinDelay is the minimum amount of time to delay between retries. If unset, + // SecondaryNetworkCreateCompleteWaiter will use default minimum delay of 10 + // seconds. Note that MinDelay must resolve to a value lesser than or equal to the + // MaxDelay. + MinDelay time.Duration + + // MaxDelay is the maximum amount of time to delay between retries. If unset or + // set to zero, SecondaryNetworkCreateCompleteWaiter will use default max delay of + // 120 seconds. Note that MaxDelay must resolve to value greater than or equal to + // the MinDelay. + MaxDelay time.Duration + + // LogWaitAttempts is used to enable logging for waiter retry attempts + LogWaitAttempts bool + + // Retryable is function that can be used to override the service defined + // waiter-behavior based on operation output, or returned error. This function is + // used by the waiter to decide if a state is retryable or a terminal state. + // + // By default service-modeled logic will populate this option. This option can + // thus be used to define a custom waiter state with fall-back to service-modeled + // waiter state mutators.The function returns an error in case of a failure state. + // In case of retry state, this function returns a bool value of true and nil + // error, while in case of success it returns a bool value of false and nil error. + Retryable func(context.Context, *DescribeSecondaryNetworksInput, *DescribeSecondaryNetworksOutput, error) (bool, error) +} + +// SecondaryNetworkCreateCompleteWaiter defines the waiters for +// SecondaryNetworkCreateComplete +type SecondaryNetworkCreateCompleteWaiter struct { + client DescribeSecondaryNetworksAPIClient + + options SecondaryNetworkCreateCompleteWaiterOptions +} + +// NewSecondaryNetworkCreateCompleteWaiter constructs a +// SecondaryNetworkCreateCompleteWaiter. +func NewSecondaryNetworkCreateCompleteWaiter(client DescribeSecondaryNetworksAPIClient, optFns ...func(*SecondaryNetworkCreateCompleteWaiterOptions)) *SecondaryNetworkCreateCompleteWaiter { + options := SecondaryNetworkCreateCompleteWaiterOptions{} + options.MinDelay = 10 * time.Second + options.MaxDelay = 120 * time.Second + options.Retryable = secondaryNetworkCreateCompleteStateRetryable + + for _, fn := range optFns { + fn(&options) + } + return &SecondaryNetworkCreateCompleteWaiter{ + client: client, + options: options, + } +} + +// Wait calls the waiter function for SecondaryNetworkCreateComplete waiter. The +// maxWaitDur is the maximum wait duration the waiter will wait. The maxWaitDur is +// required and must be greater than zero. +func (w *SecondaryNetworkCreateCompleteWaiter) Wait(ctx context.Context, params *DescribeSecondaryNetworksInput, maxWaitDur time.Duration, optFns ...func(*SecondaryNetworkCreateCompleteWaiterOptions)) error { + _, err := w.WaitForOutput(ctx, params, maxWaitDur, optFns...) + return err +} + +// WaitForOutput calls the waiter function for SecondaryNetworkCreateComplete +// waiter and returns the output of the successful operation. The maxWaitDur is the +// maximum wait duration the waiter will wait. The maxWaitDur is required and must +// be greater than zero. +func (w *SecondaryNetworkCreateCompleteWaiter) WaitForOutput(ctx context.Context, params *DescribeSecondaryNetworksInput, maxWaitDur time.Duration, optFns ...func(*SecondaryNetworkCreateCompleteWaiterOptions)) (*DescribeSecondaryNetworksOutput, error) { + if maxWaitDur <= 0 { + return nil, fmt.Errorf("maximum wait time for waiter must be greater than zero") + } + + options := w.options + for _, fn := range optFns { + fn(&options) + } + + if options.MaxDelay <= 0 { + options.MaxDelay = 120 * time.Second + } + + if options.MinDelay > options.MaxDelay { + return nil, fmt.Errorf("minimum waiter delay %v must be lesser than or equal to maximum waiter delay of %v.", options.MinDelay, options.MaxDelay) + } + + ctx, cancelFn := context.WithTimeout(ctx, maxWaitDur) + defer cancelFn() + + logger := smithywaiter.Logger{} + remainingTime := maxWaitDur + + var attempt int64 + for { + + attempt++ + apiOptions := options.APIOptions + start := time.Now() + + if options.LogWaitAttempts { + logger.Attempt = attempt + apiOptions = append([]func(*middleware.Stack) error{}, options.APIOptions...) + apiOptions = append(apiOptions, logger.AddLogger) + } + + out, err := w.client.DescribeSecondaryNetworks(ctx, params, func(o *Options) { + baseOpts := []func(*Options){ + addIsWaiterUserAgent, + } + o.APIOptions = append(o.APIOptions, apiOptions...) + for _, opt := range baseOpts { + opt(o) + } + for _, opt := range options.ClientOptions { + opt(o) + } + }) + + retryable, err := options.Retryable(ctx, params, out, err) + if err != nil { + return nil, err + } + if !retryable { + return out, nil + } + + remainingTime -= time.Since(start) + if remainingTime < options.MinDelay || remainingTime <= 0 { + break + } + + // compute exponential backoff between waiter retries + delay, err := smithywaiter.ComputeDelay( + attempt, options.MinDelay, options.MaxDelay, remainingTime, + ) + if err != nil { + return nil, fmt.Errorf("error computing waiter delay, %w", err) + } + + remainingTime -= delay + // sleep for the delay amount before invoking a request + if err := smithytime.SleepWithContext(ctx, delay); err != nil { + return nil, fmt.Errorf("request cancelled while waiting, %w", err) + } + } + return nil, fmt.Errorf("exceeded max wait time for SecondaryNetworkCreateComplete waiter") +} + +func secondaryNetworkCreateCompleteStateRetryable(ctx context.Context, input *DescribeSecondaryNetworksInput, output *DescribeSecondaryNetworksOutput, err error) (bool, error) { + + if err == nil { + v1 := output.SecondaryNetworks + var v2 []types.SecondaryNetworkState + for _, v := range v1 { + v3 := v.State + v2 = append(v2, v3) + } + expectedValue := "create-complete" + match := len(v2) > 0 + for _, v := range v2 { + if string(v) != expectedValue { + match = false + break + } + } + + if match { + return false, nil + } + } + + if err == nil { + v1 := output.SecondaryNetworks + var v2 []types.SecondaryNetworkState + for _, v := range v1 { + v3 := v.State + v2 = append(v2, v3) + } + expectedValue := "create-failed" + var match bool + for _, v := range v2 { + if string(v) == expectedValue { + match = true + break + } + } + + if match { + return false, fmt.Errorf("waiter state transitioned to Failure") + } + } + + if err != nil { + var apiErr smithy.APIError + ok := errors.As(err, &apiErr) + if !ok { + return false, fmt.Errorf("expected err to be of type smithy.APIError, got %w", err) + } + + if "InvalidSecondaryNetworkId.NotFound" == apiErr.ErrorCode() { + return true, nil + } + } + + if err != nil { + return false, err + } + return true, nil +} + +// SecondaryNetworkDeleteCompleteWaiterOptions are waiter options for +// SecondaryNetworkDeleteCompleteWaiter +type SecondaryNetworkDeleteCompleteWaiterOptions struct { + + // Set of options to modify how an operation is invoked. These apply to all + // operations invoked for this client. Use functional options on operation call to + // modify this list for per operation behavior. + // + // Passing options here is functionally equivalent to passing values to this + // config's ClientOptions field that extend the inner client's APIOptions directly. + APIOptions []func(*middleware.Stack) error + + // Functional options to be passed to all operations invoked by this client. + // + // Function values that modify the inner APIOptions are applied after the waiter + // config's own APIOptions modifiers. + ClientOptions []func(*Options) + + // MinDelay is the minimum amount of time to delay between retries. If unset, + // SecondaryNetworkDeleteCompleteWaiter will use default minimum delay of 10 + // seconds. Note that MinDelay must resolve to a value lesser than or equal to the + // MaxDelay. + MinDelay time.Duration + + // MaxDelay is the maximum amount of time to delay between retries. If unset or + // set to zero, SecondaryNetworkDeleteCompleteWaiter will use default max delay of + // 120 seconds. Note that MaxDelay must resolve to value greater than or equal to + // the MinDelay. + MaxDelay time.Duration + + // LogWaitAttempts is used to enable logging for waiter retry attempts + LogWaitAttempts bool + + // Retryable is function that can be used to override the service defined + // waiter-behavior based on operation output, or returned error. This function is + // used by the waiter to decide if a state is retryable or a terminal state. + // + // By default service-modeled logic will populate this option. This option can + // thus be used to define a custom waiter state with fall-back to service-modeled + // waiter state mutators.The function returns an error in case of a failure state. + // In case of retry state, this function returns a bool value of true and nil + // error, while in case of success it returns a bool value of false and nil error. + Retryable func(context.Context, *DescribeSecondaryNetworksInput, *DescribeSecondaryNetworksOutput, error) (bool, error) +} + +// SecondaryNetworkDeleteCompleteWaiter defines the waiters for +// SecondaryNetworkDeleteComplete +type SecondaryNetworkDeleteCompleteWaiter struct { + client DescribeSecondaryNetworksAPIClient + + options SecondaryNetworkDeleteCompleteWaiterOptions +} + +// NewSecondaryNetworkDeleteCompleteWaiter constructs a +// SecondaryNetworkDeleteCompleteWaiter. +func NewSecondaryNetworkDeleteCompleteWaiter(client DescribeSecondaryNetworksAPIClient, optFns ...func(*SecondaryNetworkDeleteCompleteWaiterOptions)) *SecondaryNetworkDeleteCompleteWaiter { + options := SecondaryNetworkDeleteCompleteWaiterOptions{} + options.MinDelay = 10 * time.Second + options.MaxDelay = 120 * time.Second + options.Retryable = secondaryNetworkDeleteCompleteStateRetryable + + for _, fn := range optFns { + fn(&options) + } + return &SecondaryNetworkDeleteCompleteWaiter{ + client: client, + options: options, + } +} + +// Wait calls the waiter function for SecondaryNetworkDeleteComplete waiter. The +// maxWaitDur is the maximum wait duration the waiter will wait. The maxWaitDur is +// required and must be greater than zero. +func (w *SecondaryNetworkDeleteCompleteWaiter) Wait(ctx context.Context, params *DescribeSecondaryNetworksInput, maxWaitDur time.Duration, optFns ...func(*SecondaryNetworkDeleteCompleteWaiterOptions)) error { + _, err := w.WaitForOutput(ctx, params, maxWaitDur, optFns...) + return err +} + +// WaitForOutput calls the waiter function for SecondaryNetworkDeleteComplete +// waiter and returns the output of the successful operation. The maxWaitDur is the +// maximum wait duration the waiter will wait. The maxWaitDur is required and must +// be greater than zero. +func (w *SecondaryNetworkDeleteCompleteWaiter) WaitForOutput(ctx context.Context, params *DescribeSecondaryNetworksInput, maxWaitDur time.Duration, optFns ...func(*SecondaryNetworkDeleteCompleteWaiterOptions)) (*DescribeSecondaryNetworksOutput, error) { + if maxWaitDur <= 0 { + return nil, fmt.Errorf("maximum wait time for waiter must be greater than zero") + } + + options := w.options + for _, fn := range optFns { + fn(&options) + } + + if options.MaxDelay <= 0 { + options.MaxDelay = 120 * time.Second + } + + if options.MinDelay > options.MaxDelay { + return nil, fmt.Errorf("minimum waiter delay %v must be lesser than or equal to maximum waiter delay of %v.", options.MinDelay, options.MaxDelay) + } + + ctx, cancelFn := context.WithTimeout(ctx, maxWaitDur) + defer cancelFn() + + logger := smithywaiter.Logger{} + remainingTime := maxWaitDur + + var attempt int64 + for { + + attempt++ + apiOptions := options.APIOptions + start := time.Now() + + if options.LogWaitAttempts { + logger.Attempt = attempt + apiOptions = append([]func(*middleware.Stack) error{}, options.APIOptions...) + apiOptions = append(apiOptions, logger.AddLogger) + } + + out, err := w.client.DescribeSecondaryNetworks(ctx, params, func(o *Options) { + baseOpts := []func(*Options){ + addIsWaiterUserAgent, + } + o.APIOptions = append(o.APIOptions, apiOptions...) + for _, opt := range baseOpts { + opt(o) + } + for _, opt := range options.ClientOptions { + opt(o) + } + }) + + retryable, err := options.Retryable(ctx, params, out, err) + if err != nil { + return nil, err + } + if !retryable { + return out, nil + } + + remainingTime -= time.Since(start) + if remainingTime < options.MinDelay || remainingTime <= 0 { + break + } + + // compute exponential backoff between waiter retries + delay, err := smithywaiter.ComputeDelay( + attempt, options.MinDelay, options.MaxDelay, remainingTime, + ) + if err != nil { + return nil, fmt.Errorf("error computing waiter delay, %w", err) + } + + remainingTime -= delay + // sleep for the delay amount before invoking a request + if err := smithytime.SleepWithContext(ctx, delay); err != nil { + return nil, fmt.Errorf("request cancelled while waiting, %w", err) + } + } + return nil, fmt.Errorf("exceeded max wait time for SecondaryNetworkDeleteComplete waiter") +} + +func secondaryNetworkDeleteCompleteStateRetryable(ctx context.Context, input *DescribeSecondaryNetworksInput, output *DescribeSecondaryNetworksOutput, err error) (bool, error) { + + if err == nil { + v1 := output.SecondaryNetworks + var v2 []types.SecondaryNetworkState + for _, v := range v1 { + v3 := v.State + v2 = append(v2, v3) + } + expectedValue := "delete-complete" + match := len(v2) > 0 + for _, v := range v2 { + if string(v) != expectedValue { + match = false + break + } + } + + if match { + return false, nil + } + } + + if err == nil { + v1 := output.SecondaryNetworks + var v2 []types.SecondaryNetworkState + for _, v := range v1 { + v3 := v.State + v2 = append(v2, v3) + } + expectedValue := "delete-failed" + var match bool + for _, v := range v2 { + if string(v) == expectedValue { + match = true + break + } + } + + if match { + return false, fmt.Errorf("waiter state transitioned to Failure") + } + } + + if err != nil { + return false, err + } + return true, nil +} + +// DescribeSecondaryNetworksPaginatorOptions is the paginator options for +// DescribeSecondaryNetworks +type DescribeSecondaryNetworksPaginatorOptions struct { + // The maximum number of results to return with a single call. To retrieve the + // remaining results, make another call with the returned nextToken value. + 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 +} + +// DescribeSecondaryNetworksPaginator is a paginator for DescribeSecondaryNetworks +type DescribeSecondaryNetworksPaginator struct { + options DescribeSecondaryNetworksPaginatorOptions + client DescribeSecondaryNetworksAPIClient + params *DescribeSecondaryNetworksInput + nextToken *string + firstPage bool +} + +// NewDescribeSecondaryNetworksPaginator returns a new +// DescribeSecondaryNetworksPaginator +func NewDescribeSecondaryNetworksPaginator(client DescribeSecondaryNetworksAPIClient, params *DescribeSecondaryNetworksInput, optFns ...func(*DescribeSecondaryNetworksPaginatorOptions)) *DescribeSecondaryNetworksPaginator { + if params == nil { + params = &DescribeSecondaryNetworksInput{} + } + + options := DescribeSecondaryNetworksPaginatorOptions{} + if params.MaxResults != nil { + options.Limit = *params.MaxResults + } + + for _, fn := range optFns { + fn(&options) + } + + return &DescribeSecondaryNetworksPaginator{ + options: options, + client: client, + params: params, + firstPage: true, + nextToken: params.NextToken, + } +} + +// HasMorePages returns a boolean indicating whether more pages are available +func (p *DescribeSecondaryNetworksPaginator) HasMorePages() bool { + return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0) +} + +// NextPage retrieves the next DescribeSecondaryNetworks page. +func (p *DescribeSecondaryNetworksPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*DescribeSecondaryNetworksOutput, 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 + + optFns = append([]func(*Options){ + addIsPaginatorUserAgent, + }, optFns...) + result, err := p.client.DescribeSecondaryNetworks(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 +} + +// DescribeSecondaryNetworksAPIClient is a client that implements the +// DescribeSecondaryNetworks operation. +type DescribeSecondaryNetworksAPIClient interface { + DescribeSecondaryNetworks(context.Context, *DescribeSecondaryNetworksInput, ...func(*Options)) (*DescribeSecondaryNetworksOutput, error) +} + +var _ DescribeSecondaryNetworksAPIClient = (*Client)(nil) + +func newServiceMetadataMiddleware_opDescribeSecondaryNetworks(region string) *awsmiddleware.RegisterServiceMetadata { + return &awsmiddleware.RegisterServiceMetadata{ + Region: region, + ServiceID: ServiceID, + OperationName: "DescribeSecondaryNetworks", + } +} diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/api_op_DescribeSecondarySubnets.go b/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/api_op_DescribeSecondarySubnets.go new file mode 100644 index 000000000..05f6c652f --- /dev/null +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/api_op_DescribeSecondarySubnets.go @@ -0,0 +1,741 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package ec2 + +import ( + "context" + "errors" + "fmt" + awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" + "github.com/aws/aws-sdk-go-v2/service/ec2/types" + smithy "github.com/aws/smithy-go" + "github.com/aws/smithy-go/middleware" + smithytime "github.com/aws/smithy-go/time" + smithyhttp "github.com/aws/smithy-go/transport/http" + smithywaiter "github.com/aws/smithy-go/waiter" + "time" +) + +// Describes one or more of your secondary subnets. +func (c *Client) DescribeSecondarySubnets(ctx context.Context, params *DescribeSecondarySubnetsInput, optFns ...func(*Options)) (*DescribeSecondarySubnetsOutput, error) { + if params == nil { + params = &DescribeSecondarySubnetsInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "DescribeSecondarySubnets", params, optFns, c.addOperationDescribeSecondarySubnetsMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*DescribeSecondarySubnetsOutput) + out.ResultMetadata = metadata + return out, nil +} + +type DescribeSecondarySubnetsInput struct { + + // Checks 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 filters. + // + // - ipv4-cidr-block-association.association-id - The association ID for an IPv4 + // CIDR block associated with the secondary subnet. + // + // - ipv4-cidr-block-association.cidr-block - An IPv4 CIDR block associated with + // the secondary subnet. + // + // - ipv4-cidr-block-association.state - The state of an IPv4 CIDR block + // associated with the secondary subnet. + // + // - owner-id - The ID of the Amazon Web Services account that owns the secondary + // subnet. + // + // - secondary-network-id - The ID of the secondary network. + // + // - secondary-network-type - The type of the secondary network ( rdma ). + // + // - secondary-subnet-id - The ID of the secondary subnet. + // + // - secondary-subnet-arn - The ARN of the secondary subnet. + // + // - state - The state of the secondary subnet ( create-in-progress | + // create-complete | create-failed | delete-in-progress | delete-complete | + // delete-failed ). + // + // - tag : - 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 tag:Owner for the filter name and TeamA for the filter value. + // + // - tag-key - The key of a tag assigned to the resource. Use this filter to find + // all resources assigned a tag with a specific key, regardless of the tag value. + Filters []types.Filter + + // The maximum number of results to return with a single call. To retrieve the + // remaining results, make another call with the returned nextToken value. + MaxResults *int32 + + // The token for the next page of results. + NextToken *string + + // The IDs of the secondary subnets. + SecondarySubnetIds []string + + noSmithyDocumentSerde +} + +type DescribeSecondarySubnetsOutput struct { + + // The token to use to retrieve the next page of results. This value is null when + // there are no more results to return. + NextToken *string + + // Information about the secondary subnets. + SecondarySubnets []types.SecondarySubnet + + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (c *Client) addOperationDescribeSecondarySubnetsMiddlewares(stack *middleware.Stack, options Options) (err error) { + if err := stack.Serialize.Add(&setOperationInputMiddleware{}, middleware.After); err != nil { + return err + } + err = stack.Serialize.Add(&awsEc2query_serializeOpDescribeSecondarySubnets{}, middleware.After) + if err != nil { + return err + } + err = stack.Deserialize.Add(&awsEc2query_deserializeOpDescribeSecondarySubnets{}, middleware.After) + if err != nil { + return err + } + if err := addProtocolFinalizerMiddlewares(stack, options, "DescribeSecondarySubnets"); err != nil { + return fmt.Errorf("add protocol finalizers: %v", err) + } + + if err = addlegacyEndpointContextSetter(stack, options); err != nil { + return err + } + if err = addSetLoggerMiddleware(stack, options); err != nil { + return err + } + if err = addClientRequestID(stack); err != nil { + return err + } + if err = addComputeContentLength(stack); err != nil { + return err + } + if err = addResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = addComputePayloadSHA256(stack); err != nil { + return err + } + if err = addRetry(stack, options); err != nil { + return err + } + if err = addRawResponseToMetadata(stack); err != nil { + return err + } + if err = addRecordResponseTiming(stack); err != nil { + return err + } + if err = addSpanRetryLoop(stack, options); err != nil { + return err + } + if err = addClientUserAgent(stack, options); err != nil { + return err + } + if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil { + return err + } + if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { + return err + } + if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { + return err + } + if err = addTimeOffsetBuild(stack, c); err != nil { + return err + } + if err = addUserAgentRetryMode(stack, options); err != nil { + return err + } + if err = addCredentialSource(stack, options); err != nil { + return err + } + if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeSecondarySubnets(options.Region), middleware.Before); err != nil { + return err + } + if err = addRecursionDetection(stack); 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 + } + if err = addDisableHTTPSMiddleware(stack, options); err != nil { + return err + } + if err = addInterceptBeforeRetryLoop(stack, options); err != nil { + return err + } + if err = addInterceptAttempt(stack, options); err != nil { + return err + } + if err = addInterceptors(stack, options); err != nil { + return err + } + return nil +} + +// SecondarySubnetCreateCompleteWaiterOptions are waiter options for +// SecondarySubnetCreateCompleteWaiter +type SecondarySubnetCreateCompleteWaiterOptions struct { + + // Set of options to modify how an operation is invoked. These apply to all + // operations invoked for this client. Use functional options on operation call to + // modify this list for per operation behavior. + // + // Passing options here is functionally equivalent to passing values to this + // config's ClientOptions field that extend the inner client's APIOptions directly. + APIOptions []func(*middleware.Stack) error + + // Functional options to be passed to all operations invoked by this client. + // + // Function values that modify the inner APIOptions are applied after the waiter + // config's own APIOptions modifiers. + ClientOptions []func(*Options) + + // MinDelay is the minimum amount of time to delay between retries. If unset, + // SecondarySubnetCreateCompleteWaiter will use default minimum delay of 10 + // seconds. Note that MinDelay must resolve to a value lesser than or equal to the + // MaxDelay. + MinDelay time.Duration + + // MaxDelay is the maximum amount of time to delay between retries. If unset or + // set to zero, SecondarySubnetCreateCompleteWaiter will use default max delay of + // 120 seconds. Note that MaxDelay must resolve to value greater than or equal to + // the MinDelay. + MaxDelay time.Duration + + // LogWaitAttempts is used to enable logging for waiter retry attempts + LogWaitAttempts bool + + // Retryable is function that can be used to override the service defined + // waiter-behavior based on operation output, or returned error. This function is + // used by the waiter to decide if a state is retryable or a terminal state. + // + // By default service-modeled logic will populate this option. This option can + // thus be used to define a custom waiter state with fall-back to service-modeled + // waiter state mutators.The function returns an error in case of a failure state. + // In case of retry state, this function returns a bool value of true and nil + // error, while in case of success it returns a bool value of false and nil error. + Retryable func(context.Context, *DescribeSecondarySubnetsInput, *DescribeSecondarySubnetsOutput, error) (bool, error) +} + +// SecondarySubnetCreateCompleteWaiter defines the waiters for +// SecondarySubnetCreateComplete +type SecondarySubnetCreateCompleteWaiter struct { + client DescribeSecondarySubnetsAPIClient + + options SecondarySubnetCreateCompleteWaiterOptions +} + +// NewSecondarySubnetCreateCompleteWaiter constructs a +// SecondarySubnetCreateCompleteWaiter. +func NewSecondarySubnetCreateCompleteWaiter(client DescribeSecondarySubnetsAPIClient, optFns ...func(*SecondarySubnetCreateCompleteWaiterOptions)) *SecondarySubnetCreateCompleteWaiter { + options := SecondarySubnetCreateCompleteWaiterOptions{} + options.MinDelay = 10 * time.Second + options.MaxDelay = 120 * time.Second + options.Retryable = secondarySubnetCreateCompleteStateRetryable + + for _, fn := range optFns { + fn(&options) + } + return &SecondarySubnetCreateCompleteWaiter{ + client: client, + options: options, + } +} + +// Wait calls the waiter function for SecondarySubnetCreateComplete waiter. The +// maxWaitDur is the maximum wait duration the waiter will wait. The maxWaitDur is +// required and must be greater than zero. +func (w *SecondarySubnetCreateCompleteWaiter) Wait(ctx context.Context, params *DescribeSecondarySubnetsInput, maxWaitDur time.Duration, optFns ...func(*SecondarySubnetCreateCompleteWaiterOptions)) error { + _, err := w.WaitForOutput(ctx, params, maxWaitDur, optFns...) + return err +} + +// WaitForOutput calls the waiter function for SecondarySubnetCreateComplete +// waiter and returns the output of the successful operation. The maxWaitDur is the +// maximum wait duration the waiter will wait. The maxWaitDur is required and must +// be greater than zero. +func (w *SecondarySubnetCreateCompleteWaiter) WaitForOutput(ctx context.Context, params *DescribeSecondarySubnetsInput, maxWaitDur time.Duration, optFns ...func(*SecondarySubnetCreateCompleteWaiterOptions)) (*DescribeSecondarySubnetsOutput, error) { + if maxWaitDur <= 0 { + return nil, fmt.Errorf("maximum wait time for waiter must be greater than zero") + } + + options := w.options + for _, fn := range optFns { + fn(&options) + } + + if options.MaxDelay <= 0 { + options.MaxDelay = 120 * time.Second + } + + if options.MinDelay > options.MaxDelay { + return nil, fmt.Errorf("minimum waiter delay %v must be lesser than or equal to maximum waiter delay of %v.", options.MinDelay, options.MaxDelay) + } + + ctx, cancelFn := context.WithTimeout(ctx, maxWaitDur) + defer cancelFn() + + logger := smithywaiter.Logger{} + remainingTime := maxWaitDur + + var attempt int64 + for { + + attempt++ + apiOptions := options.APIOptions + start := time.Now() + + if options.LogWaitAttempts { + logger.Attempt = attempt + apiOptions = append([]func(*middleware.Stack) error{}, options.APIOptions...) + apiOptions = append(apiOptions, logger.AddLogger) + } + + out, err := w.client.DescribeSecondarySubnets(ctx, params, func(o *Options) { + baseOpts := []func(*Options){ + addIsWaiterUserAgent, + } + o.APIOptions = append(o.APIOptions, apiOptions...) + for _, opt := range baseOpts { + opt(o) + } + for _, opt := range options.ClientOptions { + opt(o) + } + }) + + retryable, err := options.Retryable(ctx, params, out, err) + if err != nil { + return nil, err + } + if !retryable { + return out, nil + } + + remainingTime -= time.Since(start) + if remainingTime < options.MinDelay || remainingTime <= 0 { + break + } + + // compute exponential backoff between waiter retries + delay, err := smithywaiter.ComputeDelay( + attempt, options.MinDelay, options.MaxDelay, remainingTime, + ) + if err != nil { + return nil, fmt.Errorf("error computing waiter delay, %w", err) + } + + remainingTime -= delay + // sleep for the delay amount before invoking a request + if err := smithytime.SleepWithContext(ctx, delay); err != nil { + return nil, fmt.Errorf("request cancelled while waiting, %w", err) + } + } + return nil, fmt.Errorf("exceeded max wait time for SecondarySubnetCreateComplete waiter") +} + +func secondarySubnetCreateCompleteStateRetryable(ctx context.Context, input *DescribeSecondarySubnetsInput, output *DescribeSecondarySubnetsOutput, err error) (bool, error) { + + if err == nil { + v1 := output.SecondarySubnets + var v2 []types.SecondarySubnetState + for _, v := range v1 { + v3 := v.State + v2 = append(v2, v3) + } + expectedValue := "create-complete" + match := len(v2) > 0 + for _, v := range v2 { + if string(v) != expectedValue { + match = false + break + } + } + + if match { + return false, nil + } + } + + if err == nil { + v1 := output.SecondarySubnets + var v2 []types.SecondarySubnetState + for _, v := range v1 { + v3 := v.State + v2 = append(v2, v3) + } + expectedValue := "delete-failed" + var match bool + for _, v := range v2 { + if string(v) == expectedValue { + match = true + break + } + } + + if match { + return false, fmt.Errorf("waiter state transitioned to Failure") + } + } + + if err != nil { + var apiErr smithy.APIError + ok := errors.As(err, &apiErr) + if !ok { + return false, fmt.Errorf("expected err to be of type smithy.APIError, got %w", err) + } + + if "InvalidSecondarySubnetId.NotFound" == apiErr.ErrorCode() { + return true, nil + } + } + + if err != nil { + return false, err + } + return true, nil +} + +// SecondarySubnetDeleteCompleteWaiterOptions are waiter options for +// SecondarySubnetDeleteCompleteWaiter +type SecondarySubnetDeleteCompleteWaiterOptions struct { + + // Set of options to modify how an operation is invoked. These apply to all + // operations invoked for this client. Use functional options on operation call to + // modify this list for per operation behavior. + // + // Passing options here is functionally equivalent to passing values to this + // config's ClientOptions field that extend the inner client's APIOptions directly. + APIOptions []func(*middleware.Stack) error + + // Functional options to be passed to all operations invoked by this client. + // + // Function values that modify the inner APIOptions are applied after the waiter + // config's own APIOptions modifiers. + ClientOptions []func(*Options) + + // MinDelay is the minimum amount of time to delay between retries. If unset, + // SecondarySubnetDeleteCompleteWaiter will use default minimum delay of 10 + // seconds. Note that MinDelay must resolve to a value lesser than or equal to the + // MaxDelay. + MinDelay time.Duration + + // MaxDelay is the maximum amount of time to delay between retries. If unset or + // set to zero, SecondarySubnetDeleteCompleteWaiter will use default max delay of + // 120 seconds. Note that MaxDelay must resolve to value greater than or equal to + // the MinDelay. + MaxDelay time.Duration + + // LogWaitAttempts is used to enable logging for waiter retry attempts + LogWaitAttempts bool + + // Retryable is function that can be used to override the service defined + // waiter-behavior based on operation output, or returned error. This function is + // used by the waiter to decide if a state is retryable or a terminal state. + // + // By default service-modeled logic will populate this option. This option can + // thus be used to define a custom waiter state with fall-back to service-modeled + // waiter state mutators.The function returns an error in case of a failure state. + // In case of retry state, this function returns a bool value of true and nil + // error, while in case of success it returns a bool value of false and nil error. + Retryable func(context.Context, *DescribeSecondarySubnetsInput, *DescribeSecondarySubnetsOutput, error) (bool, error) +} + +// SecondarySubnetDeleteCompleteWaiter defines the waiters for +// SecondarySubnetDeleteComplete +type SecondarySubnetDeleteCompleteWaiter struct { + client DescribeSecondarySubnetsAPIClient + + options SecondarySubnetDeleteCompleteWaiterOptions +} + +// NewSecondarySubnetDeleteCompleteWaiter constructs a +// SecondarySubnetDeleteCompleteWaiter. +func NewSecondarySubnetDeleteCompleteWaiter(client DescribeSecondarySubnetsAPIClient, optFns ...func(*SecondarySubnetDeleteCompleteWaiterOptions)) *SecondarySubnetDeleteCompleteWaiter { + options := SecondarySubnetDeleteCompleteWaiterOptions{} + options.MinDelay = 10 * time.Second + options.MaxDelay = 120 * time.Second + options.Retryable = secondarySubnetDeleteCompleteStateRetryable + + for _, fn := range optFns { + fn(&options) + } + return &SecondarySubnetDeleteCompleteWaiter{ + client: client, + options: options, + } +} + +// Wait calls the waiter function for SecondarySubnetDeleteComplete waiter. The +// maxWaitDur is the maximum wait duration the waiter will wait. The maxWaitDur is +// required and must be greater than zero. +func (w *SecondarySubnetDeleteCompleteWaiter) Wait(ctx context.Context, params *DescribeSecondarySubnetsInput, maxWaitDur time.Duration, optFns ...func(*SecondarySubnetDeleteCompleteWaiterOptions)) error { + _, err := w.WaitForOutput(ctx, params, maxWaitDur, optFns...) + return err +} + +// WaitForOutput calls the waiter function for SecondarySubnetDeleteComplete +// waiter and returns the output of the successful operation. The maxWaitDur is the +// maximum wait duration the waiter will wait. The maxWaitDur is required and must +// be greater than zero. +func (w *SecondarySubnetDeleteCompleteWaiter) WaitForOutput(ctx context.Context, params *DescribeSecondarySubnetsInput, maxWaitDur time.Duration, optFns ...func(*SecondarySubnetDeleteCompleteWaiterOptions)) (*DescribeSecondarySubnetsOutput, error) { + if maxWaitDur <= 0 { + return nil, fmt.Errorf("maximum wait time for waiter must be greater than zero") + } + + options := w.options + for _, fn := range optFns { + fn(&options) + } + + if options.MaxDelay <= 0 { + options.MaxDelay = 120 * time.Second + } + + if options.MinDelay > options.MaxDelay { + return nil, fmt.Errorf("minimum waiter delay %v must be lesser than or equal to maximum waiter delay of %v.", options.MinDelay, options.MaxDelay) + } + + ctx, cancelFn := context.WithTimeout(ctx, maxWaitDur) + defer cancelFn() + + logger := smithywaiter.Logger{} + remainingTime := maxWaitDur + + var attempt int64 + for { + + attempt++ + apiOptions := options.APIOptions + start := time.Now() + + if options.LogWaitAttempts { + logger.Attempt = attempt + apiOptions = append([]func(*middleware.Stack) error{}, options.APIOptions...) + apiOptions = append(apiOptions, logger.AddLogger) + } + + out, err := w.client.DescribeSecondarySubnets(ctx, params, func(o *Options) { + baseOpts := []func(*Options){ + addIsWaiterUserAgent, + } + o.APIOptions = append(o.APIOptions, apiOptions...) + for _, opt := range baseOpts { + opt(o) + } + for _, opt := range options.ClientOptions { + opt(o) + } + }) + + retryable, err := options.Retryable(ctx, params, out, err) + if err != nil { + return nil, err + } + if !retryable { + return out, nil + } + + remainingTime -= time.Since(start) + if remainingTime < options.MinDelay || remainingTime <= 0 { + break + } + + // compute exponential backoff between waiter retries + delay, err := smithywaiter.ComputeDelay( + attempt, options.MinDelay, options.MaxDelay, remainingTime, + ) + if err != nil { + return nil, fmt.Errorf("error computing waiter delay, %w", err) + } + + remainingTime -= delay + // sleep for the delay amount before invoking a request + if err := smithytime.SleepWithContext(ctx, delay); err != nil { + return nil, fmt.Errorf("request cancelled while waiting, %w", err) + } + } + return nil, fmt.Errorf("exceeded max wait time for SecondarySubnetDeleteComplete waiter") +} + +func secondarySubnetDeleteCompleteStateRetryable(ctx context.Context, input *DescribeSecondarySubnetsInput, output *DescribeSecondarySubnetsOutput, err error) (bool, error) { + + if err == nil { + v1 := output.SecondarySubnets + var v2 []types.SecondarySubnetState + for _, v := range v1 { + v3 := v.State + v2 = append(v2, v3) + } + expectedValue := "delete-complete" + match := len(v2) > 0 + for _, v := range v2 { + if string(v) != expectedValue { + match = false + break + } + } + + if match { + return false, nil + } + } + + if err == nil { + v1 := output.SecondarySubnets + var v2 []types.SecondarySubnetState + for _, v := range v1 { + v3 := v.State + v2 = append(v2, v3) + } + expectedValue := "delete-failed" + var match bool + for _, v := range v2 { + if string(v) == expectedValue { + match = true + break + } + } + + if match { + return false, fmt.Errorf("waiter state transitioned to Failure") + } + } + + if err != nil { + return false, err + } + return true, nil +} + +// DescribeSecondarySubnetsPaginatorOptions is the paginator options for +// DescribeSecondarySubnets +type DescribeSecondarySubnetsPaginatorOptions struct { + // The maximum number of results to return with a single call. To retrieve the + // remaining results, make another call with the returned nextToken value. + 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 +} + +// DescribeSecondarySubnetsPaginator is a paginator for DescribeSecondarySubnets +type DescribeSecondarySubnetsPaginator struct { + options DescribeSecondarySubnetsPaginatorOptions + client DescribeSecondarySubnetsAPIClient + params *DescribeSecondarySubnetsInput + nextToken *string + firstPage bool +} + +// NewDescribeSecondarySubnetsPaginator returns a new +// DescribeSecondarySubnetsPaginator +func NewDescribeSecondarySubnetsPaginator(client DescribeSecondarySubnetsAPIClient, params *DescribeSecondarySubnetsInput, optFns ...func(*DescribeSecondarySubnetsPaginatorOptions)) *DescribeSecondarySubnetsPaginator { + if params == nil { + params = &DescribeSecondarySubnetsInput{} + } + + options := DescribeSecondarySubnetsPaginatorOptions{} + if params.MaxResults != nil { + options.Limit = *params.MaxResults + } + + for _, fn := range optFns { + fn(&options) + } + + return &DescribeSecondarySubnetsPaginator{ + options: options, + client: client, + params: params, + firstPage: true, + nextToken: params.NextToken, + } +} + +// HasMorePages returns a boolean indicating whether more pages are available +func (p *DescribeSecondarySubnetsPaginator) HasMorePages() bool { + return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0) +} + +// NextPage retrieves the next DescribeSecondarySubnets page. +func (p *DescribeSecondarySubnetsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*DescribeSecondarySubnetsOutput, 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 + + optFns = append([]func(*Options){ + addIsPaginatorUserAgent, + }, optFns...) + result, err := p.client.DescribeSecondarySubnets(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 +} + +// DescribeSecondarySubnetsAPIClient is a client that implements the +// DescribeSecondarySubnets operation. +type DescribeSecondarySubnetsAPIClient interface { + DescribeSecondarySubnets(context.Context, *DescribeSecondarySubnetsInput, ...func(*Options)) (*DescribeSecondarySubnetsOutput, error) +} + +var _ DescribeSecondarySubnetsAPIClient = (*Client)(nil) + +func newServiceMetadataMiddleware_opDescribeSecondarySubnets(region string) *awsmiddleware.RegisterServiceMetadata { + return &awsmiddleware.RegisterServiceMetadata{ + Region: region, + ServiceID: ServiceID, + OperationName: "DescribeSecondarySubnets", + } +} diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/api_op_ModifyInstanceCpuOptions.go b/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/api_op_ModifyInstanceCpuOptions.go index 335a01c96..fc6b59a01 100644 --- a/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/api_op_ModifyInstanceCpuOptions.go +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/api_op_ModifyInstanceCpuOptions.go @@ -6,6 +6,7 @@ import ( "context" "fmt" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" + "github.com/aws/aws-sdk-go-v2/service/ec2/types" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" ) @@ -40,20 +41,13 @@ func (c *Client) ModifyInstanceCpuOptions(ctx context.Context, params *ModifyIns type ModifyInstanceCpuOptionsInput struct { - // The number of CPU cores to activate for the specified instance. - // - // This member is required. - CoreCount *int32 - // The ID of the instance to update. // // This member is required. InstanceId *string - // The number of threads to run for each CPU core. - // - // This member is required. - ThreadsPerCore *int32 + // The number of CPU cores to activate for the specified instance. + CoreCount *int32 // Checks whether you have the required permissions for the operation, without // actually making the request, and provides an error response. If you have the @@ -61,6 +55,14 @@ type ModifyInstanceCpuOptionsInput struct { // UnauthorizedOperation . DryRun *bool + // Indicates whether to enable or disable nested virtualization for the instance. + // When nested virtualization is enabled, Virtual Secure Mode (VSM) is + // automatically disabled for the instance. + NestedVirtualization types.NestedVirtualizationSpecification + + // The number of threads to run for each CPU core. + ThreadsPerCore *int32 + noSmithyDocumentSerde } @@ -73,6 +75,9 @@ type ModifyInstanceCpuOptionsOutput struct { // The ID of the instance that was updated. InstanceId *string + // Indicates whether nested virtualization has been enabled or disabled. + NestedVirtualization types.NestedVirtualizationSpecification + // The number of threads that are running per CPU core for the specified instance // after the update. ThreadsPerCore *int32 diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/api_op_ModifyInstanceMetadataDefaults.go b/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/api_op_ModifyInstanceMetadataDefaults.go index d8480aaa4..b210ca7be 100644 --- a/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/api_op_ModifyInstanceMetadataDefaults.go +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/api_op_ModifyInstanceMetadataDefaults.go @@ -62,10 +62,18 @@ type ModifyInstanceMetadataDefaultsInput struct { // must use IMDSv2. HttpTokens types.MetadataDefaultHttpTokensState + // Specifies whether to enforce the requirement of IMDSv2 on an instance at the + // time of launch. When enforcement is enabled, the instance can't launch unless + // IMDSv2 ( HttpTokens ) is set to required . For more information, see [Enforce IMDSv2 at the account level] in the + // Amazon EC2 User Guide. + // + // [Enforce IMDSv2 at the account level]: https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/configuring-IMDS-new-instances.html#enforce-imdsv2-at-the-account-level + HttpTokensEnforced types.DefaultHttpTokensEnforcedState + // Enables or disables access to an instance's tags from the instance metadata. - // For more information, see [Work with instance tags using the instance metadata]in the Amazon EC2 User Guide. + // For more information, see [View tags for your EC2 instances using instance metadata]in the Amazon EC2 User Guide. // - // [Work with instance tags using the instance metadata]: https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Using_Tags.html#work-with-tags-in-IMDS + // [View tags for your EC2 instances using instance metadata]: https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/work-with-tags-in-IMDS.html InstanceMetadataTags types.DefaultInstanceMetadataTagsState noSmithyDocumentSerde diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/api_op_ModifyInstanceMetadataOptions.go b/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/api_op_ModifyInstanceMetadataOptions.go index 937b0f6ed..eeb0368d7 100644 --- a/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/api_op_ModifyInstanceMetadataOptions.go +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/api_op_ModifyInstanceMetadataOptions.go @@ -96,9 +96,9 @@ type ModifyInstanceMetadataOptionsInput struct { // Set to enabled to allow access to instance tags from the instance metadata. Set // to disabled to turn off access to instance tags from the instance metadata. For - // more information, see [Work with instance tags using the instance metadata]. + // more information, see [View tags for your EC2 instances using instance metadata]. // - // [Work with instance tags using the instance metadata]: https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Using_Tags.html#work-with-tags-in-IMDS + // [View tags for your EC2 instances using instance metadata]: https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/work-with-tags-in-IMDS.html InstanceMetadataTags types.InstanceMetadataTagsState noSmithyDocumentSerde diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/api_op_RunInstances.go b/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/api_op_RunInstances.go index fe29d4546..4d34687c3 100644 --- a/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/api_op_RunInstances.go +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/api_op_RunInstances.go @@ -346,6 +346,9 @@ type RunInstancesInput struct { // [PV-GRUB]: https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/UserProvidedkernels.html RamdiskId *string + // The secondary interfaces to associate with the instance. + SecondaryInterfaces []types.InstanceSecondaryInterfaceSpecificationRequest + // The IDs of the security groups. // // If you specify a network interface, you must specify any security groups as diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/deserializers.go b/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/deserializers.go index 906db8039..17c35b3d3 100644 --- a/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/deserializers.go +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/deserializers.go @@ -11500,14 +11500,14 @@ func awsEc2query_deserializeOpErrorCreateRouteTable(response *smithyhttp.Respons } } -type awsEc2query_deserializeOpCreateSecurityGroup struct { +type awsEc2query_deserializeOpCreateSecondaryNetwork struct { } -func (*awsEc2query_deserializeOpCreateSecurityGroup) ID() string { +func (*awsEc2query_deserializeOpCreateSecondaryNetwork) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpCreateSecurityGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpCreateSecondaryNetwork) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -11525,9 +11525,9 @@ func (m *awsEc2query_deserializeOpCreateSecurityGroup) HandleDeserialize(ctx con } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorCreateSecurityGroup(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorCreateSecondaryNetwork(response, &metadata) } - output := &CreateSecurityGroupOutput{} + output := &CreateSecondaryNetworkOutput{} out.Result = output var buff [1024]byte @@ -11548,7 +11548,7 @@ func (m *awsEc2query_deserializeOpCreateSecurityGroup) HandleDeserialize(ctx con } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentCreateSecurityGroupOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentCreateSecondaryNetworkOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -11562,7 +11562,7 @@ func (m *awsEc2query_deserializeOpCreateSecurityGroup) HandleDeserialize(ctx con return out, metadata, err } -func awsEc2query_deserializeOpErrorCreateSecurityGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorCreateSecondaryNetwork(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -11595,14 +11595,14 @@ func awsEc2query_deserializeOpErrorCreateSecurityGroup(response *smithyhttp.Resp } } -type awsEc2query_deserializeOpCreateSnapshot struct { +type awsEc2query_deserializeOpCreateSecondarySubnet struct { } -func (*awsEc2query_deserializeOpCreateSnapshot) ID() string { +func (*awsEc2query_deserializeOpCreateSecondarySubnet) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpCreateSnapshot) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpCreateSecondarySubnet) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -11620,9 +11620,9 @@ func (m *awsEc2query_deserializeOpCreateSnapshot) HandleDeserialize(ctx context. } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorCreateSnapshot(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorCreateSecondarySubnet(response, &metadata) } - output := &CreateSnapshotOutput{} + output := &CreateSecondarySubnetOutput{} out.Result = output var buff [1024]byte @@ -11643,7 +11643,7 @@ func (m *awsEc2query_deserializeOpCreateSnapshot) HandleDeserialize(ctx context. } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentCreateSnapshotOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentCreateSecondarySubnetOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -11657,7 +11657,7 @@ func (m *awsEc2query_deserializeOpCreateSnapshot) HandleDeserialize(ctx context. return out, metadata, err } -func awsEc2query_deserializeOpErrorCreateSnapshot(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorCreateSecondarySubnet(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -11690,14 +11690,14 @@ func awsEc2query_deserializeOpErrorCreateSnapshot(response *smithyhttp.Response, } } -type awsEc2query_deserializeOpCreateSnapshots struct { +type awsEc2query_deserializeOpCreateSecurityGroup struct { } -func (*awsEc2query_deserializeOpCreateSnapshots) ID() string { +func (*awsEc2query_deserializeOpCreateSecurityGroup) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpCreateSnapshots) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpCreateSecurityGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -11715,9 +11715,9 @@ func (m *awsEc2query_deserializeOpCreateSnapshots) HandleDeserialize(ctx context } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorCreateSnapshots(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorCreateSecurityGroup(response, &metadata) } - output := &CreateSnapshotsOutput{} + output := &CreateSecurityGroupOutput{} out.Result = output var buff [1024]byte @@ -11738,7 +11738,7 @@ func (m *awsEc2query_deserializeOpCreateSnapshots) HandleDeserialize(ctx context } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentCreateSnapshotsOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentCreateSecurityGroupOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -11752,7 +11752,7 @@ func (m *awsEc2query_deserializeOpCreateSnapshots) HandleDeserialize(ctx context return out, metadata, err } -func awsEc2query_deserializeOpErrorCreateSnapshots(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorCreateSecurityGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -11785,14 +11785,14 @@ func awsEc2query_deserializeOpErrorCreateSnapshots(response *smithyhttp.Response } } -type awsEc2query_deserializeOpCreateSpotDatafeedSubscription struct { +type awsEc2query_deserializeOpCreateSnapshot struct { } -func (*awsEc2query_deserializeOpCreateSpotDatafeedSubscription) ID() string { +func (*awsEc2query_deserializeOpCreateSnapshot) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpCreateSpotDatafeedSubscription) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpCreateSnapshot) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -11810,9 +11810,9 @@ func (m *awsEc2query_deserializeOpCreateSpotDatafeedSubscription) HandleDeserial } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorCreateSpotDatafeedSubscription(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorCreateSnapshot(response, &metadata) } - output := &CreateSpotDatafeedSubscriptionOutput{} + output := &CreateSnapshotOutput{} out.Result = output var buff [1024]byte @@ -11833,7 +11833,7 @@ func (m *awsEc2query_deserializeOpCreateSpotDatafeedSubscription) HandleDeserial } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentCreateSpotDatafeedSubscriptionOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentCreateSnapshotOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -11847,7 +11847,7 @@ func (m *awsEc2query_deserializeOpCreateSpotDatafeedSubscription) HandleDeserial return out, metadata, err } -func awsEc2query_deserializeOpErrorCreateSpotDatafeedSubscription(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorCreateSnapshot(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -11880,14 +11880,14 @@ func awsEc2query_deserializeOpErrorCreateSpotDatafeedSubscription(response *smit } } -type awsEc2query_deserializeOpCreateStoreImageTask struct { +type awsEc2query_deserializeOpCreateSnapshots struct { } -func (*awsEc2query_deserializeOpCreateStoreImageTask) ID() string { +func (*awsEc2query_deserializeOpCreateSnapshots) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpCreateStoreImageTask) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpCreateSnapshots) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -11905,9 +11905,9 @@ func (m *awsEc2query_deserializeOpCreateStoreImageTask) HandleDeserialize(ctx co } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorCreateStoreImageTask(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorCreateSnapshots(response, &metadata) } - output := &CreateStoreImageTaskOutput{} + output := &CreateSnapshotsOutput{} out.Result = output var buff [1024]byte @@ -11928,7 +11928,7 @@ func (m *awsEc2query_deserializeOpCreateStoreImageTask) HandleDeserialize(ctx co } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentCreateStoreImageTaskOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentCreateSnapshotsOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -11942,7 +11942,7 @@ func (m *awsEc2query_deserializeOpCreateStoreImageTask) HandleDeserialize(ctx co return out, metadata, err } -func awsEc2query_deserializeOpErrorCreateStoreImageTask(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorCreateSnapshots(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -11975,14 +11975,14 @@ func awsEc2query_deserializeOpErrorCreateStoreImageTask(response *smithyhttp.Res } } -type awsEc2query_deserializeOpCreateSubnet struct { +type awsEc2query_deserializeOpCreateSpotDatafeedSubscription struct { } -func (*awsEc2query_deserializeOpCreateSubnet) ID() string { +func (*awsEc2query_deserializeOpCreateSpotDatafeedSubscription) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpCreateSubnet) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpCreateSpotDatafeedSubscription) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -12000,9 +12000,9 @@ func (m *awsEc2query_deserializeOpCreateSubnet) HandleDeserialize(ctx context.Co } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorCreateSubnet(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorCreateSpotDatafeedSubscription(response, &metadata) } - output := &CreateSubnetOutput{} + output := &CreateSpotDatafeedSubscriptionOutput{} out.Result = output var buff [1024]byte @@ -12023,7 +12023,7 @@ func (m *awsEc2query_deserializeOpCreateSubnet) HandleDeserialize(ctx context.Co } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentCreateSubnetOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentCreateSpotDatafeedSubscriptionOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -12037,7 +12037,7 @@ func (m *awsEc2query_deserializeOpCreateSubnet) HandleDeserialize(ctx context.Co return out, metadata, err } -func awsEc2query_deserializeOpErrorCreateSubnet(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorCreateSpotDatafeedSubscription(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -12070,14 +12070,14 @@ func awsEc2query_deserializeOpErrorCreateSubnet(response *smithyhttp.Response, m } } -type awsEc2query_deserializeOpCreateSubnetCidrReservation struct { +type awsEc2query_deserializeOpCreateStoreImageTask struct { } -func (*awsEc2query_deserializeOpCreateSubnetCidrReservation) ID() string { +func (*awsEc2query_deserializeOpCreateStoreImageTask) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpCreateSubnetCidrReservation) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpCreateStoreImageTask) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -12095,9 +12095,9 @@ func (m *awsEc2query_deserializeOpCreateSubnetCidrReservation) HandleDeserialize } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorCreateSubnetCidrReservation(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorCreateStoreImageTask(response, &metadata) } - output := &CreateSubnetCidrReservationOutput{} + output := &CreateStoreImageTaskOutput{} out.Result = output var buff [1024]byte @@ -12118,7 +12118,7 @@ func (m *awsEc2query_deserializeOpCreateSubnetCidrReservation) HandleDeserialize } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentCreateSubnetCidrReservationOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentCreateStoreImageTaskOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -12132,7 +12132,7 @@ func (m *awsEc2query_deserializeOpCreateSubnetCidrReservation) HandleDeserialize return out, metadata, err } -func awsEc2query_deserializeOpErrorCreateSubnetCidrReservation(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorCreateStoreImageTask(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -12165,14 +12165,14 @@ func awsEc2query_deserializeOpErrorCreateSubnetCidrReservation(response *smithyh } } -type awsEc2query_deserializeOpCreateTags struct { +type awsEc2query_deserializeOpCreateSubnet struct { } -func (*awsEc2query_deserializeOpCreateTags) ID() string { +func (*awsEc2query_deserializeOpCreateSubnet) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpCreateTags) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpCreateSubnet) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -12190,21 +12190,44 @@ func (m *awsEc2query_deserializeOpCreateTags) HandleDeserialize(ctx context.Cont } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorCreateTags(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorCreateSubnet(response, &metadata) } - output := &CreateTagsOutput{} + output := &CreateSubnetOutput{} 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_deserializeOpDocumentCreateSubnetOutput(&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_deserializeOpErrorCreateTags(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorCreateSubnet(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -12237,14 +12260,14 @@ func awsEc2query_deserializeOpErrorCreateTags(response *smithyhttp.Response, met } } -type awsEc2query_deserializeOpCreateTrafficMirrorFilter struct { +type awsEc2query_deserializeOpCreateSubnetCidrReservation struct { } -func (*awsEc2query_deserializeOpCreateTrafficMirrorFilter) ID() string { +func (*awsEc2query_deserializeOpCreateSubnetCidrReservation) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpCreateTrafficMirrorFilter) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpCreateSubnetCidrReservation) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -12262,9 +12285,9 @@ func (m *awsEc2query_deserializeOpCreateTrafficMirrorFilter) HandleDeserialize(c } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorCreateTrafficMirrorFilter(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorCreateSubnetCidrReservation(response, &metadata) } - output := &CreateTrafficMirrorFilterOutput{} + output := &CreateSubnetCidrReservationOutput{} out.Result = output var buff [1024]byte @@ -12285,7 +12308,7 @@ func (m *awsEc2query_deserializeOpCreateTrafficMirrorFilter) HandleDeserialize(c } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentCreateTrafficMirrorFilterOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentCreateSubnetCidrReservationOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -12299,7 +12322,7 @@ func (m *awsEc2query_deserializeOpCreateTrafficMirrorFilter) HandleDeserialize(c return out, metadata, err } -func awsEc2query_deserializeOpErrorCreateTrafficMirrorFilter(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorCreateSubnetCidrReservation(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -12332,14 +12355,14 @@ func awsEc2query_deserializeOpErrorCreateTrafficMirrorFilter(response *smithyhtt } } -type awsEc2query_deserializeOpCreateTrafficMirrorFilterRule struct { +type awsEc2query_deserializeOpCreateTags struct { } -func (*awsEc2query_deserializeOpCreateTrafficMirrorFilterRule) ID() string { +func (*awsEc2query_deserializeOpCreateTags) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpCreateTrafficMirrorFilterRule) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpCreateTags) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -12357,44 +12380,21 @@ func (m *awsEc2query_deserializeOpCreateTrafficMirrorFilterRule) HandleDeseriali } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorCreateTrafficMirrorFilterRule(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorCreateTags(response, &metadata) } - output := &CreateTrafficMirrorFilterRuleOutput{} + output := &CreateTagsOutput{} 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_deserializeOpDocumentCreateTrafficMirrorFilterRuleOutput(&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_deserializeOpErrorCreateTrafficMirrorFilterRule(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorCreateTags(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -12427,14 +12427,14 @@ func awsEc2query_deserializeOpErrorCreateTrafficMirrorFilterRule(response *smith } } -type awsEc2query_deserializeOpCreateTrafficMirrorSession struct { +type awsEc2query_deserializeOpCreateTrafficMirrorFilter struct { } -func (*awsEc2query_deserializeOpCreateTrafficMirrorSession) ID() string { +func (*awsEc2query_deserializeOpCreateTrafficMirrorFilter) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpCreateTrafficMirrorSession) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpCreateTrafficMirrorFilter) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -12452,9 +12452,9 @@ func (m *awsEc2query_deserializeOpCreateTrafficMirrorSession) HandleDeserialize( } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorCreateTrafficMirrorSession(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorCreateTrafficMirrorFilter(response, &metadata) } - output := &CreateTrafficMirrorSessionOutput{} + output := &CreateTrafficMirrorFilterOutput{} out.Result = output var buff [1024]byte @@ -12475,7 +12475,7 @@ func (m *awsEc2query_deserializeOpCreateTrafficMirrorSession) HandleDeserialize( } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentCreateTrafficMirrorSessionOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentCreateTrafficMirrorFilterOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -12489,7 +12489,7 @@ func (m *awsEc2query_deserializeOpCreateTrafficMirrorSession) HandleDeserialize( return out, metadata, err } -func awsEc2query_deserializeOpErrorCreateTrafficMirrorSession(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorCreateTrafficMirrorFilter(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -12522,14 +12522,14 @@ func awsEc2query_deserializeOpErrorCreateTrafficMirrorSession(response *smithyht } } -type awsEc2query_deserializeOpCreateTrafficMirrorTarget struct { +type awsEc2query_deserializeOpCreateTrafficMirrorFilterRule struct { } -func (*awsEc2query_deserializeOpCreateTrafficMirrorTarget) ID() string { +func (*awsEc2query_deserializeOpCreateTrafficMirrorFilterRule) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpCreateTrafficMirrorTarget) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpCreateTrafficMirrorFilterRule) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -12547,9 +12547,9 @@ func (m *awsEc2query_deserializeOpCreateTrafficMirrorTarget) HandleDeserialize(c } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorCreateTrafficMirrorTarget(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorCreateTrafficMirrorFilterRule(response, &metadata) } - output := &CreateTrafficMirrorTargetOutput{} + output := &CreateTrafficMirrorFilterRuleOutput{} out.Result = output var buff [1024]byte @@ -12570,7 +12570,7 @@ func (m *awsEc2query_deserializeOpCreateTrafficMirrorTarget) HandleDeserialize(c } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentCreateTrafficMirrorTargetOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentCreateTrafficMirrorFilterRuleOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -12584,7 +12584,7 @@ func (m *awsEc2query_deserializeOpCreateTrafficMirrorTarget) HandleDeserialize(c return out, metadata, err } -func awsEc2query_deserializeOpErrorCreateTrafficMirrorTarget(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorCreateTrafficMirrorFilterRule(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -12617,14 +12617,14 @@ func awsEc2query_deserializeOpErrorCreateTrafficMirrorTarget(response *smithyhtt } } -type awsEc2query_deserializeOpCreateTransitGateway struct { +type awsEc2query_deserializeOpCreateTrafficMirrorSession struct { } -func (*awsEc2query_deserializeOpCreateTransitGateway) ID() string { +func (*awsEc2query_deserializeOpCreateTrafficMirrorSession) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpCreateTransitGateway) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpCreateTrafficMirrorSession) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -12642,9 +12642,9 @@ func (m *awsEc2query_deserializeOpCreateTransitGateway) HandleDeserialize(ctx co } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorCreateTransitGateway(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorCreateTrafficMirrorSession(response, &metadata) } - output := &CreateTransitGatewayOutput{} + output := &CreateTrafficMirrorSessionOutput{} out.Result = output var buff [1024]byte @@ -12665,7 +12665,7 @@ func (m *awsEc2query_deserializeOpCreateTransitGateway) HandleDeserialize(ctx co } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentCreateTransitGatewayOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentCreateTrafficMirrorSessionOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -12679,7 +12679,7 @@ func (m *awsEc2query_deserializeOpCreateTransitGateway) HandleDeserialize(ctx co return out, metadata, err } -func awsEc2query_deserializeOpErrorCreateTransitGateway(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorCreateTrafficMirrorSession(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -12712,14 +12712,14 @@ func awsEc2query_deserializeOpErrorCreateTransitGateway(response *smithyhttp.Res } } -type awsEc2query_deserializeOpCreateTransitGatewayConnect struct { +type awsEc2query_deserializeOpCreateTrafficMirrorTarget struct { } -func (*awsEc2query_deserializeOpCreateTransitGatewayConnect) ID() string { +func (*awsEc2query_deserializeOpCreateTrafficMirrorTarget) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpCreateTransitGatewayConnect) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpCreateTrafficMirrorTarget) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -12737,9 +12737,9 @@ func (m *awsEc2query_deserializeOpCreateTransitGatewayConnect) HandleDeserialize } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorCreateTransitGatewayConnect(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorCreateTrafficMirrorTarget(response, &metadata) } - output := &CreateTransitGatewayConnectOutput{} + output := &CreateTrafficMirrorTargetOutput{} out.Result = output var buff [1024]byte @@ -12760,7 +12760,7 @@ func (m *awsEc2query_deserializeOpCreateTransitGatewayConnect) HandleDeserialize } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentCreateTransitGatewayConnectOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentCreateTrafficMirrorTargetOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -12774,7 +12774,7 @@ func (m *awsEc2query_deserializeOpCreateTransitGatewayConnect) HandleDeserialize return out, metadata, err } -func awsEc2query_deserializeOpErrorCreateTransitGatewayConnect(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorCreateTrafficMirrorTarget(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -12807,14 +12807,14 @@ func awsEc2query_deserializeOpErrorCreateTransitGatewayConnect(response *smithyh } } -type awsEc2query_deserializeOpCreateTransitGatewayConnectPeer struct { +type awsEc2query_deserializeOpCreateTransitGateway struct { } -func (*awsEc2query_deserializeOpCreateTransitGatewayConnectPeer) ID() string { +func (*awsEc2query_deserializeOpCreateTransitGateway) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpCreateTransitGatewayConnectPeer) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpCreateTransitGateway) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -12832,9 +12832,9 @@ func (m *awsEc2query_deserializeOpCreateTransitGatewayConnectPeer) HandleDeseria } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorCreateTransitGatewayConnectPeer(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorCreateTransitGateway(response, &metadata) } - output := &CreateTransitGatewayConnectPeerOutput{} + output := &CreateTransitGatewayOutput{} out.Result = output var buff [1024]byte @@ -12855,7 +12855,7 @@ func (m *awsEc2query_deserializeOpCreateTransitGatewayConnectPeer) HandleDeseria } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentCreateTransitGatewayConnectPeerOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentCreateTransitGatewayOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -12869,7 +12869,7 @@ func (m *awsEc2query_deserializeOpCreateTransitGatewayConnectPeer) HandleDeseria return out, metadata, err } -func awsEc2query_deserializeOpErrorCreateTransitGatewayConnectPeer(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorCreateTransitGateway(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -12902,14 +12902,14 @@ func awsEc2query_deserializeOpErrorCreateTransitGatewayConnectPeer(response *smi } } -type awsEc2query_deserializeOpCreateTransitGatewayMeteringPolicy struct { +type awsEc2query_deserializeOpCreateTransitGatewayConnect struct { } -func (*awsEc2query_deserializeOpCreateTransitGatewayMeteringPolicy) ID() string { +func (*awsEc2query_deserializeOpCreateTransitGatewayConnect) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpCreateTransitGatewayMeteringPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpCreateTransitGatewayConnect) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -12927,9 +12927,9 @@ func (m *awsEc2query_deserializeOpCreateTransitGatewayMeteringPolicy) HandleDese } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorCreateTransitGatewayMeteringPolicy(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorCreateTransitGatewayConnect(response, &metadata) } - output := &CreateTransitGatewayMeteringPolicyOutput{} + output := &CreateTransitGatewayConnectOutput{} out.Result = output var buff [1024]byte @@ -12950,7 +12950,7 @@ func (m *awsEc2query_deserializeOpCreateTransitGatewayMeteringPolicy) HandleDese } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentCreateTransitGatewayMeteringPolicyOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentCreateTransitGatewayConnectOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -12964,7 +12964,7 @@ func (m *awsEc2query_deserializeOpCreateTransitGatewayMeteringPolicy) HandleDese return out, metadata, err } -func awsEc2query_deserializeOpErrorCreateTransitGatewayMeteringPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorCreateTransitGatewayConnect(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -12997,14 +12997,14 @@ func awsEc2query_deserializeOpErrorCreateTransitGatewayMeteringPolicy(response * } } -type awsEc2query_deserializeOpCreateTransitGatewayMeteringPolicyEntry struct { +type awsEc2query_deserializeOpCreateTransitGatewayConnectPeer struct { } -func (*awsEc2query_deserializeOpCreateTransitGatewayMeteringPolicyEntry) ID() string { +func (*awsEc2query_deserializeOpCreateTransitGatewayConnectPeer) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpCreateTransitGatewayMeteringPolicyEntry) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpCreateTransitGatewayConnectPeer) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -13022,9 +13022,9 @@ func (m *awsEc2query_deserializeOpCreateTransitGatewayMeteringPolicyEntry) Handl } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorCreateTransitGatewayMeteringPolicyEntry(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorCreateTransitGatewayConnectPeer(response, &metadata) } - output := &CreateTransitGatewayMeteringPolicyEntryOutput{} + output := &CreateTransitGatewayConnectPeerOutput{} out.Result = output var buff [1024]byte @@ -13045,7 +13045,7 @@ func (m *awsEc2query_deserializeOpCreateTransitGatewayMeteringPolicyEntry) Handl } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentCreateTransitGatewayMeteringPolicyEntryOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentCreateTransitGatewayConnectPeerOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -13059,7 +13059,7 @@ func (m *awsEc2query_deserializeOpCreateTransitGatewayMeteringPolicyEntry) Handl return out, metadata, err } -func awsEc2query_deserializeOpErrorCreateTransitGatewayMeteringPolicyEntry(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorCreateTransitGatewayConnectPeer(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -13092,14 +13092,14 @@ func awsEc2query_deserializeOpErrorCreateTransitGatewayMeteringPolicyEntry(respo } } -type awsEc2query_deserializeOpCreateTransitGatewayMulticastDomain struct { +type awsEc2query_deserializeOpCreateTransitGatewayMeteringPolicy struct { } -func (*awsEc2query_deserializeOpCreateTransitGatewayMulticastDomain) ID() string { +func (*awsEc2query_deserializeOpCreateTransitGatewayMeteringPolicy) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpCreateTransitGatewayMulticastDomain) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpCreateTransitGatewayMeteringPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -13117,9 +13117,9 @@ func (m *awsEc2query_deserializeOpCreateTransitGatewayMulticastDomain) HandleDes } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorCreateTransitGatewayMulticastDomain(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorCreateTransitGatewayMeteringPolicy(response, &metadata) } - output := &CreateTransitGatewayMulticastDomainOutput{} + output := &CreateTransitGatewayMeteringPolicyOutput{} out.Result = output var buff [1024]byte @@ -13140,7 +13140,7 @@ func (m *awsEc2query_deserializeOpCreateTransitGatewayMulticastDomain) HandleDes } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentCreateTransitGatewayMulticastDomainOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentCreateTransitGatewayMeteringPolicyOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -13154,7 +13154,7 @@ func (m *awsEc2query_deserializeOpCreateTransitGatewayMulticastDomain) HandleDes return out, metadata, err } -func awsEc2query_deserializeOpErrorCreateTransitGatewayMulticastDomain(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorCreateTransitGatewayMeteringPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -13187,14 +13187,14 @@ func awsEc2query_deserializeOpErrorCreateTransitGatewayMulticastDomain(response } } -type awsEc2query_deserializeOpCreateTransitGatewayPeeringAttachment struct { +type awsEc2query_deserializeOpCreateTransitGatewayMeteringPolicyEntry struct { } -func (*awsEc2query_deserializeOpCreateTransitGatewayPeeringAttachment) ID() string { +func (*awsEc2query_deserializeOpCreateTransitGatewayMeteringPolicyEntry) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpCreateTransitGatewayPeeringAttachment) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpCreateTransitGatewayMeteringPolicyEntry) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -13212,9 +13212,9 @@ func (m *awsEc2query_deserializeOpCreateTransitGatewayPeeringAttachment) HandleD } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorCreateTransitGatewayPeeringAttachment(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorCreateTransitGatewayMeteringPolicyEntry(response, &metadata) } - output := &CreateTransitGatewayPeeringAttachmentOutput{} + output := &CreateTransitGatewayMeteringPolicyEntryOutput{} out.Result = output var buff [1024]byte @@ -13235,7 +13235,7 @@ func (m *awsEc2query_deserializeOpCreateTransitGatewayPeeringAttachment) HandleD } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentCreateTransitGatewayPeeringAttachmentOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentCreateTransitGatewayMeteringPolicyEntryOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -13249,7 +13249,7 @@ func (m *awsEc2query_deserializeOpCreateTransitGatewayPeeringAttachment) HandleD return out, metadata, err } -func awsEc2query_deserializeOpErrorCreateTransitGatewayPeeringAttachment(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorCreateTransitGatewayMeteringPolicyEntry(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -13282,14 +13282,14 @@ func awsEc2query_deserializeOpErrorCreateTransitGatewayPeeringAttachment(respons } } -type awsEc2query_deserializeOpCreateTransitGatewayPolicyTable struct { +type awsEc2query_deserializeOpCreateTransitGatewayMulticastDomain struct { } -func (*awsEc2query_deserializeOpCreateTransitGatewayPolicyTable) ID() string { +func (*awsEc2query_deserializeOpCreateTransitGatewayMulticastDomain) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpCreateTransitGatewayPolicyTable) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpCreateTransitGatewayMulticastDomain) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -13307,9 +13307,9 @@ func (m *awsEc2query_deserializeOpCreateTransitGatewayPolicyTable) HandleDeseria } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorCreateTransitGatewayPolicyTable(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorCreateTransitGatewayMulticastDomain(response, &metadata) } - output := &CreateTransitGatewayPolicyTableOutput{} + output := &CreateTransitGatewayMulticastDomainOutput{} out.Result = output var buff [1024]byte @@ -13330,7 +13330,7 @@ func (m *awsEc2query_deserializeOpCreateTransitGatewayPolicyTable) HandleDeseria } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentCreateTransitGatewayPolicyTableOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentCreateTransitGatewayMulticastDomainOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -13344,7 +13344,7 @@ func (m *awsEc2query_deserializeOpCreateTransitGatewayPolicyTable) HandleDeseria return out, metadata, err } -func awsEc2query_deserializeOpErrorCreateTransitGatewayPolicyTable(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorCreateTransitGatewayMulticastDomain(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -13377,14 +13377,14 @@ func awsEc2query_deserializeOpErrorCreateTransitGatewayPolicyTable(response *smi } } -type awsEc2query_deserializeOpCreateTransitGatewayPrefixListReference struct { +type awsEc2query_deserializeOpCreateTransitGatewayPeeringAttachment struct { } -func (*awsEc2query_deserializeOpCreateTransitGatewayPrefixListReference) ID() string { +func (*awsEc2query_deserializeOpCreateTransitGatewayPeeringAttachment) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpCreateTransitGatewayPrefixListReference) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpCreateTransitGatewayPeeringAttachment) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -13402,9 +13402,9 @@ func (m *awsEc2query_deserializeOpCreateTransitGatewayPrefixListReference) Handl } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorCreateTransitGatewayPrefixListReference(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorCreateTransitGatewayPeeringAttachment(response, &metadata) } - output := &CreateTransitGatewayPrefixListReferenceOutput{} + output := &CreateTransitGatewayPeeringAttachmentOutput{} out.Result = output var buff [1024]byte @@ -13425,7 +13425,7 @@ func (m *awsEc2query_deserializeOpCreateTransitGatewayPrefixListReference) Handl } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentCreateTransitGatewayPrefixListReferenceOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentCreateTransitGatewayPeeringAttachmentOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -13439,7 +13439,7 @@ func (m *awsEc2query_deserializeOpCreateTransitGatewayPrefixListReference) Handl return out, metadata, err } -func awsEc2query_deserializeOpErrorCreateTransitGatewayPrefixListReference(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorCreateTransitGatewayPeeringAttachment(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -13472,14 +13472,14 @@ func awsEc2query_deserializeOpErrorCreateTransitGatewayPrefixListReference(respo } } -type awsEc2query_deserializeOpCreateTransitGatewayRoute struct { +type awsEc2query_deserializeOpCreateTransitGatewayPolicyTable struct { } -func (*awsEc2query_deserializeOpCreateTransitGatewayRoute) ID() string { +func (*awsEc2query_deserializeOpCreateTransitGatewayPolicyTable) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpCreateTransitGatewayRoute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpCreateTransitGatewayPolicyTable) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -13497,9 +13497,9 @@ func (m *awsEc2query_deserializeOpCreateTransitGatewayRoute) HandleDeserialize(c } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorCreateTransitGatewayRoute(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorCreateTransitGatewayPolicyTable(response, &metadata) } - output := &CreateTransitGatewayRouteOutput{} + output := &CreateTransitGatewayPolicyTableOutput{} out.Result = output var buff [1024]byte @@ -13520,7 +13520,7 @@ func (m *awsEc2query_deserializeOpCreateTransitGatewayRoute) HandleDeserialize(c } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentCreateTransitGatewayRouteOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentCreateTransitGatewayPolicyTableOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -13534,7 +13534,7 @@ func (m *awsEc2query_deserializeOpCreateTransitGatewayRoute) HandleDeserialize(c return out, metadata, err } -func awsEc2query_deserializeOpErrorCreateTransitGatewayRoute(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorCreateTransitGatewayPolicyTable(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -13567,14 +13567,14 @@ func awsEc2query_deserializeOpErrorCreateTransitGatewayRoute(response *smithyhtt } } -type awsEc2query_deserializeOpCreateTransitGatewayRouteTable struct { +type awsEc2query_deserializeOpCreateTransitGatewayPrefixListReference struct { } -func (*awsEc2query_deserializeOpCreateTransitGatewayRouteTable) ID() string { +func (*awsEc2query_deserializeOpCreateTransitGatewayPrefixListReference) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpCreateTransitGatewayRouteTable) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpCreateTransitGatewayPrefixListReference) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -13592,9 +13592,9 @@ func (m *awsEc2query_deserializeOpCreateTransitGatewayRouteTable) HandleDeserial } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorCreateTransitGatewayRouteTable(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorCreateTransitGatewayPrefixListReference(response, &metadata) } - output := &CreateTransitGatewayRouteTableOutput{} + output := &CreateTransitGatewayPrefixListReferenceOutput{} out.Result = output var buff [1024]byte @@ -13615,7 +13615,7 @@ func (m *awsEc2query_deserializeOpCreateTransitGatewayRouteTable) HandleDeserial } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentCreateTransitGatewayRouteTableOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentCreateTransitGatewayPrefixListReferenceOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -13629,7 +13629,7 @@ func (m *awsEc2query_deserializeOpCreateTransitGatewayRouteTable) HandleDeserial return out, metadata, err } -func awsEc2query_deserializeOpErrorCreateTransitGatewayRouteTable(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorCreateTransitGatewayPrefixListReference(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -13662,14 +13662,14 @@ func awsEc2query_deserializeOpErrorCreateTransitGatewayRouteTable(response *smit } } -type awsEc2query_deserializeOpCreateTransitGatewayRouteTableAnnouncement struct { +type awsEc2query_deserializeOpCreateTransitGatewayRoute struct { } -func (*awsEc2query_deserializeOpCreateTransitGatewayRouteTableAnnouncement) ID() string { +func (*awsEc2query_deserializeOpCreateTransitGatewayRoute) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpCreateTransitGatewayRouteTableAnnouncement) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpCreateTransitGatewayRoute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -13687,9 +13687,9 @@ func (m *awsEc2query_deserializeOpCreateTransitGatewayRouteTableAnnouncement) Ha } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorCreateTransitGatewayRouteTableAnnouncement(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorCreateTransitGatewayRoute(response, &metadata) } - output := &CreateTransitGatewayRouteTableAnnouncementOutput{} + output := &CreateTransitGatewayRouteOutput{} out.Result = output var buff [1024]byte @@ -13710,7 +13710,7 @@ func (m *awsEc2query_deserializeOpCreateTransitGatewayRouteTableAnnouncement) Ha } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentCreateTransitGatewayRouteTableAnnouncementOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentCreateTransitGatewayRouteOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -13724,7 +13724,7 @@ func (m *awsEc2query_deserializeOpCreateTransitGatewayRouteTableAnnouncement) Ha return out, metadata, err } -func awsEc2query_deserializeOpErrorCreateTransitGatewayRouteTableAnnouncement(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorCreateTransitGatewayRoute(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -13757,14 +13757,14 @@ func awsEc2query_deserializeOpErrorCreateTransitGatewayRouteTableAnnouncement(re } } -type awsEc2query_deserializeOpCreateTransitGatewayVpcAttachment struct { +type awsEc2query_deserializeOpCreateTransitGatewayRouteTable struct { } -func (*awsEc2query_deserializeOpCreateTransitGatewayVpcAttachment) ID() string { +func (*awsEc2query_deserializeOpCreateTransitGatewayRouteTable) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpCreateTransitGatewayVpcAttachment) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpCreateTransitGatewayRouteTable) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -13782,9 +13782,9 @@ func (m *awsEc2query_deserializeOpCreateTransitGatewayVpcAttachment) HandleDeser } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorCreateTransitGatewayVpcAttachment(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorCreateTransitGatewayRouteTable(response, &metadata) } - output := &CreateTransitGatewayVpcAttachmentOutput{} + output := &CreateTransitGatewayRouteTableOutput{} out.Result = output var buff [1024]byte @@ -13805,7 +13805,7 @@ func (m *awsEc2query_deserializeOpCreateTransitGatewayVpcAttachment) HandleDeser } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentCreateTransitGatewayVpcAttachmentOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentCreateTransitGatewayRouteTableOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -13819,7 +13819,7 @@ func (m *awsEc2query_deserializeOpCreateTransitGatewayVpcAttachment) HandleDeser return out, metadata, err } -func awsEc2query_deserializeOpErrorCreateTransitGatewayVpcAttachment(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorCreateTransitGatewayRouteTable(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -13852,14 +13852,14 @@ func awsEc2query_deserializeOpErrorCreateTransitGatewayVpcAttachment(response *s } } -type awsEc2query_deserializeOpCreateVerifiedAccessEndpoint struct { +type awsEc2query_deserializeOpCreateTransitGatewayRouteTableAnnouncement struct { } -func (*awsEc2query_deserializeOpCreateVerifiedAccessEndpoint) ID() string { +func (*awsEc2query_deserializeOpCreateTransitGatewayRouteTableAnnouncement) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpCreateVerifiedAccessEndpoint) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpCreateTransitGatewayRouteTableAnnouncement) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -13877,9 +13877,9 @@ func (m *awsEc2query_deserializeOpCreateVerifiedAccessEndpoint) HandleDeserializ } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorCreateVerifiedAccessEndpoint(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorCreateTransitGatewayRouteTableAnnouncement(response, &metadata) } - output := &CreateVerifiedAccessEndpointOutput{} + output := &CreateTransitGatewayRouteTableAnnouncementOutput{} out.Result = output var buff [1024]byte @@ -13900,7 +13900,7 @@ func (m *awsEc2query_deserializeOpCreateVerifiedAccessEndpoint) HandleDeserializ } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentCreateVerifiedAccessEndpointOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentCreateTransitGatewayRouteTableAnnouncementOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -13914,7 +13914,7 @@ func (m *awsEc2query_deserializeOpCreateVerifiedAccessEndpoint) HandleDeserializ return out, metadata, err } -func awsEc2query_deserializeOpErrorCreateVerifiedAccessEndpoint(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorCreateTransitGatewayRouteTableAnnouncement(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -13947,14 +13947,14 @@ func awsEc2query_deserializeOpErrorCreateVerifiedAccessEndpoint(response *smithy } } -type awsEc2query_deserializeOpCreateVerifiedAccessGroup struct { +type awsEc2query_deserializeOpCreateTransitGatewayVpcAttachment struct { } -func (*awsEc2query_deserializeOpCreateVerifiedAccessGroup) ID() string { +func (*awsEc2query_deserializeOpCreateTransitGatewayVpcAttachment) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpCreateVerifiedAccessGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpCreateTransitGatewayVpcAttachment) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -13972,9 +13972,9 @@ func (m *awsEc2query_deserializeOpCreateVerifiedAccessGroup) HandleDeserialize(c } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorCreateVerifiedAccessGroup(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorCreateTransitGatewayVpcAttachment(response, &metadata) } - output := &CreateVerifiedAccessGroupOutput{} + output := &CreateTransitGatewayVpcAttachmentOutput{} out.Result = output var buff [1024]byte @@ -13995,7 +13995,7 @@ func (m *awsEc2query_deserializeOpCreateVerifiedAccessGroup) HandleDeserialize(c } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentCreateVerifiedAccessGroupOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentCreateTransitGatewayVpcAttachmentOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -14009,7 +14009,7 @@ func (m *awsEc2query_deserializeOpCreateVerifiedAccessGroup) HandleDeserialize(c return out, metadata, err } -func awsEc2query_deserializeOpErrorCreateVerifiedAccessGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorCreateTransitGatewayVpcAttachment(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -14042,14 +14042,14 @@ func awsEc2query_deserializeOpErrorCreateVerifiedAccessGroup(response *smithyhtt } } -type awsEc2query_deserializeOpCreateVerifiedAccessInstance struct { +type awsEc2query_deserializeOpCreateVerifiedAccessEndpoint struct { } -func (*awsEc2query_deserializeOpCreateVerifiedAccessInstance) ID() string { +func (*awsEc2query_deserializeOpCreateVerifiedAccessEndpoint) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpCreateVerifiedAccessInstance) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpCreateVerifiedAccessEndpoint) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -14067,9 +14067,9 @@ func (m *awsEc2query_deserializeOpCreateVerifiedAccessInstance) HandleDeserializ } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorCreateVerifiedAccessInstance(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorCreateVerifiedAccessEndpoint(response, &metadata) } - output := &CreateVerifiedAccessInstanceOutput{} + output := &CreateVerifiedAccessEndpointOutput{} out.Result = output var buff [1024]byte @@ -14090,7 +14090,7 @@ func (m *awsEc2query_deserializeOpCreateVerifiedAccessInstance) HandleDeserializ } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentCreateVerifiedAccessInstanceOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentCreateVerifiedAccessEndpointOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -14104,7 +14104,7 @@ func (m *awsEc2query_deserializeOpCreateVerifiedAccessInstance) HandleDeserializ return out, metadata, err } -func awsEc2query_deserializeOpErrorCreateVerifiedAccessInstance(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorCreateVerifiedAccessEndpoint(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -14137,14 +14137,14 @@ func awsEc2query_deserializeOpErrorCreateVerifiedAccessInstance(response *smithy } } -type awsEc2query_deserializeOpCreateVerifiedAccessTrustProvider struct { +type awsEc2query_deserializeOpCreateVerifiedAccessGroup struct { } -func (*awsEc2query_deserializeOpCreateVerifiedAccessTrustProvider) ID() string { +func (*awsEc2query_deserializeOpCreateVerifiedAccessGroup) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpCreateVerifiedAccessTrustProvider) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpCreateVerifiedAccessGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -14162,9 +14162,9 @@ func (m *awsEc2query_deserializeOpCreateVerifiedAccessTrustProvider) HandleDeser } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorCreateVerifiedAccessTrustProvider(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorCreateVerifiedAccessGroup(response, &metadata) } - output := &CreateVerifiedAccessTrustProviderOutput{} + output := &CreateVerifiedAccessGroupOutput{} out.Result = output var buff [1024]byte @@ -14185,7 +14185,7 @@ func (m *awsEc2query_deserializeOpCreateVerifiedAccessTrustProvider) HandleDeser } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentCreateVerifiedAccessTrustProviderOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentCreateVerifiedAccessGroupOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -14199,7 +14199,7 @@ func (m *awsEc2query_deserializeOpCreateVerifiedAccessTrustProvider) HandleDeser return out, metadata, err } -func awsEc2query_deserializeOpErrorCreateVerifiedAccessTrustProvider(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorCreateVerifiedAccessGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -14232,14 +14232,14 @@ func awsEc2query_deserializeOpErrorCreateVerifiedAccessTrustProvider(response *s } } -type awsEc2query_deserializeOpCreateVolume struct { +type awsEc2query_deserializeOpCreateVerifiedAccessInstance struct { } -func (*awsEc2query_deserializeOpCreateVolume) ID() string { +func (*awsEc2query_deserializeOpCreateVerifiedAccessInstance) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpCreateVolume) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpCreateVerifiedAccessInstance) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -14257,9 +14257,9 @@ func (m *awsEc2query_deserializeOpCreateVolume) HandleDeserialize(ctx context.Co } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorCreateVolume(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorCreateVerifiedAccessInstance(response, &metadata) } - output := &CreateVolumeOutput{} + output := &CreateVerifiedAccessInstanceOutput{} out.Result = output var buff [1024]byte @@ -14280,7 +14280,7 @@ func (m *awsEc2query_deserializeOpCreateVolume) HandleDeserialize(ctx context.Co } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentCreateVolumeOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentCreateVerifiedAccessInstanceOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -14294,7 +14294,7 @@ func (m *awsEc2query_deserializeOpCreateVolume) HandleDeserialize(ctx context.Co return out, metadata, err } -func awsEc2query_deserializeOpErrorCreateVolume(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorCreateVerifiedAccessInstance(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -14327,14 +14327,14 @@ func awsEc2query_deserializeOpErrorCreateVolume(response *smithyhttp.Response, m } } -type awsEc2query_deserializeOpCreateVpc struct { +type awsEc2query_deserializeOpCreateVerifiedAccessTrustProvider struct { } -func (*awsEc2query_deserializeOpCreateVpc) ID() string { +func (*awsEc2query_deserializeOpCreateVerifiedAccessTrustProvider) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpCreateVpc) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpCreateVerifiedAccessTrustProvider) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -14352,9 +14352,9 @@ func (m *awsEc2query_deserializeOpCreateVpc) HandleDeserialize(ctx context.Conte } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorCreateVpc(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorCreateVerifiedAccessTrustProvider(response, &metadata) } - output := &CreateVpcOutput{} + output := &CreateVerifiedAccessTrustProviderOutput{} out.Result = output var buff [1024]byte @@ -14375,7 +14375,7 @@ func (m *awsEc2query_deserializeOpCreateVpc) HandleDeserialize(ctx context.Conte } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentCreateVpcOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentCreateVerifiedAccessTrustProviderOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -14389,7 +14389,7 @@ func (m *awsEc2query_deserializeOpCreateVpc) HandleDeserialize(ctx context.Conte return out, metadata, err } -func awsEc2query_deserializeOpErrorCreateVpc(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorCreateVerifiedAccessTrustProvider(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -14422,14 +14422,14 @@ func awsEc2query_deserializeOpErrorCreateVpc(response *smithyhttp.Response, meta } } -type awsEc2query_deserializeOpCreateVpcBlockPublicAccessExclusion struct { +type awsEc2query_deserializeOpCreateVolume struct { } -func (*awsEc2query_deserializeOpCreateVpcBlockPublicAccessExclusion) ID() string { +func (*awsEc2query_deserializeOpCreateVolume) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpCreateVpcBlockPublicAccessExclusion) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpCreateVolume) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -14447,9 +14447,9 @@ func (m *awsEc2query_deserializeOpCreateVpcBlockPublicAccessExclusion) HandleDes } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorCreateVpcBlockPublicAccessExclusion(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorCreateVolume(response, &metadata) } - output := &CreateVpcBlockPublicAccessExclusionOutput{} + output := &CreateVolumeOutput{} out.Result = output var buff [1024]byte @@ -14470,7 +14470,7 @@ func (m *awsEc2query_deserializeOpCreateVpcBlockPublicAccessExclusion) HandleDes } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentCreateVpcBlockPublicAccessExclusionOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentCreateVolumeOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -14484,7 +14484,7 @@ func (m *awsEc2query_deserializeOpCreateVpcBlockPublicAccessExclusion) HandleDes return out, metadata, err } -func awsEc2query_deserializeOpErrorCreateVpcBlockPublicAccessExclusion(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorCreateVolume(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -14517,14 +14517,14 @@ func awsEc2query_deserializeOpErrorCreateVpcBlockPublicAccessExclusion(response } } -type awsEc2query_deserializeOpCreateVpcEncryptionControl struct { +type awsEc2query_deserializeOpCreateVpc struct { } -func (*awsEc2query_deserializeOpCreateVpcEncryptionControl) ID() string { +func (*awsEc2query_deserializeOpCreateVpc) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpCreateVpcEncryptionControl) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpCreateVpc) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -14542,9 +14542,9 @@ func (m *awsEc2query_deserializeOpCreateVpcEncryptionControl) HandleDeserialize( } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorCreateVpcEncryptionControl(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorCreateVpc(response, &metadata) } - output := &CreateVpcEncryptionControlOutput{} + output := &CreateVpcOutput{} out.Result = output var buff [1024]byte @@ -14565,7 +14565,7 @@ func (m *awsEc2query_deserializeOpCreateVpcEncryptionControl) HandleDeserialize( } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentCreateVpcEncryptionControlOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentCreateVpcOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -14579,7 +14579,7 @@ func (m *awsEc2query_deserializeOpCreateVpcEncryptionControl) HandleDeserialize( return out, metadata, err } -func awsEc2query_deserializeOpErrorCreateVpcEncryptionControl(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorCreateVpc(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -14612,14 +14612,14 @@ func awsEc2query_deserializeOpErrorCreateVpcEncryptionControl(response *smithyht } } -type awsEc2query_deserializeOpCreateVpcEndpoint struct { +type awsEc2query_deserializeOpCreateVpcBlockPublicAccessExclusion struct { } -func (*awsEc2query_deserializeOpCreateVpcEndpoint) ID() string { +func (*awsEc2query_deserializeOpCreateVpcBlockPublicAccessExclusion) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpCreateVpcEndpoint) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpCreateVpcBlockPublicAccessExclusion) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -14637,9 +14637,9 @@ func (m *awsEc2query_deserializeOpCreateVpcEndpoint) HandleDeserialize(ctx conte } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorCreateVpcEndpoint(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorCreateVpcBlockPublicAccessExclusion(response, &metadata) } - output := &CreateVpcEndpointOutput{} + output := &CreateVpcBlockPublicAccessExclusionOutput{} out.Result = output var buff [1024]byte @@ -14660,7 +14660,7 @@ func (m *awsEc2query_deserializeOpCreateVpcEndpoint) HandleDeserialize(ctx conte } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentCreateVpcEndpointOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentCreateVpcBlockPublicAccessExclusionOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -14674,7 +14674,7 @@ func (m *awsEc2query_deserializeOpCreateVpcEndpoint) HandleDeserialize(ctx conte return out, metadata, err } -func awsEc2query_deserializeOpErrorCreateVpcEndpoint(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorCreateVpcBlockPublicAccessExclusion(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -14707,14 +14707,14 @@ func awsEc2query_deserializeOpErrorCreateVpcEndpoint(response *smithyhttp.Respon } } -type awsEc2query_deserializeOpCreateVpcEndpointConnectionNotification struct { +type awsEc2query_deserializeOpCreateVpcEncryptionControl struct { } -func (*awsEc2query_deserializeOpCreateVpcEndpointConnectionNotification) ID() string { +func (*awsEc2query_deserializeOpCreateVpcEncryptionControl) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpCreateVpcEndpointConnectionNotification) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpCreateVpcEncryptionControl) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -14732,9 +14732,9 @@ func (m *awsEc2query_deserializeOpCreateVpcEndpointConnectionNotification) Handl } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorCreateVpcEndpointConnectionNotification(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorCreateVpcEncryptionControl(response, &metadata) } - output := &CreateVpcEndpointConnectionNotificationOutput{} + output := &CreateVpcEncryptionControlOutput{} out.Result = output var buff [1024]byte @@ -14755,7 +14755,7 @@ func (m *awsEc2query_deserializeOpCreateVpcEndpointConnectionNotification) Handl } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentCreateVpcEndpointConnectionNotificationOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentCreateVpcEncryptionControlOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -14769,7 +14769,7 @@ func (m *awsEc2query_deserializeOpCreateVpcEndpointConnectionNotification) Handl return out, metadata, err } -func awsEc2query_deserializeOpErrorCreateVpcEndpointConnectionNotification(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorCreateVpcEncryptionControl(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -14802,14 +14802,14 @@ func awsEc2query_deserializeOpErrorCreateVpcEndpointConnectionNotification(respo } } -type awsEc2query_deserializeOpCreateVpcEndpointServiceConfiguration struct { +type awsEc2query_deserializeOpCreateVpcEndpoint struct { } -func (*awsEc2query_deserializeOpCreateVpcEndpointServiceConfiguration) ID() string { +func (*awsEc2query_deserializeOpCreateVpcEndpoint) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpCreateVpcEndpointServiceConfiguration) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpCreateVpcEndpoint) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -14827,9 +14827,9 @@ func (m *awsEc2query_deserializeOpCreateVpcEndpointServiceConfiguration) HandleD } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorCreateVpcEndpointServiceConfiguration(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorCreateVpcEndpoint(response, &metadata) } - output := &CreateVpcEndpointServiceConfigurationOutput{} + output := &CreateVpcEndpointOutput{} out.Result = output var buff [1024]byte @@ -14850,7 +14850,7 @@ func (m *awsEc2query_deserializeOpCreateVpcEndpointServiceConfiguration) HandleD } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentCreateVpcEndpointServiceConfigurationOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentCreateVpcEndpointOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -14864,7 +14864,7 @@ func (m *awsEc2query_deserializeOpCreateVpcEndpointServiceConfiguration) HandleD return out, metadata, err } -func awsEc2query_deserializeOpErrorCreateVpcEndpointServiceConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorCreateVpcEndpoint(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -14897,14 +14897,14 @@ func awsEc2query_deserializeOpErrorCreateVpcEndpointServiceConfiguration(respons } } -type awsEc2query_deserializeOpCreateVpcPeeringConnection struct { +type awsEc2query_deserializeOpCreateVpcEndpointConnectionNotification struct { } -func (*awsEc2query_deserializeOpCreateVpcPeeringConnection) ID() string { +func (*awsEc2query_deserializeOpCreateVpcEndpointConnectionNotification) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpCreateVpcPeeringConnection) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpCreateVpcEndpointConnectionNotification) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -14922,9 +14922,9 @@ func (m *awsEc2query_deserializeOpCreateVpcPeeringConnection) HandleDeserialize( } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorCreateVpcPeeringConnection(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorCreateVpcEndpointConnectionNotification(response, &metadata) } - output := &CreateVpcPeeringConnectionOutput{} + output := &CreateVpcEndpointConnectionNotificationOutput{} out.Result = output var buff [1024]byte @@ -14945,7 +14945,7 @@ func (m *awsEc2query_deserializeOpCreateVpcPeeringConnection) HandleDeserialize( } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentCreateVpcPeeringConnectionOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentCreateVpcEndpointConnectionNotificationOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -14959,7 +14959,7 @@ func (m *awsEc2query_deserializeOpCreateVpcPeeringConnection) HandleDeserialize( return out, metadata, err } -func awsEc2query_deserializeOpErrorCreateVpcPeeringConnection(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorCreateVpcEndpointConnectionNotification(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -14992,14 +14992,14 @@ func awsEc2query_deserializeOpErrorCreateVpcPeeringConnection(response *smithyht } } -type awsEc2query_deserializeOpCreateVpnConcentrator struct { +type awsEc2query_deserializeOpCreateVpcEndpointServiceConfiguration struct { } -func (*awsEc2query_deserializeOpCreateVpnConcentrator) ID() string { +func (*awsEc2query_deserializeOpCreateVpcEndpointServiceConfiguration) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpCreateVpnConcentrator) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpCreateVpcEndpointServiceConfiguration) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -15017,9 +15017,9 @@ func (m *awsEc2query_deserializeOpCreateVpnConcentrator) HandleDeserialize(ctx c } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorCreateVpnConcentrator(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorCreateVpcEndpointServiceConfiguration(response, &metadata) } - output := &CreateVpnConcentratorOutput{} + output := &CreateVpcEndpointServiceConfigurationOutput{} out.Result = output var buff [1024]byte @@ -15040,7 +15040,7 @@ func (m *awsEc2query_deserializeOpCreateVpnConcentrator) HandleDeserialize(ctx c } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentCreateVpnConcentratorOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentCreateVpcEndpointServiceConfigurationOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -15054,7 +15054,7 @@ func (m *awsEc2query_deserializeOpCreateVpnConcentrator) HandleDeserialize(ctx c return out, metadata, err } -func awsEc2query_deserializeOpErrorCreateVpnConcentrator(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorCreateVpcEndpointServiceConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -15087,14 +15087,14 @@ func awsEc2query_deserializeOpErrorCreateVpnConcentrator(response *smithyhttp.Re } } -type awsEc2query_deserializeOpCreateVpnConnection struct { +type awsEc2query_deserializeOpCreateVpcPeeringConnection struct { } -func (*awsEc2query_deserializeOpCreateVpnConnection) ID() string { +func (*awsEc2query_deserializeOpCreateVpcPeeringConnection) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpCreateVpnConnection) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpCreateVpcPeeringConnection) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -15112,9 +15112,9 @@ func (m *awsEc2query_deserializeOpCreateVpnConnection) HandleDeserialize(ctx con } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorCreateVpnConnection(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorCreateVpcPeeringConnection(response, &metadata) } - output := &CreateVpnConnectionOutput{} + output := &CreateVpcPeeringConnectionOutput{} out.Result = output var buff [1024]byte @@ -15135,7 +15135,7 @@ func (m *awsEc2query_deserializeOpCreateVpnConnection) HandleDeserialize(ctx con } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentCreateVpnConnectionOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentCreateVpcPeeringConnectionOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -15149,7 +15149,7 @@ func (m *awsEc2query_deserializeOpCreateVpnConnection) HandleDeserialize(ctx con return out, metadata, err } -func awsEc2query_deserializeOpErrorCreateVpnConnection(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorCreateVpcPeeringConnection(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -15182,14 +15182,14 @@ func awsEc2query_deserializeOpErrorCreateVpnConnection(response *smithyhttp.Resp } } -type awsEc2query_deserializeOpCreateVpnConnectionRoute struct { +type awsEc2query_deserializeOpCreateVpnConcentrator struct { } -func (*awsEc2query_deserializeOpCreateVpnConnectionRoute) ID() string { +func (*awsEc2query_deserializeOpCreateVpnConcentrator) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpCreateVpnConnectionRoute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpCreateVpnConcentrator) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -15207,21 +15207,44 @@ func (m *awsEc2query_deserializeOpCreateVpnConnectionRoute) HandleDeserialize(ct } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorCreateVpnConnectionRoute(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorCreateVpnConcentrator(response, &metadata) } - output := &CreateVpnConnectionRouteOutput{} + output := &CreateVpnConcentratorOutput{} 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_deserializeOpDocumentCreateVpnConcentratorOutput(&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_deserializeOpErrorCreateVpnConnectionRoute(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorCreateVpnConcentrator(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -15254,14 +15277,14 @@ func awsEc2query_deserializeOpErrorCreateVpnConnectionRoute(response *smithyhttp } } -type awsEc2query_deserializeOpCreateVpnGateway struct { +type awsEc2query_deserializeOpCreateVpnConnection struct { } -func (*awsEc2query_deserializeOpCreateVpnGateway) ID() string { +func (*awsEc2query_deserializeOpCreateVpnConnection) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpCreateVpnGateway) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpCreateVpnConnection) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -15279,9 +15302,9 @@ func (m *awsEc2query_deserializeOpCreateVpnGateway) HandleDeserialize(ctx contex } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorCreateVpnGateway(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorCreateVpnConnection(response, &metadata) } - output := &CreateVpnGatewayOutput{} + output := &CreateVpnConnectionOutput{} out.Result = output var buff [1024]byte @@ -15302,7 +15325,7 @@ func (m *awsEc2query_deserializeOpCreateVpnGateway) HandleDeserialize(ctx contex } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentCreateVpnGatewayOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentCreateVpnConnectionOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -15316,7 +15339,7 @@ func (m *awsEc2query_deserializeOpCreateVpnGateway) HandleDeserialize(ctx contex return out, metadata, err } -func awsEc2query_deserializeOpErrorCreateVpnGateway(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorCreateVpnConnection(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -15349,14 +15372,14 @@ func awsEc2query_deserializeOpErrorCreateVpnGateway(response *smithyhttp.Respons } } -type awsEc2query_deserializeOpDeleteCapacityManagerDataExport struct { +type awsEc2query_deserializeOpCreateVpnConnectionRoute struct { } -func (*awsEc2query_deserializeOpDeleteCapacityManagerDataExport) ID() string { +func (*awsEc2query_deserializeOpCreateVpnConnectionRoute) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDeleteCapacityManagerDataExport) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpCreateVpnConnectionRoute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -15374,44 +15397,21 @@ func (m *awsEc2query_deserializeOpDeleteCapacityManagerDataExport) HandleDeseria } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDeleteCapacityManagerDataExport(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorCreateVpnConnectionRoute(response, &metadata) } - output := &DeleteCapacityManagerDataExportOutput{} + output := &CreateVpnConnectionRouteOutput{} 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_deserializeOpDocumentDeleteCapacityManagerDataExportOutput(&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_deserializeOpErrorDeleteCapacityManagerDataExport(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorCreateVpnConnectionRoute(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -15444,14 +15444,14 @@ func awsEc2query_deserializeOpErrorDeleteCapacityManagerDataExport(response *smi } } -type awsEc2query_deserializeOpDeleteCarrierGateway struct { +type awsEc2query_deserializeOpCreateVpnGateway struct { } -func (*awsEc2query_deserializeOpDeleteCarrierGateway) ID() string { +func (*awsEc2query_deserializeOpCreateVpnGateway) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDeleteCarrierGateway) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpCreateVpnGateway) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -15469,9 +15469,9 @@ func (m *awsEc2query_deserializeOpDeleteCarrierGateway) HandleDeserialize(ctx co } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDeleteCarrierGateway(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorCreateVpnGateway(response, &metadata) } - output := &DeleteCarrierGatewayOutput{} + output := &CreateVpnGatewayOutput{} out.Result = output var buff [1024]byte @@ -15492,7 +15492,7 @@ func (m *awsEc2query_deserializeOpDeleteCarrierGateway) HandleDeserialize(ctx co } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDeleteCarrierGatewayOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentCreateVpnGatewayOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -15506,7 +15506,7 @@ func (m *awsEc2query_deserializeOpDeleteCarrierGateway) HandleDeserialize(ctx co return out, metadata, err } -func awsEc2query_deserializeOpErrorDeleteCarrierGateway(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorCreateVpnGateway(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -15539,14 +15539,14 @@ func awsEc2query_deserializeOpErrorDeleteCarrierGateway(response *smithyhttp.Res } } -type awsEc2query_deserializeOpDeleteClientVpnEndpoint struct { +type awsEc2query_deserializeOpDeleteCapacityManagerDataExport struct { } -func (*awsEc2query_deserializeOpDeleteClientVpnEndpoint) ID() string { +func (*awsEc2query_deserializeOpDeleteCapacityManagerDataExport) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDeleteClientVpnEndpoint) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDeleteCapacityManagerDataExport) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -15564,9 +15564,9 @@ func (m *awsEc2query_deserializeOpDeleteClientVpnEndpoint) HandleDeserialize(ctx } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDeleteClientVpnEndpoint(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDeleteCapacityManagerDataExport(response, &metadata) } - output := &DeleteClientVpnEndpointOutput{} + output := &DeleteCapacityManagerDataExportOutput{} out.Result = output var buff [1024]byte @@ -15587,7 +15587,7 @@ func (m *awsEc2query_deserializeOpDeleteClientVpnEndpoint) HandleDeserialize(ctx } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDeleteClientVpnEndpointOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDeleteCapacityManagerDataExportOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -15601,7 +15601,7 @@ func (m *awsEc2query_deserializeOpDeleteClientVpnEndpoint) HandleDeserialize(ctx return out, metadata, err } -func awsEc2query_deserializeOpErrorDeleteClientVpnEndpoint(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDeleteCapacityManagerDataExport(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -15634,14 +15634,14 @@ func awsEc2query_deserializeOpErrorDeleteClientVpnEndpoint(response *smithyhttp. } } -type awsEc2query_deserializeOpDeleteClientVpnRoute struct { +type awsEc2query_deserializeOpDeleteCarrierGateway struct { } -func (*awsEc2query_deserializeOpDeleteClientVpnRoute) ID() string { +func (*awsEc2query_deserializeOpDeleteCarrierGateway) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDeleteClientVpnRoute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDeleteCarrierGateway) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -15659,9 +15659,9 @@ func (m *awsEc2query_deserializeOpDeleteClientVpnRoute) HandleDeserialize(ctx co } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDeleteClientVpnRoute(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDeleteCarrierGateway(response, &metadata) } - output := &DeleteClientVpnRouteOutput{} + output := &DeleteCarrierGatewayOutput{} out.Result = output var buff [1024]byte @@ -15682,7 +15682,7 @@ func (m *awsEc2query_deserializeOpDeleteClientVpnRoute) HandleDeserialize(ctx co } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDeleteClientVpnRouteOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDeleteCarrierGatewayOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -15696,7 +15696,7 @@ func (m *awsEc2query_deserializeOpDeleteClientVpnRoute) HandleDeserialize(ctx co return out, metadata, err } -func awsEc2query_deserializeOpErrorDeleteClientVpnRoute(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDeleteCarrierGateway(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -15729,14 +15729,14 @@ func awsEc2query_deserializeOpErrorDeleteClientVpnRoute(response *smithyhttp.Res } } -type awsEc2query_deserializeOpDeleteCoipCidr struct { +type awsEc2query_deserializeOpDeleteClientVpnEndpoint struct { } -func (*awsEc2query_deserializeOpDeleteCoipCidr) ID() string { +func (*awsEc2query_deserializeOpDeleteClientVpnEndpoint) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDeleteCoipCidr) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDeleteClientVpnEndpoint) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -15754,9 +15754,9 @@ func (m *awsEc2query_deserializeOpDeleteCoipCidr) HandleDeserialize(ctx context. } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDeleteCoipCidr(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDeleteClientVpnEndpoint(response, &metadata) } - output := &DeleteCoipCidrOutput{} + output := &DeleteClientVpnEndpointOutput{} out.Result = output var buff [1024]byte @@ -15777,7 +15777,7 @@ func (m *awsEc2query_deserializeOpDeleteCoipCidr) HandleDeserialize(ctx context. } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDeleteCoipCidrOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDeleteClientVpnEndpointOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -15791,7 +15791,7 @@ func (m *awsEc2query_deserializeOpDeleteCoipCidr) HandleDeserialize(ctx context. return out, metadata, err } -func awsEc2query_deserializeOpErrorDeleteCoipCidr(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDeleteClientVpnEndpoint(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -15824,14 +15824,14 @@ func awsEc2query_deserializeOpErrorDeleteCoipCidr(response *smithyhttp.Response, } } -type awsEc2query_deserializeOpDeleteCoipPool struct { +type awsEc2query_deserializeOpDeleteClientVpnRoute struct { } -func (*awsEc2query_deserializeOpDeleteCoipPool) ID() string { +func (*awsEc2query_deserializeOpDeleteClientVpnRoute) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDeleteCoipPool) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDeleteClientVpnRoute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -15849,9 +15849,9 @@ func (m *awsEc2query_deserializeOpDeleteCoipPool) HandleDeserialize(ctx context. } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDeleteCoipPool(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDeleteClientVpnRoute(response, &metadata) } - output := &DeleteCoipPoolOutput{} + output := &DeleteClientVpnRouteOutput{} out.Result = output var buff [1024]byte @@ -15872,7 +15872,7 @@ func (m *awsEc2query_deserializeOpDeleteCoipPool) HandleDeserialize(ctx context. } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDeleteCoipPoolOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDeleteClientVpnRouteOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -15886,7 +15886,7 @@ func (m *awsEc2query_deserializeOpDeleteCoipPool) HandleDeserialize(ctx context. return out, metadata, err } -func awsEc2query_deserializeOpErrorDeleteCoipPool(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDeleteClientVpnRoute(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -15919,14 +15919,14 @@ func awsEc2query_deserializeOpErrorDeleteCoipPool(response *smithyhttp.Response, } } -type awsEc2query_deserializeOpDeleteCustomerGateway struct { +type awsEc2query_deserializeOpDeleteCoipCidr struct { } -func (*awsEc2query_deserializeOpDeleteCustomerGateway) ID() string { +func (*awsEc2query_deserializeOpDeleteCoipCidr) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDeleteCustomerGateway) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDeleteCoipCidr) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -15944,21 +15944,211 @@ func (m *awsEc2query_deserializeOpDeleteCustomerGateway) HandleDeserialize(ctx c } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDeleteCustomerGateway(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDeleteCoipCidr(response, &metadata) } - output := &DeleteCustomerGatewayOutput{} + output := &DeleteCoipCidrOutput{} 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_deserializeOpDocumentDeleteCoipCidrOutput(&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_deserializeOpErrorDeleteCustomerGateway(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDeleteCoipCidr(response *smithyhttp.Response, metadata *middleware.Metadata) error { + var errorBuffer bytes.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_deserializeOpDeleteCoipPool struct { +} + +func (*awsEc2query_deserializeOpDeleteCoipPool) ID() string { + return "OperationDeserializer" +} + +func (m *awsEc2query_deserializeOpDeleteCoipPool) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( + out middleware.DeserializeOutput, metadata middleware.Metadata, err error, +) { + out, metadata, err = next.HandleDeserialize(ctx, in) + if err != nil { + return out, metadata, err + } + + _, span := tracing.StartSpan(ctx, "OperationDeserializer") + endTimer := startMetricTimer(ctx, "client.call.deserialization_duration") + defer endTimer() + defer span.End() + response, ok := out.RawResponse.(*smithyhttp.Response) + if !ok { + return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} + } + + if response.StatusCode < 200 || response.StatusCode >= 300 { + return out, metadata, awsEc2query_deserializeOpErrorDeleteCoipPool(response, &metadata) + } + output := &DeleteCoipPoolOutput{} + 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_deserializeOpDocumentDeleteCoipPoolOutput(&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_deserializeOpErrorDeleteCoipPool(response *smithyhttp.Response, metadata *middleware.Metadata) error { + var errorBuffer bytes.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_deserializeOpDeleteCustomerGateway struct { +} + +func (*awsEc2query_deserializeOpDeleteCustomerGateway) ID() string { + return "OperationDeserializer" +} + +func (m *awsEc2query_deserializeOpDeleteCustomerGateway) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( + out middleware.DeserializeOutput, metadata middleware.Metadata, err error, +) { + out, metadata, err = next.HandleDeserialize(ctx, in) + if err != nil { + return out, metadata, err + } + + _, span := tracing.StartSpan(ctx, "OperationDeserializer") + endTimer := startMetricTimer(ctx, "client.call.deserialization_duration") + defer endTimer() + defer span.End() + response, ok := out.RawResponse.(*smithyhttp.Response) + if !ok { + return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} + } + + if response.StatusCode < 200 || response.StatusCode >= 300 { + return out, metadata, awsEc2query_deserializeOpErrorDeleteCustomerGateway(response, &metadata) + } + output := &DeleteCustomerGatewayOutput{} + 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_deserializeOpErrorDeleteCustomerGateway(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -19987,14 +20177,14 @@ func awsEc2query_deserializeOpErrorDeleteRouteTable(response *smithyhttp.Respons } } -type awsEc2query_deserializeOpDeleteSecurityGroup struct { +type awsEc2query_deserializeOpDeleteSecondaryNetwork struct { } -func (*awsEc2query_deserializeOpDeleteSecurityGroup) ID() string { +func (*awsEc2query_deserializeOpDeleteSecondaryNetwork) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDeleteSecurityGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDeleteSecondaryNetwork) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -20012,9 +20202,9 @@ func (m *awsEc2query_deserializeOpDeleteSecurityGroup) HandleDeserialize(ctx con } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDeleteSecurityGroup(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDeleteSecondaryNetwork(response, &metadata) } - output := &DeleteSecurityGroupOutput{} + output := &DeleteSecondaryNetworkOutput{} out.Result = output var buff [1024]byte @@ -20035,7 +20225,7 @@ func (m *awsEc2query_deserializeOpDeleteSecurityGroup) HandleDeserialize(ctx con } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDeleteSecurityGroupOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDeleteSecondaryNetworkOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -20049,7 +20239,7 @@ func (m *awsEc2query_deserializeOpDeleteSecurityGroup) HandleDeserialize(ctx con return out, metadata, err } -func awsEc2query_deserializeOpErrorDeleteSecurityGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDeleteSecondaryNetwork(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -20082,14 +20272,14 @@ func awsEc2query_deserializeOpErrorDeleteSecurityGroup(response *smithyhttp.Resp } } -type awsEc2query_deserializeOpDeleteSnapshot struct { +type awsEc2query_deserializeOpDeleteSecondarySubnet struct { } -func (*awsEc2query_deserializeOpDeleteSnapshot) ID() string { +func (*awsEc2query_deserializeOpDeleteSecondarySubnet) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDeleteSnapshot) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDeleteSecondarySubnet) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -20107,21 +20297,44 @@ func (m *awsEc2query_deserializeOpDeleteSnapshot) HandleDeserialize(ctx context. } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDeleteSnapshot(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDeleteSecondarySubnet(response, &metadata) } - output := &DeleteSnapshotOutput{} + output := &DeleteSecondarySubnetOutput{} 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_deserializeOpDocumentDeleteSecondarySubnetOutput(&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_deserializeOpErrorDeleteSnapshot(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDeleteSecondarySubnet(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -20154,14 +20367,14 @@ func awsEc2query_deserializeOpErrorDeleteSnapshot(response *smithyhttp.Response, } } -type awsEc2query_deserializeOpDeleteSpotDatafeedSubscription struct { +type awsEc2query_deserializeOpDeleteSecurityGroup struct { } -func (*awsEc2query_deserializeOpDeleteSpotDatafeedSubscription) ID() string { +func (*awsEc2query_deserializeOpDeleteSecurityGroup) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDeleteSpotDatafeedSubscription) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDeleteSecurityGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -20179,21 +20392,44 @@ func (m *awsEc2query_deserializeOpDeleteSpotDatafeedSubscription) HandleDeserial } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDeleteSpotDatafeedSubscription(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDeleteSecurityGroup(response, &metadata) } - output := &DeleteSpotDatafeedSubscriptionOutput{} + output := &DeleteSecurityGroupOutput{} 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_deserializeOpDocumentDeleteSecurityGroupOutput(&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_deserializeOpErrorDeleteSpotDatafeedSubscription(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDeleteSecurityGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -20226,14 +20462,14 @@ func awsEc2query_deserializeOpErrorDeleteSpotDatafeedSubscription(response *smit } } -type awsEc2query_deserializeOpDeleteSubnet struct { +type awsEc2query_deserializeOpDeleteSnapshot struct { } -func (*awsEc2query_deserializeOpDeleteSubnet) ID() string { +func (*awsEc2query_deserializeOpDeleteSnapshot) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDeleteSubnet) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDeleteSnapshot) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -20251,9 +20487,9 @@ func (m *awsEc2query_deserializeOpDeleteSubnet) HandleDeserialize(ctx context.Co } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDeleteSubnet(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDeleteSnapshot(response, &metadata) } - output := &DeleteSubnetOutput{} + output := &DeleteSnapshotOutput{} out.Result = output if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { @@ -20265,7 +20501,7 @@ func (m *awsEc2query_deserializeOpDeleteSubnet) HandleDeserialize(ctx context.Co return out, metadata, err } -func awsEc2query_deserializeOpErrorDeleteSubnet(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDeleteSnapshot(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -20298,14 +20534,14 @@ func awsEc2query_deserializeOpErrorDeleteSubnet(response *smithyhttp.Response, m } } -type awsEc2query_deserializeOpDeleteSubnetCidrReservation struct { +type awsEc2query_deserializeOpDeleteSpotDatafeedSubscription struct { } -func (*awsEc2query_deserializeOpDeleteSubnetCidrReservation) ID() string { +func (*awsEc2query_deserializeOpDeleteSpotDatafeedSubscription) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDeleteSubnetCidrReservation) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDeleteSpotDatafeedSubscription) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -20323,44 +20559,21 @@ func (m *awsEc2query_deserializeOpDeleteSubnetCidrReservation) HandleDeserialize } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDeleteSubnetCidrReservation(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDeleteSpotDatafeedSubscription(response, &metadata) } - output := &DeleteSubnetCidrReservationOutput{} + output := &DeleteSpotDatafeedSubscriptionOutput{} 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_deserializeOpDocumentDeleteSubnetCidrReservationOutput(&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_deserializeOpErrorDeleteSubnetCidrReservation(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDeleteSpotDatafeedSubscription(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -20393,14 +20606,14 @@ func awsEc2query_deserializeOpErrorDeleteSubnetCidrReservation(response *smithyh } } -type awsEc2query_deserializeOpDeleteTags struct { +type awsEc2query_deserializeOpDeleteSubnet struct { } -func (*awsEc2query_deserializeOpDeleteTags) ID() string { +func (*awsEc2query_deserializeOpDeleteSubnet) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDeleteTags) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDeleteSubnet) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -20418,9 +20631,9 @@ func (m *awsEc2query_deserializeOpDeleteTags) HandleDeserialize(ctx context.Cont } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDeleteTags(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDeleteSubnet(response, &metadata) } - output := &DeleteTagsOutput{} + output := &DeleteSubnetOutput{} out.Result = output if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { @@ -20432,7 +20645,7 @@ func (m *awsEc2query_deserializeOpDeleteTags) HandleDeserialize(ctx context.Cont return out, metadata, err } -func awsEc2query_deserializeOpErrorDeleteTags(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDeleteSubnet(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -20465,14 +20678,14 @@ func awsEc2query_deserializeOpErrorDeleteTags(response *smithyhttp.Response, met } } -type awsEc2query_deserializeOpDeleteTrafficMirrorFilter struct { +type awsEc2query_deserializeOpDeleteSubnetCidrReservation struct { } -func (*awsEc2query_deserializeOpDeleteTrafficMirrorFilter) ID() string { +func (*awsEc2query_deserializeOpDeleteSubnetCidrReservation) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDeleteTrafficMirrorFilter) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDeleteSubnetCidrReservation) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -20490,9 +20703,9 @@ func (m *awsEc2query_deserializeOpDeleteTrafficMirrorFilter) HandleDeserialize(c } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDeleteTrafficMirrorFilter(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDeleteSubnetCidrReservation(response, &metadata) } - output := &DeleteTrafficMirrorFilterOutput{} + output := &DeleteSubnetCidrReservationOutput{} out.Result = output var buff [1024]byte @@ -20513,7 +20726,7 @@ func (m *awsEc2query_deserializeOpDeleteTrafficMirrorFilter) HandleDeserialize(c } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDeleteTrafficMirrorFilterOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDeleteSubnetCidrReservationOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -20527,7 +20740,7 @@ func (m *awsEc2query_deserializeOpDeleteTrafficMirrorFilter) HandleDeserialize(c return out, metadata, err } -func awsEc2query_deserializeOpErrorDeleteTrafficMirrorFilter(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDeleteSubnetCidrReservation(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -20560,14 +20773,14 @@ func awsEc2query_deserializeOpErrorDeleteTrafficMirrorFilter(response *smithyhtt } } -type awsEc2query_deserializeOpDeleteTrafficMirrorFilterRule struct { +type awsEc2query_deserializeOpDeleteTags struct { } -func (*awsEc2query_deserializeOpDeleteTrafficMirrorFilterRule) ID() string { +func (*awsEc2query_deserializeOpDeleteTags) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDeleteTrafficMirrorFilterRule) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDeleteTags) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -20585,44 +20798,21 @@ func (m *awsEc2query_deserializeOpDeleteTrafficMirrorFilterRule) HandleDeseriali } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDeleteTrafficMirrorFilterRule(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDeleteTags(response, &metadata) } - output := &DeleteTrafficMirrorFilterRuleOutput{} + output := &DeleteTagsOutput{} 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_deserializeOpDocumentDeleteTrafficMirrorFilterRuleOutput(&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_deserializeOpErrorDeleteTrafficMirrorFilterRule(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDeleteTags(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -20655,14 +20845,14 @@ func awsEc2query_deserializeOpErrorDeleteTrafficMirrorFilterRule(response *smith } } -type awsEc2query_deserializeOpDeleteTrafficMirrorSession struct { +type awsEc2query_deserializeOpDeleteTrafficMirrorFilter struct { } -func (*awsEc2query_deserializeOpDeleteTrafficMirrorSession) ID() string { +func (*awsEc2query_deserializeOpDeleteTrafficMirrorFilter) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDeleteTrafficMirrorSession) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDeleteTrafficMirrorFilter) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -20680,9 +20870,9 @@ func (m *awsEc2query_deserializeOpDeleteTrafficMirrorSession) HandleDeserialize( } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDeleteTrafficMirrorSession(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDeleteTrafficMirrorFilter(response, &metadata) } - output := &DeleteTrafficMirrorSessionOutput{} + output := &DeleteTrafficMirrorFilterOutput{} out.Result = output var buff [1024]byte @@ -20703,7 +20893,7 @@ func (m *awsEc2query_deserializeOpDeleteTrafficMirrorSession) HandleDeserialize( } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDeleteTrafficMirrorSessionOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDeleteTrafficMirrorFilterOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -20717,7 +20907,7 @@ func (m *awsEc2query_deserializeOpDeleteTrafficMirrorSession) HandleDeserialize( return out, metadata, err } -func awsEc2query_deserializeOpErrorDeleteTrafficMirrorSession(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDeleteTrafficMirrorFilter(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -20750,14 +20940,14 @@ func awsEc2query_deserializeOpErrorDeleteTrafficMirrorSession(response *smithyht } } -type awsEc2query_deserializeOpDeleteTrafficMirrorTarget struct { +type awsEc2query_deserializeOpDeleteTrafficMirrorFilterRule struct { } -func (*awsEc2query_deserializeOpDeleteTrafficMirrorTarget) ID() string { +func (*awsEc2query_deserializeOpDeleteTrafficMirrorFilterRule) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDeleteTrafficMirrorTarget) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDeleteTrafficMirrorFilterRule) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -20775,9 +20965,9 @@ func (m *awsEc2query_deserializeOpDeleteTrafficMirrorTarget) HandleDeserialize(c } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDeleteTrafficMirrorTarget(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDeleteTrafficMirrorFilterRule(response, &metadata) } - output := &DeleteTrafficMirrorTargetOutput{} + output := &DeleteTrafficMirrorFilterRuleOutput{} out.Result = output var buff [1024]byte @@ -20798,7 +20988,7 @@ func (m *awsEc2query_deserializeOpDeleteTrafficMirrorTarget) HandleDeserialize(c } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDeleteTrafficMirrorTargetOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDeleteTrafficMirrorFilterRuleOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -20812,7 +21002,7 @@ func (m *awsEc2query_deserializeOpDeleteTrafficMirrorTarget) HandleDeserialize(c return out, metadata, err } -func awsEc2query_deserializeOpErrorDeleteTrafficMirrorTarget(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDeleteTrafficMirrorFilterRule(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -20845,14 +21035,14 @@ func awsEc2query_deserializeOpErrorDeleteTrafficMirrorTarget(response *smithyhtt } } -type awsEc2query_deserializeOpDeleteTransitGateway struct { +type awsEc2query_deserializeOpDeleteTrafficMirrorSession struct { } -func (*awsEc2query_deserializeOpDeleteTransitGateway) ID() string { +func (*awsEc2query_deserializeOpDeleteTrafficMirrorSession) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDeleteTransitGateway) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDeleteTrafficMirrorSession) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -20870,9 +21060,9 @@ func (m *awsEc2query_deserializeOpDeleteTransitGateway) HandleDeserialize(ctx co } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDeleteTransitGateway(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDeleteTrafficMirrorSession(response, &metadata) } - output := &DeleteTransitGatewayOutput{} + output := &DeleteTrafficMirrorSessionOutput{} out.Result = output var buff [1024]byte @@ -20893,7 +21083,7 @@ func (m *awsEc2query_deserializeOpDeleteTransitGateway) HandleDeserialize(ctx co } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDeleteTransitGatewayOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDeleteTrafficMirrorSessionOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -20907,7 +21097,7 @@ func (m *awsEc2query_deserializeOpDeleteTransitGateway) HandleDeserialize(ctx co return out, metadata, err } -func awsEc2query_deserializeOpErrorDeleteTransitGateway(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDeleteTrafficMirrorSession(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -20940,14 +21130,14 @@ func awsEc2query_deserializeOpErrorDeleteTransitGateway(response *smithyhttp.Res } } -type awsEc2query_deserializeOpDeleteTransitGatewayConnect struct { +type awsEc2query_deserializeOpDeleteTrafficMirrorTarget struct { } -func (*awsEc2query_deserializeOpDeleteTransitGatewayConnect) ID() string { +func (*awsEc2query_deserializeOpDeleteTrafficMirrorTarget) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDeleteTransitGatewayConnect) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDeleteTrafficMirrorTarget) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -20965,9 +21155,9 @@ func (m *awsEc2query_deserializeOpDeleteTransitGatewayConnect) HandleDeserialize } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDeleteTransitGatewayConnect(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDeleteTrafficMirrorTarget(response, &metadata) } - output := &DeleteTransitGatewayConnectOutput{} + output := &DeleteTrafficMirrorTargetOutput{} out.Result = output var buff [1024]byte @@ -20988,7 +21178,7 @@ func (m *awsEc2query_deserializeOpDeleteTransitGatewayConnect) HandleDeserialize } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDeleteTransitGatewayConnectOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDeleteTrafficMirrorTargetOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -21002,7 +21192,7 @@ func (m *awsEc2query_deserializeOpDeleteTransitGatewayConnect) HandleDeserialize return out, metadata, err } -func awsEc2query_deserializeOpErrorDeleteTransitGatewayConnect(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDeleteTrafficMirrorTarget(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -21035,14 +21225,14 @@ func awsEc2query_deserializeOpErrorDeleteTransitGatewayConnect(response *smithyh } } -type awsEc2query_deserializeOpDeleteTransitGatewayConnectPeer struct { +type awsEc2query_deserializeOpDeleteTransitGateway struct { } -func (*awsEc2query_deserializeOpDeleteTransitGatewayConnectPeer) ID() string { +func (*awsEc2query_deserializeOpDeleteTransitGateway) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDeleteTransitGatewayConnectPeer) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDeleteTransitGateway) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -21060,9 +21250,9 @@ func (m *awsEc2query_deserializeOpDeleteTransitGatewayConnectPeer) HandleDeseria } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDeleteTransitGatewayConnectPeer(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDeleteTransitGateway(response, &metadata) } - output := &DeleteTransitGatewayConnectPeerOutput{} + output := &DeleteTransitGatewayOutput{} out.Result = output var buff [1024]byte @@ -21083,7 +21273,7 @@ func (m *awsEc2query_deserializeOpDeleteTransitGatewayConnectPeer) HandleDeseria } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDeleteTransitGatewayConnectPeerOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDeleteTransitGatewayOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -21097,7 +21287,7 @@ func (m *awsEc2query_deserializeOpDeleteTransitGatewayConnectPeer) HandleDeseria return out, metadata, err } -func awsEc2query_deserializeOpErrorDeleteTransitGatewayConnectPeer(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDeleteTransitGateway(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -21130,14 +21320,14 @@ func awsEc2query_deserializeOpErrorDeleteTransitGatewayConnectPeer(response *smi } } -type awsEc2query_deserializeOpDeleteTransitGatewayMeteringPolicy struct { +type awsEc2query_deserializeOpDeleteTransitGatewayConnect struct { } -func (*awsEc2query_deserializeOpDeleteTransitGatewayMeteringPolicy) ID() string { +func (*awsEc2query_deserializeOpDeleteTransitGatewayConnect) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDeleteTransitGatewayMeteringPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDeleteTransitGatewayConnect) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -21155,9 +21345,9 @@ func (m *awsEc2query_deserializeOpDeleteTransitGatewayMeteringPolicy) HandleDese } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDeleteTransitGatewayMeteringPolicy(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDeleteTransitGatewayConnect(response, &metadata) } - output := &DeleteTransitGatewayMeteringPolicyOutput{} + output := &DeleteTransitGatewayConnectOutput{} out.Result = output var buff [1024]byte @@ -21178,7 +21368,7 @@ func (m *awsEc2query_deserializeOpDeleteTransitGatewayMeteringPolicy) HandleDese } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDeleteTransitGatewayMeteringPolicyOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDeleteTransitGatewayConnectOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -21192,7 +21382,7 @@ func (m *awsEc2query_deserializeOpDeleteTransitGatewayMeteringPolicy) HandleDese return out, metadata, err } -func awsEc2query_deserializeOpErrorDeleteTransitGatewayMeteringPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDeleteTransitGatewayConnect(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -21225,14 +21415,14 @@ func awsEc2query_deserializeOpErrorDeleteTransitGatewayMeteringPolicy(response * } } -type awsEc2query_deserializeOpDeleteTransitGatewayMeteringPolicyEntry struct { +type awsEc2query_deserializeOpDeleteTransitGatewayConnectPeer struct { } -func (*awsEc2query_deserializeOpDeleteTransitGatewayMeteringPolicyEntry) ID() string { +func (*awsEc2query_deserializeOpDeleteTransitGatewayConnectPeer) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDeleteTransitGatewayMeteringPolicyEntry) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDeleteTransitGatewayConnectPeer) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -21250,9 +21440,9 @@ func (m *awsEc2query_deserializeOpDeleteTransitGatewayMeteringPolicyEntry) Handl } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDeleteTransitGatewayMeteringPolicyEntry(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDeleteTransitGatewayConnectPeer(response, &metadata) } - output := &DeleteTransitGatewayMeteringPolicyEntryOutput{} + output := &DeleteTransitGatewayConnectPeerOutput{} out.Result = output var buff [1024]byte @@ -21273,7 +21463,7 @@ func (m *awsEc2query_deserializeOpDeleteTransitGatewayMeteringPolicyEntry) Handl } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDeleteTransitGatewayMeteringPolicyEntryOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDeleteTransitGatewayConnectPeerOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -21287,7 +21477,7 @@ func (m *awsEc2query_deserializeOpDeleteTransitGatewayMeteringPolicyEntry) Handl return out, metadata, err } -func awsEc2query_deserializeOpErrorDeleteTransitGatewayMeteringPolicyEntry(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDeleteTransitGatewayConnectPeer(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -21320,14 +21510,14 @@ func awsEc2query_deserializeOpErrorDeleteTransitGatewayMeteringPolicyEntry(respo } } -type awsEc2query_deserializeOpDeleteTransitGatewayMulticastDomain struct { +type awsEc2query_deserializeOpDeleteTransitGatewayMeteringPolicy struct { } -func (*awsEc2query_deserializeOpDeleteTransitGatewayMulticastDomain) ID() string { +func (*awsEc2query_deserializeOpDeleteTransitGatewayMeteringPolicy) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDeleteTransitGatewayMulticastDomain) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDeleteTransitGatewayMeteringPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -21345,9 +21535,9 @@ func (m *awsEc2query_deserializeOpDeleteTransitGatewayMulticastDomain) HandleDes } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDeleteTransitGatewayMulticastDomain(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDeleteTransitGatewayMeteringPolicy(response, &metadata) } - output := &DeleteTransitGatewayMulticastDomainOutput{} + output := &DeleteTransitGatewayMeteringPolicyOutput{} out.Result = output var buff [1024]byte @@ -21368,7 +21558,7 @@ func (m *awsEc2query_deserializeOpDeleteTransitGatewayMulticastDomain) HandleDes } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDeleteTransitGatewayMulticastDomainOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDeleteTransitGatewayMeteringPolicyOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -21382,7 +21572,7 @@ func (m *awsEc2query_deserializeOpDeleteTransitGatewayMulticastDomain) HandleDes return out, metadata, err } -func awsEc2query_deserializeOpErrorDeleteTransitGatewayMulticastDomain(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDeleteTransitGatewayMeteringPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -21415,14 +21605,14 @@ func awsEc2query_deserializeOpErrorDeleteTransitGatewayMulticastDomain(response } } -type awsEc2query_deserializeOpDeleteTransitGatewayPeeringAttachment struct { +type awsEc2query_deserializeOpDeleteTransitGatewayMeteringPolicyEntry struct { } -func (*awsEc2query_deserializeOpDeleteTransitGatewayPeeringAttachment) ID() string { +func (*awsEc2query_deserializeOpDeleteTransitGatewayMeteringPolicyEntry) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDeleteTransitGatewayPeeringAttachment) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDeleteTransitGatewayMeteringPolicyEntry) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -21440,9 +21630,9 @@ func (m *awsEc2query_deserializeOpDeleteTransitGatewayPeeringAttachment) HandleD } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDeleteTransitGatewayPeeringAttachment(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDeleteTransitGatewayMeteringPolicyEntry(response, &metadata) } - output := &DeleteTransitGatewayPeeringAttachmentOutput{} + output := &DeleteTransitGatewayMeteringPolicyEntryOutput{} out.Result = output var buff [1024]byte @@ -21463,7 +21653,7 @@ func (m *awsEc2query_deserializeOpDeleteTransitGatewayPeeringAttachment) HandleD } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDeleteTransitGatewayPeeringAttachmentOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDeleteTransitGatewayMeteringPolicyEntryOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -21477,7 +21667,7 @@ func (m *awsEc2query_deserializeOpDeleteTransitGatewayPeeringAttachment) HandleD return out, metadata, err } -func awsEc2query_deserializeOpErrorDeleteTransitGatewayPeeringAttachment(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDeleteTransitGatewayMeteringPolicyEntry(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -21510,14 +21700,14 @@ func awsEc2query_deserializeOpErrorDeleteTransitGatewayPeeringAttachment(respons } } -type awsEc2query_deserializeOpDeleteTransitGatewayPolicyTable struct { +type awsEc2query_deserializeOpDeleteTransitGatewayMulticastDomain struct { } -func (*awsEc2query_deserializeOpDeleteTransitGatewayPolicyTable) ID() string { +func (*awsEc2query_deserializeOpDeleteTransitGatewayMulticastDomain) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDeleteTransitGatewayPolicyTable) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDeleteTransitGatewayMulticastDomain) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -21535,9 +21725,9 @@ func (m *awsEc2query_deserializeOpDeleteTransitGatewayPolicyTable) HandleDeseria } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDeleteTransitGatewayPolicyTable(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDeleteTransitGatewayMulticastDomain(response, &metadata) } - output := &DeleteTransitGatewayPolicyTableOutput{} + output := &DeleteTransitGatewayMulticastDomainOutput{} out.Result = output var buff [1024]byte @@ -21558,7 +21748,7 @@ func (m *awsEc2query_deserializeOpDeleteTransitGatewayPolicyTable) HandleDeseria } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDeleteTransitGatewayPolicyTableOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDeleteTransitGatewayMulticastDomainOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -21572,7 +21762,7 @@ func (m *awsEc2query_deserializeOpDeleteTransitGatewayPolicyTable) HandleDeseria return out, metadata, err } -func awsEc2query_deserializeOpErrorDeleteTransitGatewayPolicyTable(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDeleteTransitGatewayMulticastDomain(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -21605,14 +21795,14 @@ func awsEc2query_deserializeOpErrorDeleteTransitGatewayPolicyTable(response *smi } } -type awsEc2query_deserializeOpDeleteTransitGatewayPrefixListReference struct { +type awsEc2query_deserializeOpDeleteTransitGatewayPeeringAttachment struct { } -func (*awsEc2query_deserializeOpDeleteTransitGatewayPrefixListReference) ID() string { +func (*awsEc2query_deserializeOpDeleteTransitGatewayPeeringAttachment) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDeleteTransitGatewayPrefixListReference) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDeleteTransitGatewayPeeringAttachment) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -21630,9 +21820,9 @@ func (m *awsEc2query_deserializeOpDeleteTransitGatewayPrefixListReference) Handl } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDeleteTransitGatewayPrefixListReference(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDeleteTransitGatewayPeeringAttachment(response, &metadata) } - output := &DeleteTransitGatewayPrefixListReferenceOutput{} + output := &DeleteTransitGatewayPeeringAttachmentOutput{} out.Result = output var buff [1024]byte @@ -21653,7 +21843,7 @@ func (m *awsEc2query_deserializeOpDeleteTransitGatewayPrefixListReference) Handl } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDeleteTransitGatewayPrefixListReferenceOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDeleteTransitGatewayPeeringAttachmentOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -21667,7 +21857,7 @@ func (m *awsEc2query_deserializeOpDeleteTransitGatewayPrefixListReference) Handl return out, metadata, err } -func awsEc2query_deserializeOpErrorDeleteTransitGatewayPrefixListReference(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDeleteTransitGatewayPeeringAttachment(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -21700,14 +21890,14 @@ func awsEc2query_deserializeOpErrorDeleteTransitGatewayPrefixListReference(respo } } -type awsEc2query_deserializeOpDeleteTransitGatewayRoute struct { +type awsEc2query_deserializeOpDeleteTransitGatewayPolicyTable struct { } -func (*awsEc2query_deserializeOpDeleteTransitGatewayRoute) ID() string { +func (*awsEc2query_deserializeOpDeleteTransitGatewayPolicyTable) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDeleteTransitGatewayRoute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDeleteTransitGatewayPolicyTable) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -21725,9 +21915,9 @@ func (m *awsEc2query_deserializeOpDeleteTransitGatewayRoute) HandleDeserialize(c } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDeleteTransitGatewayRoute(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDeleteTransitGatewayPolicyTable(response, &metadata) } - output := &DeleteTransitGatewayRouteOutput{} + output := &DeleteTransitGatewayPolicyTableOutput{} out.Result = output var buff [1024]byte @@ -21748,7 +21938,7 @@ func (m *awsEc2query_deserializeOpDeleteTransitGatewayRoute) HandleDeserialize(c } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDeleteTransitGatewayRouteOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDeleteTransitGatewayPolicyTableOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -21762,7 +21952,7 @@ func (m *awsEc2query_deserializeOpDeleteTransitGatewayRoute) HandleDeserialize(c return out, metadata, err } -func awsEc2query_deserializeOpErrorDeleteTransitGatewayRoute(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDeleteTransitGatewayPolicyTable(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -21795,14 +21985,14 @@ func awsEc2query_deserializeOpErrorDeleteTransitGatewayRoute(response *smithyhtt } } -type awsEc2query_deserializeOpDeleteTransitGatewayRouteTable struct { +type awsEc2query_deserializeOpDeleteTransitGatewayPrefixListReference struct { } -func (*awsEc2query_deserializeOpDeleteTransitGatewayRouteTable) ID() string { +func (*awsEc2query_deserializeOpDeleteTransitGatewayPrefixListReference) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDeleteTransitGatewayRouteTable) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDeleteTransitGatewayPrefixListReference) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -21820,9 +22010,9 @@ func (m *awsEc2query_deserializeOpDeleteTransitGatewayRouteTable) HandleDeserial } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDeleteTransitGatewayRouteTable(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDeleteTransitGatewayPrefixListReference(response, &metadata) } - output := &DeleteTransitGatewayRouteTableOutput{} + output := &DeleteTransitGatewayPrefixListReferenceOutput{} out.Result = output var buff [1024]byte @@ -21843,7 +22033,7 @@ func (m *awsEc2query_deserializeOpDeleteTransitGatewayRouteTable) HandleDeserial } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDeleteTransitGatewayRouteTableOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDeleteTransitGatewayPrefixListReferenceOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -21857,7 +22047,7 @@ func (m *awsEc2query_deserializeOpDeleteTransitGatewayRouteTable) HandleDeserial return out, metadata, err } -func awsEc2query_deserializeOpErrorDeleteTransitGatewayRouteTable(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDeleteTransitGatewayPrefixListReference(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -21890,14 +22080,14 @@ func awsEc2query_deserializeOpErrorDeleteTransitGatewayRouteTable(response *smit } } -type awsEc2query_deserializeOpDeleteTransitGatewayRouteTableAnnouncement struct { +type awsEc2query_deserializeOpDeleteTransitGatewayRoute struct { } -func (*awsEc2query_deserializeOpDeleteTransitGatewayRouteTableAnnouncement) ID() string { +func (*awsEc2query_deserializeOpDeleteTransitGatewayRoute) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDeleteTransitGatewayRouteTableAnnouncement) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDeleteTransitGatewayRoute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -21915,9 +22105,9 @@ func (m *awsEc2query_deserializeOpDeleteTransitGatewayRouteTableAnnouncement) Ha } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDeleteTransitGatewayRouteTableAnnouncement(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDeleteTransitGatewayRoute(response, &metadata) } - output := &DeleteTransitGatewayRouteTableAnnouncementOutput{} + output := &DeleteTransitGatewayRouteOutput{} out.Result = output var buff [1024]byte @@ -21938,7 +22128,7 @@ func (m *awsEc2query_deserializeOpDeleteTransitGatewayRouteTableAnnouncement) Ha } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDeleteTransitGatewayRouteTableAnnouncementOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDeleteTransitGatewayRouteOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -21952,7 +22142,7 @@ func (m *awsEc2query_deserializeOpDeleteTransitGatewayRouteTableAnnouncement) Ha return out, metadata, err } -func awsEc2query_deserializeOpErrorDeleteTransitGatewayRouteTableAnnouncement(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDeleteTransitGatewayRoute(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -21985,14 +22175,14 @@ func awsEc2query_deserializeOpErrorDeleteTransitGatewayRouteTableAnnouncement(re } } -type awsEc2query_deserializeOpDeleteTransitGatewayVpcAttachment struct { +type awsEc2query_deserializeOpDeleteTransitGatewayRouteTable struct { } -func (*awsEc2query_deserializeOpDeleteTransitGatewayVpcAttachment) ID() string { +func (*awsEc2query_deserializeOpDeleteTransitGatewayRouteTable) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDeleteTransitGatewayVpcAttachment) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDeleteTransitGatewayRouteTable) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -22010,9 +22200,9 @@ func (m *awsEc2query_deserializeOpDeleteTransitGatewayVpcAttachment) HandleDeser } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDeleteTransitGatewayVpcAttachment(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDeleteTransitGatewayRouteTable(response, &metadata) } - output := &DeleteTransitGatewayVpcAttachmentOutput{} + output := &DeleteTransitGatewayRouteTableOutput{} out.Result = output var buff [1024]byte @@ -22033,7 +22223,7 @@ func (m *awsEc2query_deserializeOpDeleteTransitGatewayVpcAttachment) HandleDeser } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDeleteTransitGatewayVpcAttachmentOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDeleteTransitGatewayRouteTableOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -22047,7 +22237,7 @@ func (m *awsEc2query_deserializeOpDeleteTransitGatewayVpcAttachment) HandleDeser return out, metadata, err } -func awsEc2query_deserializeOpErrorDeleteTransitGatewayVpcAttachment(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDeleteTransitGatewayRouteTable(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -22080,14 +22270,14 @@ func awsEc2query_deserializeOpErrorDeleteTransitGatewayVpcAttachment(response *s } } -type awsEc2query_deserializeOpDeleteVerifiedAccessEndpoint struct { +type awsEc2query_deserializeOpDeleteTransitGatewayRouteTableAnnouncement struct { } -func (*awsEc2query_deserializeOpDeleteVerifiedAccessEndpoint) ID() string { +func (*awsEc2query_deserializeOpDeleteTransitGatewayRouteTableAnnouncement) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDeleteVerifiedAccessEndpoint) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDeleteTransitGatewayRouteTableAnnouncement) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -22105,9 +22295,9 @@ func (m *awsEc2query_deserializeOpDeleteVerifiedAccessEndpoint) HandleDeserializ } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDeleteVerifiedAccessEndpoint(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDeleteTransitGatewayRouteTableAnnouncement(response, &metadata) } - output := &DeleteVerifiedAccessEndpointOutput{} + output := &DeleteTransitGatewayRouteTableAnnouncementOutput{} out.Result = output var buff [1024]byte @@ -22128,7 +22318,7 @@ func (m *awsEc2query_deserializeOpDeleteVerifiedAccessEndpoint) HandleDeserializ } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDeleteVerifiedAccessEndpointOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDeleteTransitGatewayRouteTableAnnouncementOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -22142,7 +22332,7 @@ func (m *awsEc2query_deserializeOpDeleteVerifiedAccessEndpoint) HandleDeserializ return out, metadata, err } -func awsEc2query_deserializeOpErrorDeleteVerifiedAccessEndpoint(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDeleteTransitGatewayRouteTableAnnouncement(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -22175,14 +22365,14 @@ func awsEc2query_deserializeOpErrorDeleteVerifiedAccessEndpoint(response *smithy } } -type awsEc2query_deserializeOpDeleteVerifiedAccessGroup struct { +type awsEc2query_deserializeOpDeleteTransitGatewayVpcAttachment struct { } -func (*awsEc2query_deserializeOpDeleteVerifiedAccessGroup) ID() string { +func (*awsEc2query_deserializeOpDeleteTransitGatewayVpcAttachment) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDeleteVerifiedAccessGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDeleteTransitGatewayVpcAttachment) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -22200,9 +22390,9 @@ func (m *awsEc2query_deserializeOpDeleteVerifiedAccessGroup) HandleDeserialize(c } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDeleteVerifiedAccessGroup(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDeleteTransitGatewayVpcAttachment(response, &metadata) } - output := &DeleteVerifiedAccessGroupOutput{} + output := &DeleteTransitGatewayVpcAttachmentOutput{} out.Result = output var buff [1024]byte @@ -22223,7 +22413,7 @@ func (m *awsEc2query_deserializeOpDeleteVerifiedAccessGroup) HandleDeserialize(c } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDeleteVerifiedAccessGroupOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDeleteTransitGatewayVpcAttachmentOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -22237,7 +22427,7 @@ func (m *awsEc2query_deserializeOpDeleteVerifiedAccessGroup) HandleDeserialize(c return out, metadata, err } -func awsEc2query_deserializeOpErrorDeleteVerifiedAccessGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDeleteTransitGatewayVpcAttachment(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -22270,14 +22460,14 @@ func awsEc2query_deserializeOpErrorDeleteVerifiedAccessGroup(response *smithyhtt } } -type awsEc2query_deserializeOpDeleteVerifiedAccessInstance struct { +type awsEc2query_deserializeOpDeleteVerifiedAccessEndpoint struct { } -func (*awsEc2query_deserializeOpDeleteVerifiedAccessInstance) ID() string { +func (*awsEc2query_deserializeOpDeleteVerifiedAccessEndpoint) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDeleteVerifiedAccessInstance) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDeleteVerifiedAccessEndpoint) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -22295,9 +22485,9 @@ func (m *awsEc2query_deserializeOpDeleteVerifiedAccessInstance) HandleDeserializ } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDeleteVerifiedAccessInstance(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDeleteVerifiedAccessEndpoint(response, &metadata) } - output := &DeleteVerifiedAccessInstanceOutput{} + output := &DeleteVerifiedAccessEndpointOutput{} out.Result = output var buff [1024]byte @@ -22318,7 +22508,7 @@ func (m *awsEc2query_deserializeOpDeleteVerifiedAccessInstance) HandleDeserializ } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDeleteVerifiedAccessInstanceOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDeleteVerifiedAccessEndpointOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -22332,7 +22522,7 @@ func (m *awsEc2query_deserializeOpDeleteVerifiedAccessInstance) HandleDeserializ return out, metadata, err } -func awsEc2query_deserializeOpErrorDeleteVerifiedAccessInstance(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDeleteVerifiedAccessEndpoint(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -22365,14 +22555,14 @@ func awsEc2query_deserializeOpErrorDeleteVerifiedAccessInstance(response *smithy } } -type awsEc2query_deserializeOpDeleteVerifiedAccessTrustProvider struct { +type awsEc2query_deserializeOpDeleteVerifiedAccessGroup struct { } -func (*awsEc2query_deserializeOpDeleteVerifiedAccessTrustProvider) ID() string { +func (*awsEc2query_deserializeOpDeleteVerifiedAccessGroup) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDeleteVerifiedAccessTrustProvider) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDeleteVerifiedAccessGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -22390,9 +22580,9 @@ func (m *awsEc2query_deserializeOpDeleteVerifiedAccessTrustProvider) HandleDeser } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDeleteVerifiedAccessTrustProvider(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDeleteVerifiedAccessGroup(response, &metadata) } - output := &DeleteVerifiedAccessTrustProviderOutput{} + output := &DeleteVerifiedAccessGroupOutput{} out.Result = output var buff [1024]byte @@ -22413,7 +22603,7 @@ func (m *awsEc2query_deserializeOpDeleteVerifiedAccessTrustProvider) HandleDeser } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDeleteVerifiedAccessTrustProviderOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDeleteVerifiedAccessGroupOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -22427,7 +22617,7 @@ func (m *awsEc2query_deserializeOpDeleteVerifiedAccessTrustProvider) HandleDeser return out, metadata, err } -func awsEc2query_deserializeOpErrorDeleteVerifiedAccessTrustProvider(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDeleteVerifiedAccessGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -22460,14 +22650,14 @@ func awsEc2query_deserializeOpErrorDeleteVerifiedAccessTrustProvider(response *s } } -type awsEc2query_deserializeOpDeleteVolume struct { +type awsEc2query_deserializeOpDeleteVerifiedAccessInstance struct { } -func (*awsEc2query_deserializeOpDeleteVolume) ID() string { +func (*awsEc2query_deserializeOpDeleteVerifiedAccessInstance) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDeleteVolume) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDeleteVerifiedAccessInstance) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -22485,21 +22675,44 @@ func (m *awsEc2query_deserializeOpDeleteVolume) HandleDeserialize(ctx context.Co } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDeleteVolume(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDeleteVerifiedAccessInstance(response, &metadata) } - output := &DeleteVolumeOutput{} + output := &DeleteVerifiedAccessInstanceOutput{} 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_deserializeOpDocumentDeleteVerifiedAccessInstanceOutput(&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_deserializeOpErrorDeleteVolume(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDeleteVerifiedAccessInstance(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -22532,14 +22745,14 @@ func awsEc2query_deserializeOpErrorDeleteVolume(response *smithyhttp.Response, m } } -type awsEc2query_deserializeOpDeleteVpc struct { +type awsEc2query_deserializeOpDeleteVerifiedAccessTrustProvider struct { } -func (*awsEc2query_deserializeOpDeleteVpc) ID() string { +func (*awsEc2query_deserializeOpDeleteVerifiedAccessTrustProvider) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDeleteVpc) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDeleteVerifiedAccessTrustProvider) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -22557,9 +22770,104 @@ func (m *awsEc2query_deserializeOpDeleteVpc) HandleDeserialize(ctx context.Conte } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDeleteVpc(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDeleteVerifiedAccessTrustProvider(response, &metadata) } - output := &DeleteVpcOutput{} + output := &DeleteVerifiedAccessTrustProviderOutput{} + 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_deserializeOpDocumentDeleteVerifiedAccessTrustProviderOutput(&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_deserializeOpErrorDeleteVerifiedAccessTrustProvider(response *smithyhttp.Response, metadata *middleware.Metadata) error { + var errorBuffer bytes.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_deserializeOpDeleteVolume struct { +} + +func (*awsEc2query_deserializeOpDeleteVolume) ID() string { + return "OperationDeserializer" +} + +func (m *awsEc2query_deserializeOpDeleteVolume) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( + out middleware.DeserializeOutput, metadata middleware.Metadata, err error, +) { + out, metadata, err = next.HandleDeserialize(ctx, in) + if err != nil { + return out, metadata, err + } + + _, span := tracing.StartSpan(ctx, "OperationDeserializer") + endTimer := startMetricTimer(ctx, "client.call.deserialization_duration") + defer endTimer() + defer span.End() + response, ok := out.RawResponse.(*smithyhttp.Response) + if !ok { + return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} + } + + if response.StatusCode < 200 || response.StatusCode >= 300 { + return out, metadata, awsEc2query_deserializeOpErrorDeleteVolume(response, &metadata) + } + output := &DeleteVolumeOutput{} out.Result = output if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { @@ -22571,7 +22879,79 @@ func (m *awsEc2query_deserializeOpDeleteVpc) HandleDeserialize(ctx context.Conte return out, metadata, err } -func awsEc2query_deserializeOpErrorDeleteVpc(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDeleteVolume(response *smithyhttp.Response, metadata *middleware.Metadata) error { + var errorBuffer bytes.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_deserializeOpDeleteVpc struct { +} + +func (*awsEc2query_deserializeOpDeleteVpc) ID() string { + return "OperationDeserializer" +} + +func (m *awsEc2query_deserializeOpDeleteVpc) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( + out middleware.DeserializeOutput, metadata middleware.Metadata, err error, +) { + out, metadata, err = next.HandleDeserialize(ctx, in) + if err != nil { + return out, metadata, err + } + + _, span := tracing.StartSpan(ctx, "OperationDeserializer") + endTimer := startMetricTimer(ctx, "client.call.deserialization_duration") + defer endTimer() + defer span.End() + response, ok := out.RawResponse.(*smithyhttp.Response) + if !ok { + return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} + } + + if response.StatusCode < 200 || response.StatusCode >= 300 { + return out, metadata, awsEc2query_deserializeOpErrorDeleteVpc(response, &metadata) + } + output := &DeleteVpcOutput{} + 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_deserializeOpErrorDeleteVpc(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -35740,14 +36120,14 @@ func awsEc2query_deserializeOpErrorDescribeScheduledInstances(response *smithyht } } -type awsEc2query_deserializeOpDescribeSecurityGroupReferences struct { +type awsEc2query_deserializeOpDescribeSecondaryInterfaces struct { } -func (*awsEc2query_deserializeOpDescribeSecurityGroupReferences) ID() string { +func (*awsEc2query_deserializeOpDescribeSecondaryInterfaces) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDescribeSecurityGroupReferences) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDescribeSecondaryInterfaces) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -35765,9 +36145,9 @@ func (m *awsEc2query_deserializeOpDescribeSecurityGroupReferences) HandleDeseria } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDescribeSecurityGroupReferences(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDescribeSecondaryInterfaces(response, &metadata) } - output := &DescribeSecurityGroupReferencesOutput{} + output := &DescribeSecondaryInterfacesOutput{} out.Result = output var buff [1024]byte @@ -35788,7 +36168,7 @@ func (m *awsEc2query_deserializeOpDescribeSecurityGroupReferences) HandleDeseria } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDescribeSecurityGroupReferencesOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDescribeSecondaryInterfacesOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -35802,7 +36182,7 @@ func (m *awsEc2query_deserializeOpDescribeSecurityGroupReferences) HandleDeseria return out, metadata, err } -func awsEc2query_deserializeOpErrorDescribeSecurityGroupReferences(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDescribeSecondaryInterfaces(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -35835,14 +36215,14 @@ func awsEc2query_deserializeOpErrorDescribeSecurityGroupReferences(response *smi } } -type awsEc2query_deserializeOpDescribeSecurityGroupRules struct { +type awsEc2query_deserializeOpDescribeSecondaryNetworks struct { } -func (*awsEc2query_deserializeOpDescribeSecurityGroupRules) ID() string { +func (*awsEc2query_deserializeOpDescribeSecondaryNetworks) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDescribeSecurityGroupRules) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDescribeSecondaryNetworks) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -35860,9 +36240,9 @@ func (m *awsEc2query_deserializeOpDescribeSecurityGroupRules) HandleDeserialize( } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDescribeSecurityGroupRules(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDescribeSecondaryNetworks(response, &metadata) } - output := &DescribeSecurityGroupRulesOutput{} + output := &DescribeSecondaryNetworksOutput{} out.Result = output var buff [1024]byte @@ -35883,7 +36263,7 @@ func (m *awsEc2query_deserializeOpDescribeSecurityGroupRules) HandleDeserialize( } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDescribeSecurityGroupRulesOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDescribeSecondaryNetworksOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -35897,7 +36277,7 @@ func (m *awsEc2query_deserializeOpDescribeSecurityGroupRules) HandleDeserialize( return out, metadata, err } -func awsEc2query_deserializeOpErrorDescribeSecurityGroupRules(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDescribeSecondaryNetworks(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -35930,14 +36310,14 @@ func awsEc2query_deserializeOpErrorDescribeSecurityGroupRules(response *smithyht } } -type awsEc2query_deserializeOpDescribeSecurityGroups struct { +type awsEc2query_deserializeOpDescribeSecondarySubnets struct { } -func (*awsEc2query_deserializeOpDescribeSecurityGroups) ID() string { +func (*awsEc2query_deserializeOpDescribeSecondarySubnets) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDescribeSecurityGroups) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDescribeSecondarySubnets) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -35955,9 +36335,9 @@ func (m *awsEc2query_deserializeOpDescribeSecurityGroups) HandleDeserialize(ctx } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDescribeSecurityGroups(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDescribeSecondarySubnets(response, &metadata) } - output := &DescribeSecurityGroupsOutput{} + output := &DescribeSecondarySubnetsOutput{} out.Result = output var buff [1024]byte @@ -35978,7 +36358,7 @@ func (m *awsEc2query_deserializeOpDescribeSecurityGroups) HandleDeserialize(ctx } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDescribeSecurityGroupsOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDescribeSecondarySubnetsOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -35992,7 +36372,7 @@ func (m *awsEc2query_deserializeOpDescribeSecurityGroups) HandleDeserialize(ctx return out, metadata, err } -func awsEc2query_deserializeOpErrorDescribeSecurityGroups(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDescribeSecondarySubnets(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -36025,14 +36405,14 @@ func awsEc2query_deserializeOpErrorDescribeSecurityGroups(response *smithyhttp.R } } -type awsEc2query_deserializeOpDescribeSecurityGroupVpcAssociations struct { +type awsEc2query_deserializeOpDescribeSecurityGroupReferences struct { } -func (*awsEc2query_deserializeOpDescribeSecurityGroupVpcAssociations) ID() string { +func (*awsEc2query_deserializeOpDescribeSecurityGroupReferences) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDescribeSecurityGroupVpcAssociations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDescribeSecurityGroupReferences) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -36050,9 +36430,9 @@ func (m *awsEc2query_deserializeOpDescribeSecurityGroupVpcAssociations) HandleDe } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDescribeSecurityGroupVpcAssociations(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDescribeSecurityGroupReferences(response, &metadata) } - output := &DescribeSecurityGroupVpcAssociationsOutput{} + output := &DescribeSecurityGroupReferencesOutput{} out.Result = output var buff [1024]byte @@ -36073,7 +36453,7 @@ func (m *awsEc2query_deserializeOpDescribeSecurityGroupVpcAssociations) HandleDe } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDescribeSecurityGroupVpcAssociationsOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDescribeSecurityGroupReferencesOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -36087,7 +36467,7 @@ func (m *awsEc2query_deserializeOpDescribeSecurityGroupVpcAssociations) HandleDe return out, metadata, err } -func awsEc2query_deserializeOpErrorDescribeSecurityGroupVpcAssociations(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDescribeSecurityGroupReferences(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -36120,14 +36500,14 @@ func awsEc2query_deserializeOpErrorDescribeSecurityGroupVpcAssociations(response } } -type awsEc2query_deserializeOpDescribeServiceLinkVirtualInterfaces struct { +type awsEc2query_deserializeOpDescribeSecurityGroupRules struct { } -func (*awsEc2query_deserializeOpDescribeServiceLinkVirtualInterfaces) ID() string { +func (*awsEc2query_deserializeOpDescribeSecurityGroupRules) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDescribeServiceLinkVirtualInterfaces) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDescribeSecurityGroupRules) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -36145,9 +36525,9 @@ func (m *awsEc2query_deserializeOpDescribeServiceLinkVirtualInterfaces) HandleDe } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDescribeServiceLinkVirtualInterfaces(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDescribeSecurityGroupRules(response, &metadata) } - output := &DescribeServiceLinkVirtualInterfacesOutput{} + output := &DescribeSecurityGroupRulesOutput{} out.Result = output var buff [1024]byte @@ -36168,7 +36548,7 @@ func (m *awsEc2query_deserializeOpDescribeServiceLinkVirtualInterfaces) HandleDe } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDescribeServiceLinkVirtualInterfacesOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDescribeSecurityGroupRulesOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -36182,7 +36562,7 @@ func (m *awsEc2query_deserializeOpDescribeServiceLinkVirtualInterfaces) HandleDe return out, metadata, err } -func awsEc2query_deserializeOpErrorDescribeServiceLinkVirtualInterfaces(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDescribeSecurityGroupRules(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -36215,14 +36595,14 @@ func awsEc2query_deserializeOpErrorDescribeServiceLinkVirtualInterfaces(response } } -type awsEc2query_deserializeOpDescribeSnapshotAttribute struct { +type awsEc2query_deserializeOpDescribeSecurityGroups struct { } -func (*awsEc2query_deserializeOpDescribeSnapshotAttribute) ID() string { +func (*awsEc2query_deserializeOpDescribeSecurityGroups) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDescribeSnapshotAttribute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDescribeSecurityGroups) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -36240,9 +36620,9 @@ func (m *awsEc2query_deserializeOpDescribeSnapshotAttribute) HandleDeserialize(c } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDescribeSnapshotAttribute(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDescribeSecurityGroups(response, &metadata) } - output := &DescribeSnapshotAttributeOutput{} + output := &DescribeSecurityGroupsOutput{} out.Result = output var buff [1024]byte @@ -36263,7 +36643,7 @@ func (m *awsEc2query_deserializeOpDescribeSnapshotAttribute) HandleDeserialize(c } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDescribeSnapshotAttributeOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDescribeSecurityGroupsOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -36277,7 +36657,7 @@ func (m *awsEc2query_deserializeOpDescribeSnapshotAttribute) HandleDeserialize(c return out, metadata, err } -func awsEc2query_deserializeOpErrorDescribeSnapshotAttribute(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDescribeSecurityGroups(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -36310,14 +36690,14 @@ func awsEc2query_deserializeOpErrorDescribeSnapshotAttribute(response *smithyhtt } } -type awsEc2query_deserializeOpDescribeSnapshots struct { +type awsEc2query_deserializeOpDescribeSecurityGroupVpcAssociations struct { } -func (*awsEc2query_deserializeOpDescribeSnapshots) ID() string { +func (*awsEc2query_deserializeOpDescribeSecurityGroupVpcAssociations) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDescribeSnapshots) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDescribeSecurityGroupVpcAssociations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -36335,9 +36715,9 @@ func (m *awsEc2query_deserializeOpDescribeSnapshots) HandleDeserialize(ctx conte } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDescribeSnapshots(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDescribeSecurityGroupVpcAssociations(response, &metadata) } - output := &DescribeSnapshotsOutput{} + output := &DescribeSecurityGroupVpcAssociationsOutput{} out.Result = output var buff [1024]byte @@ -36358,7 +36738,7 @@ func (m *awsEc2query_deserializeOpDescribeSnapshots) HandleDeserialize(ctx conte } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDescribeSnapshotsOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDescribeSecurityGroupVpcAssociationsOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -36372,7 +36752,7 @@ func (m *awsEc2query_deserializeOpDescribeSnapshots) HandleDeserialize(ctx conte return out, metadata, err } -func awsEc2query_deserializeOpErrorDescribeSnapshots(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDescribeSecurityGroupVpcAssociations(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -36405,14 +36785,14 @@ func awsEc2query_deserializeOpErrorDescribeSnapshots(response *smithyhttp.Respon } } -type awsEc2query_deserializeOpDescribeSnapshotTierStatus struct { +type awsEc2query_deserializeOpDescribeServiceLinkVirtualInterfaces struct { } -func (*awsEc2query_deserializeOpDescribeSnapshotTierStatus) ID() string { +func (*awsEc2query_deserializeOpDescribeServiceLinkVirtualInterfaces) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDescribeSnapshotTierStatus) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDescribeServiceLinkVirtualInterfaces) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -36430,9 +36810,9 @@ func (m *awsEc2query_deserializeOpDescribeSnapshotTierStatus) HandleDeserialize( } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDescribeSnapshotTierStatus(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDescribeServiceLinkVirtualInterfaces(response, &metadata) } - output := &DescribeSnapshotTierStatusOutput{} + output := &DescribeServiceLinkVirtualInterfacesOutput{} out.Result = output var buff [1024]byte @@ -36453,7 +36833,7 @@ func (m *awsEc2query_deserializeOpDescribeSnapshotTierStatus) HandleDeserialize( } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDescribeSnapshotTierStatusOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDescribeServiceLinkVirtualInterfacesOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -36467,7 +36847,7 @@ func (m *awsEc2query_deserializeOpDescribeSnapshotTierStatus) HandleDeserialize( return out, metadata, err } -func awsEc2query_deserializeOpErrorDescribeSnapshotTierStatus(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDescribeServiceLinkVirtualInterfaces(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -36500,14 +36880,14 @@ func awsEc2query_deserializeOpErrorDescribeSnapshotTierStatus(response *smithyht } } -type awsEc2query_deserializeOpDescribeSpotDatafeedSubscription struct { +type awsEc2query_deserializeOpDescribeSnapshotAttribute struct { } -func (*awsEc2query_deserializeOpDescribeSpotDatafeedSubscription) ID() string { +func (*awsEc2query_deserializeOpDescribeSnapshotAttribute) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDescribeSpotDatafeedSubscription) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDescribeSnapshotAttribute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -36525,9 +36905,9 @@ func (m *awsEc2query_deserializeOpDescribeSpotDatafeedSubscription) HandleDeseri } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDescribeSpotDatafeedSubscription(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDescribeSnapshotAttribute(response, &metadata) } - output := &DescribeSpotDatafeedSubscriptionOutput{} + output := &DescribeSnapshotAttributeOutput{} out.Result = output var buff [1024]byte @@ -36548,7 +36928,7 @@ func (m *awsEc2query_deserializeOpDescribeSpotDatafeedSubscription) HandleDeseri } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDescribeSpotDatafeedSubscriptionOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDescribeSnapshotAttributeOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -36562,7 +36942,7 @@ func (m *awsEc2query_deserializeOpDescribeSpotDatafeedSubscription) HandleDeseri return out, metadata, err } -func awsEc2query_deserializeOpErrorDescribeSpotDatafeedSubscription(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDescribeSnapshotAttribute(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -36595,14 +36975,14 @@ func awsEc2query_deserializeOpErrorDescribeSpotDatafeedSubscription(response *sm } } -type awsEc2query_deserializeOpDescribeSpotFleetInstances struct { +type awsEc2query_deserializeOpDescribeSnapshots struct { } -func (*awsEc2query_deserializeOpDescribeSpotFleetInstances) ID() string { +func (*awsEc2query_deserializeOpDescribeSnapshots) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDescribeSpotFleetInstances) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDescribeSnapshots) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -36620,9 +37000,9 @@ func (m *awsEc2query_deserializeOpDescribeSpotFleetInstances) HandleDeserialize( } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDescribeSpotFleetInstances(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDescribeSnapshots(response, &metadata) } - output := &DescribeSpotFleetInstancesOutput{} + output := &DescribeSnapshotsOutput{} out.Result = output var buff [1024]byte @@ -36643,7 +37023,7 @@ func (m *awsEc2query_deserializeOpDescribeSpotFleetInstances) HandleDeserialize( } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDescribeSpotFleetInstancesOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDescribeSnapshotsOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -36657,7 +37037,7 @@ func (m *awsEc2query_deserializeOpDescribeSpotFleetInstances) HandleDeserialize( return out, metadata, err } -func awsEc2query_deserializeOpErrorDescribeSpotFleetInstances(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDescribeSnapshots(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -36690,14 +37070,14 @@ func awsEc2query_deserializeOpErrorDescribeSpotFleetInstances(response *smithyht } } -type awsEc2query_deserializeOpDescribeSpotFleetRequestHistory struct { +type awsEc2query_deserializeOpDescribeSnapshotTierStatus struct { } -func (*awsEc2query_deserializeOpDescribeSpotFleetRequestHistory) ID() string { +func (*awsEc2query_deserializeOpDescribeSnapshotTierStatus) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDescribeSpotFleetRequestHistory) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDescribeSnapshotTierStatus) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -36715,9 +37095,9 @@ func (m *awsEc2query_deserializeOpDescribeSpotFleetRequestHistory) HandleDeseria } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDescribeSpotFleetRequestHistory(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDescribeSnapshotTierStatus(response, &metadata) } - output := &DescribeSpotFleetRequestHistoryOutput{} + output := &DescribeSnapshotTierStatusOutput{} out.Result = output var buff [1024]byte @@ -36738,7 +37118,7 @@ func (m *awsEc2query_deserializeOpDescribeSpotFleetRequestHistory) HandleDeseria } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDescribeSpotFleetRequestHistoryOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDescribeSnapshotTierStatusOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -36752,7 +37132,7 @@ func (m *awsEc2query_deserializeOpDescribeSpotFleetRequestHistory) HandleDeseria return out, metadata, err } -func awsEc2query_deserializeOpErrorDescribeSpotFleetRequestHistory(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDescribeSnapshotTierStatus(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -36785,14 +37165,14 @@ func awsEc2query_deserializeOpErrorDescribeSpotFleetRequestHistory(response *smi } } -type awsEc2query_deserializeOpDescribeSpotFleetRequests struct { +type awsEc2query_deserializeOpDescribeSpotDatafeedSubscription struct { } -func (*awsEc2query_deserializeOpDescribeSpotFleetRequests) ID() string { +func (*awsEc2query_deserializeOpDescribeSpotDatafeedSubscription) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDescribeSpotFleetRequests) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDescribeSpotDatafeedSubscription) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -36810,9 +37190,9 @@ func (m *awsEc2query_deserializeOpDescribeSpotFleetRequests) HandleDeserialize(c } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDescribeSpotFleetRequests(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDescribeSpotDatafeedSubscription(response, &metadata) } - output := &DescribeSpotFleetRequestsOutput{} + output := &DescribeSpotDatafeedSubscriptionOutput{} out.Result = output var buff [1024]byte @@ -36833,7 +37213,7 @@ func (m *awsEc2query_deserializeOpDescribeSpotFleetRequests) HandleDeserialize(c } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDescribeSpotFleetRequestsOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDescribeSpotDatafeedSubscriptionOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -36847,7 +37227,7 @@ func (m *awsEc2query_deserializeOpDescribeSpotFleetRequests) HandleDeserialize(c return out, metadata, err } -func awsEc2query_deserializeOpErrorDescribeSpotFleetRequests(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDescribeSpotDatafeedSubscription(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -36880,14 +37260,14 @@ func awsEc2query_deserializeOpErrorDescribeSpotFleetRequests(response *smithyhtt } } -type awsEc2query_deserializeOpDescribeSpotInstanceRequests struct { +type awsEc2query_deserializeOpDescribeSpotFleetInstances struct { } -func (*awsEc2query_deserializeOpDescribeSpotInstanceRequests) ID() string { +func (*awsEc2query_deserializeOpDescribeSpotFleetInstances) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDescribeSpotInstanceRequests) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDescribeSpotFleetInstances) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -36905,9 +37285,9 @@ func (m *awsEc2query_deserializeOpDescribeSpotInstanceRequests) HandleDeserializ } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDescribeSpotInstanceRequests(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDescribeSpotFleetInstances(response, &metadata) } - output := &DescribeSpotInstanceRequestsOutput{} + output := &DescribeSpotFleetInstancesOutput{} out.Result = output var buff [1024]byte @@ -36928,7 +37308,7 @@ func (m *awsEc2query_deserializeOpDescribeSpotInstanceRequests) HandleDeserializ } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDescribeSpotInstanceRequestsOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDescribeSpotFleetInstancesOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -36942,7 +37322,7 @@ func (m *awsEc2query_deserializeOpDescribeSpotInstanceRequests) HandleDeserializ return out, metadata, err } -func awsEc2query_deserializeOpErrorDescribeSpotInstanceRequests(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDescribeSpotFleetInstances(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -36975,14 +37355,14 @@ func awsEc2query_deserializeOpErrorDescribeSpotInstanceRequests(response *smithy } } -type awsEc2query_deserializeOpDescribeSpotPriceHistory struct { +type awsEc2query_deserializeOpDescribeSpotFleetRequestHistory struct { } -func (*awsEc2query_deserializeOpDescribeSpotPriceHistory) ID() string { +func (*awsEc2query_deserializeOpDescribeSpotFleetRequestHistory) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDescribeSpotPriceHistory) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDescribeSpotFleetRequestHistory) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -37000,9 +37380,9 @@ func (m *awsEc2query_deserializeOpDescribeSpotPriceHistory) HandleDeserialize(ct } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDescribeSpotPriceHistory(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDescribeSpotFleetRequestHistory(response, &metadata) } - output := &DescribeSpotPriceHistoryOutput{} + output := &DescribeSpotFleetRequestHistoryOutput{} out.Result = output var buff [1024]byte @@ -37023,7 +37403,7 @@ func (m *awsEc2query_deserializeOpDescribeSpotPriceHistory) HandleDeserialize(ct } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDescribeSpotPriceHistoryOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDescribeSpotFleetRequestHistoryOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -37037,7 +37417,7 @@ func (m *awsEc2query_deserializeOpDescribeSpotPriceHistory) HandleDeserialize(ct return out, metadata, err } -func awsEc2query_deserializeOpErrorDescribeSpotPriceHistory(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDescribeSpotFleetRequestHistory(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -37070,14 +37450,14 @@ func awsEc2query_deserializeOpErrorDescribeSpotPriceHistory(response *smithyhttp } } -type awsEc2query_deserializeOpDescribeStaleSecurityGroups struct { +type awsEc2query_deserializeOpDescribeSpotFleetRequests struct { } -func (*awsEc2query_deserializeOpDescribeStaleSecurityGroups) ID() string { +func (*awsEc2query_deserializeOpDescribeSpotFleetRequests) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDescribeStaleSecurityGroups) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDescribeSpotFleetRequests) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -37095,9 +37475,9 @@ func (m *awsEc2query_deserializeOpDescribeStaleSecurityGroups) HandleDeserialize } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDescribeStaleSecurityGroups(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDescribeSpotFleetRequests(response, &metadata) } - output := &DescribeStaleSecurityGroupsOutput{} + output := &DescribeSpotFleetRequestsOutput{} out.Result = output var buff [1024]byte @@ -37118,7 +37498,7 @@ func (m *awsEc2query_deserializeOpDescribeStaleSecurityGroups) HandleDeserialize } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDescribeStaleSecurityGroupsOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDescribeSpotFleetRequestsOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -37132,7 +37512,7 @@ func (m *awsEc2query_deserializeOpDescribeStaleSecurityGroups) HandleDeserialize return out, metadata, err } -func awsEc2query_deserializeOpErrorDescribeStaleSecurityGroups(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDescribeSpotFleetRequests(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -37165,14 +37545,14 @@ func awsEc2query_deserializeOpErrorDescribeStaleSecurityGroups(response *smithyh } } -type awsEc2query_deserializeOpDescribeStoreImageTasks struct { +type awsEc2query_deserializeOpDescribeSpotInstanceRequests struct { } -func (*awsEc2query_deserializeOpDescribeStoreImageTasks) ID() string { +func (*awsEc2query_deserializeOpDescribeSpotInstanceRequests) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDescribeStoreImageTasks) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDescribeSpotInstanceRequests) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -37190,9 +37570,9 @@ func (m *awsEc2query_deserializeOpDescribeStoreImageTasks) HandleDeserialize(ctx } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDescribeStoreImageTasks(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDescribeSpotInstanceRequests(response, &metadata) } - output := &DescribeStoreImageTasksOutput{} + output := &DescribeSpotInstanceRequestsOutput{} out.Result = output var buff [1024]byte @@ -37213,7 +37593,7 @@ func (m *awsEc2query_deserializeOpDescribeStoreImageTasks) HandleDeserialize(ctx } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDescribeStoreImageTasksOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDescribeSpotInstanceRequestsOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -37227,7 +37607,7 @@ func (m *awsEc2query_deserializeOpDescribeStoreImageTasks) HandleDeserialize(ctx return out, metadata, err } -func awsEc2query_deserializeOpErrorDescribeStoreImageTasks(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDescribeSpotInstanceRequests(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -37260,14 +37640,14 @@ func awsEc2query_deserializeOpErrorDescribeStoreImageTasks(response *smithyhttp. } } -type awsEc2query_deserializeOpDescribeSubnets struct { +type awsEc2query_deserializeOpDescribeSpotPriceHistory struct { } -func (*awsEc2query_deserializeOpDescribeSubnets) ID() string { +func (*awsEc2query_deserializeOpDescribeSpotPriceHistory) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDescribeSubnets) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDescribeSpotPriceHistory) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -37285,9 +37665,9 @@ func (m *awsEc2query_deserializeOpDescribeSubnets) HandleDeserialize(ctx context } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDescribeSubnets(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDescribeSpotPriceHistory(response, &metadata) } - output := &DescribeSubnetsOutput{} + output := &DescribeSpotPriceHistoryOutput{} out.Result = output var buff [1024]byte @@ -37308,7 +37688,7 @@ func (m *awsEc2query_deserializeOpDescribeSubnets) HandleDeserialize(ctx context } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDescribeSubnetsOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDescribeSpotPriceHistoryOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -37322,7 +37702,7 @@ func (m *awsEc2query_deserializeOpDescribeSubnets) HandleDeserialize(ctx context return out, metadata, err } -func awsEc2query_deserializeOpErrorDescribeSubnets(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDescribeSpotPriceHistory(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -37355,14 +37735,14 @@ func awsEc2query_deserializeOpErrorDescribeSubnets(response *smithyhttp.Response } } -type awsEc2query_deserializeOpDescribeTags struct { +type awsEc2query_deserializeOpDescribeStaleSecurityGroups struct { } -func (*awsEc2query_deserializeOpDescribeTags) ID() string { +func (*awsEc2query_deserializeOpDescribeStaleSecurityGroups) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDescribeTags) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDescribeStaleSecurityGroups) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -37380,9 +37760,9 @@ func (m *awsEc2query_deserializeOpDescribeTags) HandleDeserialize(ctx context.Co } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDescribeTags(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDescribeStaleSecurityGroups(response, &metadata) } - output := &DescribeTagsOutput{} + output := &DescribeStaleSecurityGroupsOutput{} out.Result = output var buff [1024]byte @@ -37403,7 +37783,7 @@ func (m *awsEc2query_deserializeOpDescribeTags) HandleDeserialize(ctx context.Co } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDescribeTagsOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDescribeStaleSecurityGroupsOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -37417,7 +37797,7 @@ func (m *awsEc2query_deserializeOpDescribeTags) HandleDeserialize(ctx context.Co return out, metadata, err } -func awsEc2query_deserializeOpErrorDescribeTags(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDescribeStaleSecurityGroups(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -37450,14 +37830,14 @@ func awsEc2query_deserializeOpErrorDescribeTags(response *smithyhttp.Response, m } } -type awsEc2query_deserializeOpDescribeTrafficMirrorFilterRules struct { +type awsEc2query_deserializeOpDescribeStoreImageTasks struct { } -func (*awsEc2query_deserializeOpDescribeTrafficMirrorFilterRules) ID() string { +func (*awsEc2query_deserializeOpDescribeStoreImageTasks) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDescribeTrafficMirrorFilterRules) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDescribeStoreImageTasks) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -37475,9 +37855,9 @@ func (m *awsEc2query_deserializeOpDescribeTrafficMirrorFilterRules) HandleDeseri } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDescribeTrafficMirrorFilterRules(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDescribeStoreImageTasks(response, &metadata) } - output := &DescribeTrafficMirrorFilterRulesOutput{} + output := &DescribeStoreImageTasksOutput{} out.Result = output var buff [1024]byte @@ -37498,7 +37878,7 @@ func (m *awsEc2query_deserializeOpDescribeTrafficMirrorFilterRules) HandleDeseri } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDescribeTrafficMirrorFilterRulesOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDescribeStoreImageTasksOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -37512,7 +37892,7 @@ func (m *awsEc2query_deserializeOpDescribeTrafficMirrorFilterRules) HandleDeseri return out, metadata, err } -func awsEc2query_deserializeOpErrorDescribeTrafficMirrorFilterRules(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDescribeStoreImageTasks(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -37545,14 +37925,14 @@ func awsEc2query_deserializeOpErrorDescribeTrafficMirrorFilterRules(response *sm } } -type awsEc2query_deserializeOpDescribeTrafficMirrorFilters struct { +type awsEc2query_deserializeOpDescribeSubnets struct { } -func (*awsEc2query_deserializeOpDescribeTrafficMirrorFilters) ID() string { +func (*awsEc2query_deserializeOpDescribeSubnets) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDescribeTrafficMirrorFilters) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDescribeSubnets) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -37570,9 +37950,9 @@ func (m *awsEc2query_deserializeOpDescribeTrafficMirrorFilters) HandleDeserializ } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDescribeTrafficMirrorFilters(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDescribeSubnets(response, &metadata) } - output := &DescribeTrafficMirrorFiltersOutput{} + output := &DescribeSubnetsOutput{} out.Result = output var buff [1024]byte @@ -37593,7 +37973,7 @@ func (m *awsEc2query_deserializeOpDescribeTrafficMirrorFilters) HandleDeserializ } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDescribeTrafficMirrorFiltersOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDescribeSubnetsOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -37607,7 +37987,7 @@ func (m *awsEc2query_deserializeOpDescribeTrafficMirrorFilters) HandleDeserializ return out, metadata, err } -func awsEc2query_deserializeOpErrorDescribeTrafficMirrorFilters(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDescribeSubnets(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -37640,14 +38020,14 @@ func awsEc2query_deserializeOpErrorDescribeTrafficMirrorFilters(response *smithy } } -type awsEc2query_deserializeOpDescribeTrafficMirrorSessions struct { +type awsEc2query_deserializeOpDescribeTags struct { } -func (*awsEc2query_deserializeOpDescribeTrafficMirrorSessions) ID() string { +func (*awsEc2query_deserializeOpDescribeTags) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDescribeTrafficMirrorSessions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDescribeTags) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -37665,9 +38045,9 @@ func (m *awsEc2query_deserializeOpDescribeTrafficMirrorSessions) HandleDeseriali } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDescribeTrafficMirrorSessions(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDescribeTags(response, &metadata) } - output := &DescribeTrafficMirrorSessionsOutput{} + output := &DescribeTagsOutput{} out.Result = output var buff [1024]byte @@ -37688,7 +38068,7 @@ func (m *awsEc2query_deserializeOpDescribeTrafficMirrorSessions) HandleDeseriali } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDescribeTrafficMirrorSessionsOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDescribeTagsOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -37702,7 +38082,7 @@ func (m *awsEc2query_deserializeOpDescribeTrafficMirrorSessions) HandleDeseriali return out, metadata, err } -func awsEc2query_deserializeOpErrorDescribeTrafficMirrorSessions(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDescribeTags(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -37735,14 +38115,14 @@ func awsEc2query_deserializeOpErrorDescribeTrafficMirrorSessions(response *smith } } -type awsEc2query_deserializeOpDescribeTrafficMirrorTargets struct { +type awsEc2query_deserializeOpDescribeTrafficMirrorFilterRules struct { } -func (*awsEc2query_deserializeOpDescribeTrafficMirrorTargets) ID() string { +func (*awsEc2query_deserializeOpDescribeTrafficMirrorFilterRules) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDescribeTrafficMirrorTargets) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDescribeTrafficMirrorFilterRules) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -37760,9 +38140,9 @@ func (m *awsEc2query_deserializeOpDescribeTrafficMirrorTargets) HandleDeserializ } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDescribeTrafficMirrorTargets(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDescribeTrafficMirrorFilterRules(response, &metadata) } - output := &DescribeTrafficMirrorTargetsOutput{} + output := &DescribeTrafficMirrorFilterRulesOutput{} out.Result = output var buff [1024]byte @@ -37783,7 +38163,7 @@ func (m *awsEc2query_deserializeOpDescribeTrafficMirrorTargets) HandleDeserializ } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDescribeTrafficMirrorTargetsOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDescribeTrafficMirrorFilterRulesOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -37797,7 +38177,7 @@ func (m *awsEc2query_deserializeOpDescribeTrafficMirrorTargets) HandleDeserializ return out, metadata, err } -func awsEc2query_deserializeOpErrorDescribeTrafficMirrorTargets(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDescribeTrafficMirrorFilterRules(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -37830,14 +38210,14 @@ func awsEc2query_deserializeOpErrorDescribeTrafficMirrorTargets(response *smithy } } -type awsEc2query_deserializeOpDescribeTransitGatewayAttachments struct { +type awsEc2query_deserializeOpDescribeTrafficMirrorFilters struct { } -func (*awsEc2query_deserializeOpDescribeTransitGatewayAttachments) ID() string { +func (*awsEc2query_deserializeOpDescribeTrafficMirrorFilters) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDescribeTransitGatewayAttachments) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDescribeTrafficMirrorFilters) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -37855,9 +38235,9 @@ func (m *awsEc2query_deserializeOpDescribeTransitGatewayAttachments) HandleDeser } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDescribeTransitGatewayAttachments(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDescribeTrafficMirrorFilters(response, &metadata) } - output := &DescribeTransitGatewayAttachmentsOutput{} + output := &DescribeTrafficMirrorFiltersOutput{} out.Result = output var buff [1024]byte @@ -37878,7 +38258,7 @@ func (m *awsEc2query_deserializeOpDescribeTransitGatewayAttachments) HandleDeser } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDescribeTransitGatewayAttachmentsOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDescribeTrafficMirrorFiltersOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -37892,7 +38272,7 @@ func (m *awsEc2query_deserializeOpDescribeTransitGatewayAttachments) HandleDeser return out, metadata, err } -func awsEc2query_deserializeOpErrorDescribeTransitGatewayAttachments(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDescribeTrafficMirrorFilters(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -37925,14 +38305,14 @@ func awsEc2query_deserializeOpErrorDescribeTransitGatewayAttachments(response *s } } -type awsEc2query_deserializeOpDescribeTransitGatewayConnectPeers struct { +type awsEc2query_deserializeOpDescribeTrafficMirrorSessions struct { } -func (*awsEc2query_deserializeOpDescribeTransitGatewayConnectPeers) ID() string { +func (*awsEc2query_deserializeOpDescribeTrafficMirrorSessions) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDescribeTransitGatewayConnectPeers) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDescribeTrafficMirrorSessions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -37950,9 +38330,9 @@ func (m *awsEc2query_deserializeOpDescribeTransitGatewayConnectPeers) HandleDese } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDescribeTransitGatewayConnectPeers(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDescribeTrafficMirrorSessions(response, &metadata) } - output := &DescribeTransitGatewayConnectPeersOutput{} + output := &DescribeTrafficMirrorSessionsOutput{} out.Result = output var buff [1024]byte @@ -37973,7 +38353,7 @@ func (m *awsEc2query_deserializeOpDescribeTransitGatewayConnectPeers) HandleDese } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDescribeTransitGatewayConnectPeersOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDescribeTrafficMirrorSessionsOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -37987,7 +38367,7 @@ func (m *awsEc2query_deserializeOpDescribeTransitGatewayConnectPeers) HandleDese return out, metadata, err } -func awsEc2query_deserializeOpErrorDescribeTransitGatewayConnectPeers(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDescribeTrafficMirrorSessions(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -38020,14 +38400,14 @@ func awsEc2query_deserializeOpErrorDescribeTransitGatewayConnectPeers(response * } } -type awsEc2query_deserializeOpDescribeTransitGatewayConnects struct { +type awsEc2query_deserializeOpDescribeTrafficMirrorTargets struct { } -func (*awsEc2query_deserializeOpDescribeTransitGatewayConnects) ID() string { +func (*awsEc2query_deserializeOpDescribeTrafficMirrorTargets) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDescribeTransitGatewayConnects) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDescribeTrafficMirrorTargets) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -38045,9 +38425,9 @@ func (m *awsEc2query_deserializeOpDescribeTransitGatewayConnects) HandleDeserial } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDescribeTransitGatewayConnects(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDescribeTrafficMirrorTargets(response, &metadata) } - output := &DescribeTransitGatewayConnectsOutput{} + output := &DescribeTrafficMirrorTargetsOutput{} out.Result = output var buff [1024]byte @@ -38068,7 +38448,7 @@ func (m *awsEc2query_deserializeOpDescribeTransitGatewayConnects) HandleDeserial } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDescribeTransitGatewayConnectsOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDescribeTrafficMirrorTargetsOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -38082,7 +38462,7 @@ func (m *awsEc2query_deserializeOpDescribeTransitGatewayConnects) HandleDeserial return out, metadata, err } -func awsEc2query_deserializeOpErrorDescribeTransitGatewayConnects(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDescribeTrafficMirrorTargets(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -38115,14 +38495,14 @@ func awsEc2query_deserializeOpErrorDescribeTransitGatewayConnects(response *smit } } -type awsEc2query_deserializeOpDescribeTransitGatewayMeteringPolicies struct { +type awsEc2query_deserializeOpDescribeTransitGatewayAttachments struct { } -func (*awsEc2query_deserializeOpDescribeTransitGatewayMeteringPolicies) ID() string { +func (*awsEc2query_deserializeOpDescribeTransitGatewayAttachments) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDescribeTransitGatewayMeteringPolicies) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDescribeTransitGatewayAttachments) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -38140,9 +38520,9 @@ func (m *awsEc2query_deserializeOpDescribeTransitGatewayMeteringPolicies) Handle } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDescribeTransitGatewayMeteringPolicies(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDescribeTransitGatewayAttachments(response, &metadata) } - output := &DescribeTransitGatewayMeteringPoliciesOutput{} + output := &DescribeTransitGatewayAttachmentsOutput{} out.Result = output var buff [1024]byte @@ -38163,7 +38543,7 @@ func (m *awsEc2query_deserializeOpDescribeTransitGatewayMeteringPolicies) Handle } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDescribeTransitGatewayMeteringPoliciesOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDescribeTransitGatewayAttachmentsOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -38177,7 +38557,7 @@ func (m *awsEc2query_deserializeOpDescribeTransitGatewayMeteringPolicies) Handle return out, metadata, err } -func awsEc2query_deserializeOpErrorDescribeTransitGatewayMeteringPolicies(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDescribeTransitGatewayAttachments(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -38210,14 +38590,14 @@ func awsEc2query_deserializeOpErrorDescribeTransitGatewayMeteringPolicies(respon } } -type awsEc2query_deserializeOpDescribeTransitGatewayMulticastDomains struct { +type awsEc2query_deserializeOpDescribeTransitGatewayConnectPeers struct { } -func (*awsEc2query_deserializeOpDescribeTransitGatewayMulticastDomains) ID() string { +func (*awsEc2query_deserializeOpDescribeTransitGatewayConnectPeers) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDescribeTransitGatewayMulticastDomains) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDescribeTransitGatewayConnectPeers) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -38235,9 +38615,9 @@ func (m *awsEc2query_deserializeOpDescribeTransitGatewayMulticastDomains) Handle } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDescribeTransitGatewayMulticastDomains(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDescribeTransitGatewayConnectPeers(response, &metadata) } - output := &DescribeTransitGatewayMulticastDomainsOutput{} + output := &DescribeTransitGatewayConnectPeersOutput{} out.Result = output var buff [1024]byte @@ -38258,7 +38638,7 @@ func (m *awsEc2query_deserializeOpDescribeTransitGatewayMulticastDomains) Handle } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDescribeTransitGatewayMulticastDomainsOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDescribeTransitGatewayConnectPeersOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -38272,7 +38652,7 @@ func (m *awsEc2query_deserializeOpDescribeTransitGatewayMulticastDomains) Handle return out, metadata, err } -func awsEc2query_deserializeOpErrorDescribeTransitGatewayMulticastDomains(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDescribeTransitGatewayConnectPeers(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -38305,14 +38685,14 @@ func awsEc2query_deserializeOpErrorDescribeTransitGatewayMulticastDomains(respon } } -type awsEc2query_deserializeOpDescribeTransitGatewayPeeringAttachments struct { +type awsEc2query_deserializeOpDescribeTransitGatewayConnects struct { } -func (*awsEc2query_deserializeOpDescribeTransitGatewayPeeringAttachments) ID() string { +func (*awsEc2query_deserializeOpDescribeTransitGatewayConnects) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDescribeTransitGatewayPeeringAttachments) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDescribeTransitGatewayConnects) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -38330,9 +38710,9 @@ func (m *awsEc2query_deserializeOpDescribeTransitGatewayPeeringAttachments) Hand } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDescribeTransitGatewayPeeringAttachments(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDescribeTransitGatewayConnects(response, &metadata) } - output := &DescribeTransitGatewayPeeringAttachmentsOutput{} + output := &DescribeTransitGatewayConnectsOutput{} out.Result = output var buff [1024]byte @@ -38353,7 +38733,7 @@ func (m *awsEc2query_deserializeOpDescribeTransitGatewayPeeringAttachments) Hand } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDescribeTransitGatewayPeeringAttachmentsOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDescribeTransitGatewayConnectsOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -38367,7 +38747,7 @@ func (m *awsEc2query_deserializeOpDescribeTransitGatewayPeeringAttachments) Hand return out, metadata, err } -func awsEc2query_deserializeOpErrorDescribeTransitGatewayPeeringAttachments(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDescribeTransitGatewayConnects(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -38400,14 +38780,14 @@ func awsEc2query_deserializeOpErrorDescribeTransitGatewayPeeringAttachments(resp } } -type awsEc2query_deserializeOpDescribeTransitGatewayPolicyTables struct { +type awsEc2query_deserializeOpDescribeTransitGatewayMeteringPolicies struct { } -func (*awsEc2query_deserializeOpDescribeTransitGatewayPolicyTables) ID() string { +func (*awsEc2query_deserializeOpDescribeTransitGatewayMeteringPolicies) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDescribeTransitGatewayPolicyTables) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDescribeTransitGatewayMeteringPolicies) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -38425,9 +38805,9 @@ func (m *awsEc2query_deserializeOpDescribeTransitGatewayPolicyTables) HandleDese } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDescribeTransitGatewayPolicyTables(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDescribeTransitGatewayMeteringPolicies(response, &metadata) } - output := &DescribeTransitGatewayPolicyTablesOutput{} + output := &DescribeTransitGatewayMeteringPoliciesOutput{} out.Result = output var buff [1024]byte @@ -38448,7 +38828,7 @@ func (m *awsEc2query_deserializeOpDescribeTransitGatewayPolicyTables) HandleDese } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDescribeTransitGatewayPolicyTablesOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDescribeTransitGatewayMeteringPoliciesOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -38462,7 +38842,7 @@ func (m *awsEc2query_deserializeOpDescribeTransitGatewayPolicyTables) HandleDese return out, metadata, err } -func awsEc2query_deserializeOpErrorDescribeTransitGatewayPolicyTables(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDescribeTransitGatewayMeteringPolicies(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -38495,14 +38875,14 @@ func awsEc2query_deserializeOpErrorDescribeTransitGatewayPolicyTables(response * } } -type awsEc2query_deserializeOpDescribeTransitGatewayRouteTableAnnouncements struct { +type awsEc2query_deserializeOpDescribeTransitGatewayMulticastDomains struct { } -func (*awsEc2query_deserializeOpDescribeTransitGatewayRouteTableAnnouncements) ID() string { +func (*awsEc2query_deserializeOpDescribeTransitGatewayMulticastDomains) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDescribeTransitGatewayRouteTableAnnouncements) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDescribeTransitGatewayMulticastDomains) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -38520,9 +38900,9 @@ func (m *awsEc2query_deserializeOpDescribeTransitGatewayRouteTableAnnouncements) } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDescribeTransitGatewayRouteTableAnnouncements(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDescribeTransitGatewayMulticastDomains(response, &metadata) } - output := &DescribeTransitGatewayRouteTableAnnouncementsOutput{} + output := &DescribeTransitGatewayMulticastDomainsOutput{} out.Result = output var buff [1024]byte @@ -38543,7 +38923,7 @@ func (m *awsEc2query_deserializeOpDescribeTransitGatewayRouteTableAnnouncements) } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDescribeTransitGatewayRouteTableAnnouncementsOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDescribeTransitGatewayMulticastDomainsOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -38557,7 +38937,7 @@ func (m *awsEc2query_deserializeOpDescribeTransitGatewayRouteTableAnnouncements) return out, metadata, err } -func awsEc2query_deserializeOpErrorDescribeTransitGatewayRouteTableAnnouncements(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDescribeTransitGatewayMulticastDomains(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -38590,14 +38970,14 @@ func awsEc2query_deserializeOpErrorDescribeTransitGatewayRouteTableAnnouncements } } -type awsEc2query_deserializeOpDescribeTransitGatewayRouteTables struct { +type awsEc2query_deserializeOpDescribeTransitGatewayPeeringAttachments struct { } -func (*awsEc2query_deserializeOpDescribeTransitGatewayRouteTables) ID() string { +func (*awsEc2query_deserializeOpDescribeTransitGatewayPeeringAttachments) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDescribeTransitGatewayRouteTables) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDescribeTransitGatewayPeeringAttachments) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -38615,9 +38995,9 @@ func (m *awsEc2query_deserializeOpDescribeTransitGatewayRouteTables) HandleDeser } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDescribeTransitGatewayRouteTables(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDescribeTransitGatewayPeeringAttachments(response, &metadata) } - output := &DescribeTransitGatewayRouteTablesOutput{} + output := &DescribeTransitGatewayPeeringAttachmentsOutput{} out.Result = output var buff [1024]byte @@ -38638,7 +39018,7 @@ func (m *awsEc2query_deserializeOpDescribeTransitGatewayRouteTables) HandleDeser } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDescribeTransitGatewayRouteTablesOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDescribeTransitGatewayPeeringAttachmentsOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -38652,7 +39032,7 @@ func (m *awsEc2query_deserializeOpDescribeTransitGatewayRouteTables) HandleDeser return out, metadata, err } -func awsEc2query_deserializeOpErrorDescribeTransitGatewayRouteTables(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDescribeTransitGatewayPeeringAttachments(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -38685,14 +39065,14 @@ func awsEc2query_deserializeOpErrorDescribeTransitGatewayRouteTables(response *s } } -type awsEc2query_deserializeOpDescribeTransitGateways struct { +type awsEc2query_deserializeOpDescribeTransitGatewayPolicyTables struct { } -func (*awsEc2query_deserializeOpDescribeTransitGateways) ID() string { +func (*awsEc2query_deserializeOpDescribeTransitGatewayPolicyTables) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDescribeTransitGateways) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDescribeTransitGatewayPolicyTables) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -38710,9 +39090,9 @@ func (m *awsEc2query_deserializeOpDescribeTransitGateways) HandleDeserialize(ctx } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDescribeTransitGateways(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDescribeTransitGatewayPolicyTables(response, &metadata) } - output := &DescribeTransitGatewaysOutput{} + output := &DescribeTransitGatewayPolicyTablesOutput{} out.Result = output var buff [1024]byte @@ -38733,7 +39113,7 @@ func (m *awsEc2query_deserializeOpDescribeTransitGateways) HandleDeserialize(ctx } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDescribeTransitGatewaysOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDescribeTransitGatewayPolicyTablesOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -38747,7 +39127,7 @@ func (m *awsEc2query_deserializeOpDescribeTransitGateways) HandleDeserialize(ctx return out, metadata, err } -func awsEc2query_deserializeOpErrorDescribeTransitGateways(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDescribeTransitGatewayPolicyTables(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -38780,14 +39160,14 @@ func awsEc2query_deserializeOpErrorDescribeTransitGateways(response *smithyhttp. } } -type awsEc2query_deserializeOpDescribeTransitGatewayVpcAttachments struct { +type awsEc2query_deserializeOpDescribeTransitGatewayRouteTableAnnouncements struct { } -func (*awsEc2query_deserializeOpDescribeTransitGatewayVpcAttachments) ID() string { +func (*awsEc2query_deserializeOpDescribeTransitGatewayRouteTableAnnouncements) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDescribeTransitGatewayVpcAttachments) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDescribeTransitGatewayRouteTableAnnouncements) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -38805,9 +39185,9 @@ func (m *awsEc2query_deserializeOpDescribeTransitGatewayVpcAttachments) HandleDe } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDescribeTransitGatewayVpcAttachments(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDescribeTransitGatewayRouteTableAnnouncements(response, &metadata) } - output := &DescribeTransitGatewayVpcAttachmentsOutput{} + output := &DescribeTransitGatewayRouteTableAnnouncementsOutput{} out.Result = output var buff [1024]byte @@ -38828,7 +39208,7 @@ func (m *awsEc2query_deserializeOpDescribeTransitGatewayVpcAttachments) HandleDe } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDescribeTransitGatewayVpcAttachmentsOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDescribeTransitGatewayRouteTableAnnouncementsOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -38842,7 +39222,7 @@ func (m *awsEc2query_deserializeOpDescribeTransitGatewayVpcAttachments) HandleDe return out, metadata, err } -func awsEc2query_deserializeOpErrorDescribeTransitGatewayVpcAttachments(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDescribeTransitGatewayRouteTableAnnouncements(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -38875,14 +39255,14 @@ func awsEc2query_deserializeOpErrorDescribeTransitGatewayVpcAttachments(response } } -type awsEc2query_deserializeOpDescribeTrunkInterfaceAssociations struct { +type awsEc2query_deserializeOpDescribeTransitGatewayRouteTables struct { } -func (*awsEc2query_deserializeOpDescribeTrunkInterfaceAssociations) ID() string { +func (*awsEc2query_deserializeOpDescribeTransitGatewayRouteTables) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDescribeTrunkInterfaceAssociations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDescribeTransitGatewayRouteTables) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -38900,9 +39280,9 @@ func (m *awsEc2query_deserializeOpDescribeTrunkInterfaceAssociations) HandleDese } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDescribeTrunkInterfaceAssociations(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDescribeTransitGatewayRouteTables(response, &metadata) } - output := &DescribeTrunkInterfaceAssociationsOutput{} + output := &DescribeTransitGatewayRouteTablesOutput{} out.Result = output var buff [1024]byte @@ -38923,7 +39303,7 @@ func (m *awsEc2query_deserializeOpDescribeTrunkInterfaceAssociations) HandleDese } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDescribeTrunkInterfaceAssociationsOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDescribeTransitGatewayRouteTablesOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -38937,7 +39317,7 @@ func (m *awsEc2query_deserializeOpDescribeTrunkInterfaceAssociations) HandleDese return out, metadata, err } -func awsEc2query_deserializeOpErrorDescribeTrunkInterfaceAssociations(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDescribeTransitGatewayRouteTables(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -38970,14 +39350,14 @@ func awsEc2query_deserializeOpErrorDescribeTrunkInterfaceAssociations(response * } } -type awsEc2query_deserializeOpDescribeVerifiedAccessEndpoints struct { +type awsEc2query_deserializeOpDescribeTransitGateways struct { } -func (*awsEc2query_deserializeOpDescribeVerifiedAccessEndpoints) ID() string { +func (*awsEc2query_deserializeOpDescribeTransitGateways) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDescribeVerifiedAccessEndpoints) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDescribeTransitGateways) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -38995,9 +39375,9 @@ func (m *awsEc2query_deserializeOpDescribeVerifiedAccessEndpoints) HandleDeseria } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDescribeVerifiedAccessEndpoints(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDescribeTransitGateways(response, &metadata) } - output := &DescribeVerifiedAccessEndpointsOutput{} + output := &DescribeTransitGatewaysOutput{} out.Result = output var buff [1024]byte @@ -39018,7 +39398,7 @@ func (m *awsEc2query_deserializeOpDescribeVerifiedAccessEndpoints) HandleDeseria } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDescribeVerifiedAccessEndpointsOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDescribeTransitGatewaysOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -39032,7 +39412,7 @@ func (m *awsEc2query_deserializeOpDescribeVerifiedAccessEndpoints) HandleDeseria return out, metadata, err } -func awsEc2query_deserializeOpErrorDescribeVerifiedAccessEndpoints(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDescribeTransitGateways(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -39065,14 +39445,14 @@ func awsEc2query_deserializeOpErrorDescribeVerifiedAccessEndpoints(response *smi } } -type awsEc2query_deserializeOpDescribeVerifiedAccessGroups struct { +type awsEc2query_deserializeOpDescribeTransitGatewayVpcAttachments struct { } -func (*awsEc2query_deserializeOpDescribeVerifiedAccessGroups) ID() string { +func (*awsEc2query_deserializeOpDescribeTransitGatewayVpcAttachments) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDescribeVerifiedAccessGroups) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDescribeTransitGatewayVpcAttachments) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -39090,9 +39470,9 @@ func (m *awsEc2query_deserializeOpDescribeVerifiedAccessGroups) HandleDeserializ } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDescribeVerifiedAccessGroups(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDescribeTransitGatewayVpcAttachments(response, &metadata) } - output := &DescribeVerifiedAccessGroupsOutput{} + output := &DescribeTransitGatewayVpcAttachmentsOutput{} out.Result = output var buff [1024]byte @@ -39113,7 +39493,7 @@ func (m *awsEc2query_deserializeOpDescribeVerifiedAccessGroups) HandleDeserializ } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDescribeVerifiedAccessGroupsOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDescribeTransitGatewayVpcAttachmentsOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -39127,7 +39507,7 @@ func (m *awsEc2query_deserializeOpDescribeVerifiedAccessGroups) HandleDeserializ return out, metadata, err } -func awsEc2query_deserializeOpErrorDescribeVerifiedAccessGroups(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDescribeTransitGatewayVpcAttachments(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -39160,14 +39540,14 @@ func awsEc2query_deserializeOpErrorDescribeVerifiedAccessGroups(response *smithy } } -type awsEc2query_deserializeOpDescribeVerifiedAccessInstanceLoggingConfigurations struct { +type awsEc2query_deserializeOpDescribeTrunkInterfaceAssociations struct { } -func (*awsEc2query_deserializeOpDescribeVerifiedAccessInstanceLoggingConfigurations) ID() string { +func (*awsEc2query_deserializeOpDescribeTrunkInterfaceAssociations) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDescribeVerifiedAccessInstanceLoggingConfigurations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDescribeTrunkInterfaceAssociations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -39185,9 +39565,9 @@ func (m *awsEc2query_deserializeOpDescribeVerifiedAccessInstanceLoggingConfigura } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDescribeVerifiedAccessInstanceLoggingConfigurations(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDescribeTrunkInterfaceAssociations(response, &metadata) } - output := &DescribeVerifiedAccessInstanceLoggingConfigurationsOutput{} + output := &DescribeTrunkInterfaceAssociationsOutput{} out.Result = output var buff [1024]byte @@ -39208,7 +39588,7 @@ func (m *awsEc2query_deserializeOpDescribeVerifiedAccessInstanceLoggingConfigura } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDescribeVerifiedAccessInstanceLoggingConfigurationsOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDescribeTrunkInterfaceAssociationsOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -39222,7 +39602,7 @@ func (m *awsEc2query_deserializeOpDescribeVerifiedAccessInstanceLoggingConfigura return out, metadata, err } -func awsEc2query_deserializeOpErrorDescribeVerifiedAccessInstanceLoggingConfigurations(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDescribeTrunkInterfaceAssociations(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -39255,14 +39635,14 @@ func awsEc2query_deserializeOpErrorDescribeVerifiedAccessInstanceLoggingConfigur } } -type awsEc2query_deserializeOpDescribeVerifiedAccessInstances struct { +type awsEc2query_deserializeOpDescribeVerifiedAccessEndpoints struct { } -func (*awsEc2query_deserializeOpDescribeVerifiedAccessInstances) ID() string { +func (*awsEc2query_deserializeOpDescribeVerifiedAccessEndpoints) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDescribeVerifiedAccessInstances) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDescribeVerifiedAccessEndpoints) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -39280,9 +39660,9 @@ func (m *awsEc2query_deserializeOpDescribeVerifiedAccessInstances) HandleDeseria } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDescribeVerifiedAccessInstances(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDescribeVerifiedAccessEndpoints(response, &metadata) } - output := &DescribeVerifiedAccessInstancesOutput{} + output := &DescribeVerifiedAccessEndpointsOutput{} out.Result = output var buff [1024]byte @@ -39303,7 +39683,7 @@ func (m *awsEc2query_deserializeOpDescribeVerifiedAccessInstances) HandleDeseria } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDescribeVerifiedAccessInstancesOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDescribeVerifiedAccessEndpointsOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -39317,7 +39697,7 @@ func (m *awsEc2query_deserializeOpDescribeVerifiedAccessInstances) HandleDeseria return out, metadata, err } -func awsEc2query_deserializeOpErrorDescribeVerifiedAccessInstances(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDescribeVerifiedAccessEndpoints(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -39350,14 +39730,14 @@ func awsEc2query_deserializeOpErrorDescribeVerifiedAccessInstances(response *smi } } -type awsEc2query_deserializeOpDescribeVerifiedAccessTrustProviders struct { +type awsEc2query_deserializeOpDescribeVerifiedAccessGroups struct { } -func (*awsEc2query_deserializeOpDescribeVerifiedAccessTrustProviders) ID() string { +func (*awsEc2query_deserializeOpDescribeVerifiedAccessGroups) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDescribeVerifiedAccessTrustProviders) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDescribeVerifiedAccessGroups) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -39375,9 +39755,9 @@ func (m *awsEc2query_deserializeOpDescribeVerifiedAccessTrustProviders) HandleDe } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDescribeVerifiedAccessTrustProviders(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDescribeVerifiedAccessGroups(response, &metadata) } - output := &DescribeVerifiedAccessTrustProvidersOutput{} + output := &DescribeVerifiedAccessGroupsOutput{} out.Result = output var buff [1024]byte @@ -39398,7 +39778,7 @@ func (m *awsEc2query_deserializeOpDescribeVerifiedAccessTrustProviders) HandleDe } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDescribeVerifiedAccessTrustProvidersOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDescribeVerifiedAccessGroupsOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -39412,7 +39792,7 @@ func (m *awsEc2query_deserializeOpDescribeVerifiedAccessTrustProviders) HandleDe return out, metadata, err } -func awsEc2query_deserializeOpErrorDescribeVerifiedAccessTrustProviders(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDescribeVerifiedAccessGroups(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -39445,14 +39825,14 @@ func awsEc2query_deserializeOpErrorDescribeVerifiedAccessTrustProviders(response } } -type awsEc2query_deserializeOpDescribeVolumeAttribute struct { +type awsEc2query_deserializeOpDescribeVerifiedAccessInstanceLoggingConfigurations struct { } -func (*awsEc2query_deserializeOpDescribeVolumeAttribute) ID() string { +func (*awsEc2query_deserializeOpDescribeVerifiedAccessInstanceLoggingConfigurations) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDescribeVolumeAttribute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDescribeVerifiedAccessInstanceLoggingConfigurations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -39470,9 +39850,9 @@ func (m *awsEc2query_deserializeOpDescribeVolumeAttribute) HandleDeserialize(ctx } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDescribeVolumeAttribute(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDescribeVerifiedAccessInstanceLoggingConfigurations(response, &metadata) } - output := &DescribeVolumeAttributeOutput{} + output := &DescribeVerifiedAccessInstanceLoggingConfigurationsOutput{} out.Result = output var buff [1024]byte @@ -39493,7 +39873,7 @@ func (m *awsEc2query_deserializeOpDescribeVolumeAttribute) HandleDeserialize(ctx } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDescribeVolumeAttributeOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDescribeVerifiedAccessInstanceLoggingConfigurationsOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -39507,7 +39887,7 @@ func (m *awsEc2query_deserializeOpDescribeVolumeAttribute) HandleDeserialize(ctx return out, metadata, err } -func awsEc2query_deserializeOpErrorDescribeVolumeAttribute(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDescribeVerifiedAccessInstanceLoggingConfigurations(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -39540,14 +39920,14 @@ func awsEc2query_deserializeOpErrorDescribeVolumeAttribute(response *smithyhttp. } } -type awsEc2query_deserializeOpDescribeVolumes struct { +type awsEc2query_deserializeOpDescribeVerifiedAccessInstances struct { } -func (*awsEc2query_deserializeOpDescribeVolumes) ID() string { +func (*awsEc2query_deserializeOpDescribeVerifiedAccessInstances) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDescribeVolumes) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDescribeVerifiedAccessInstances) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -39565,9 +39945,9 @@ func (m *awsEc2query_deserializeOpDescribeVolumes) HandleDeserialize(ctx context } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDescribeVolumes(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDescribeVerifiedAccessInstances(response, &metadata) } - output := &DescribeVolumesOutput{} + output := &DescribeVerifiedAccessInstancesOutput{} out.Result = output var buff [1024]byte @@ -39588,7 +39968,7 @@ func (m *awsEc2query_deserializeOpDescribeVolumes) HandleDeserialize(ctx context } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDescribeVolumesOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDescribeVerifiedAccessInstancesOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -39602,7 +39982,7 @@ func (m *awsEc2query_deserializeOpDescribeVolumes) HandleDeserialize(ctx context return out, metadata, err } -func awsEc2query_deserializeOpErrorDescribeVolumes(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDescribeVerifiedAccessInstances(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -39635,14 +40015,14 @@ func awsEc2query_deserializeOpErrorDescribeVolumes(response *smithyhttp.Response } } -type awsEc2query_deserializeOpDescribeVolumesModifications struct { +type awsEc2query_deserializeOpDescribeVerifiedAccessTrustProviders struct { } -func (*awsEc2query_deserializeOpDescribeVolumesModifications) ID() string { +func (*awsEc2query_deserializeOpDescribeVerifiedAccessTrustProviders) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDescribeVolumesModifications) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDescribeVerifiedAccessTrustProviders) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -39660,9 +40040,9 @@ func (m *awsEc2query_deserializeOpDescribeVolumesModifications) HandleDeserializ } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDescribeVolumesModifications(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDescribeVerifiedAccessTrustProviders(response, &metadata) } - output := &DescribeVolumesModificationsOutput{} + output := &DescribeVerifiedAccessTrustProvidersOutput{} out.Result = output var buff [1024]byte @@ -39683,7 +40063,7 @@ func (m *awsEc2query_deserializeOpDescribeVolumesModifications) HandleDeserializ } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDescribeVolumesModificationsOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDescribeVerifiedAccessTrustProvidersOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -39697,7 +40077,7 @@ func (m *awsEc2query_deserializeOpDescribeVolumesModifications) HandleDeserializ return out, metadata, err } -func awsEc2query_deserializeOpErrorDescribeVolumesModifications(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDescribeVerifiedAccessTrustProviders(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -39730,14 +40110,14 @@ func awsEc2query_deserializeOpErrorDescribeVolumesModifications(response *smithy } } -type awsEc2query_deserializeOpDescribeVolumeStatus struct { +type awsEc2query_deserializeOpDescribeVolumeAttribute struct { } -func (*awsEc2query_deserializeOpDescribeVolumeStatus) ID() string { +func (*awsEc2query_deserializeOpDescribeVolumeAttribute) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDescribeVolumeStatus) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDescribeVolumeAttribute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -39755,9 +40135,9 @@ func (m *awsEc2query_deserializeOpDescribeVolumeStatus) HandleDeserialize(ctx co } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDescribeVolumeStatus(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDescribeVolumeAttribute(response, &metadata) } - output := &DescribeVolumeStatusOutput{} + output := &DescribeVolumeAttributeOutput{} out.Result = output var buff [1024]byte @@ -39778,7 +40158,7 @@ func (m *awsEc2query_deserializeOpDescribeVolumeStatus) HandleDeserialize(ctx co } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDescribeVolumeStatusOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDescribeVolumeAttributeOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -39792,7 +40172,7 @@ func (m *awsEc2query_deserializeOpDescribeVolumeStatus) HandleDeserialize(ctx co return out, metadata, err } -func awsEc2query_deserializeOpErrorDescribeVolumeStatus(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDescribeVolumeAttribute(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -39825,14 +40205,14 @@ func awsEc2query_deserializeOpErrorDescribeVolumeStatus(response *smithyhttp.Res } } -type awsEc2query_deserializeOpDescribeVpcAttribute struct { +type awsEc2query_deserializeOpDescribeVolumes struct { } -func (*awsEc2query_deserializeOpDescribeVpcAttribute) ID() string { +func (*awsEc2query_deserializeOpDescribeVolumes) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDescribeVpcAttribute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDescribeVolumes) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -39850,9 +40230,9 @@ func (m *awsEc2query_deserializeOpDescribeVpcAttribute) HandleDeserialize(ctx co } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDescribeVpcAttribute(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDescribeVolumes(response, &metadata) } - output := &DescribeVpcAttributeOutput{} + output := &DescribeVolumesOutput{} out.Result = output var buff [1024]byte @@ -39873,7 +40253,7 @@ func (m *awsEc2query_deserializeOpDescribeVpcAttribute) HandleDeserialize(ctx co } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDescribeVpcAttributeOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDescribeVolumesOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -39887,7 +40267,7 @@ func (m *awsEc2query_deserializeOpDescribeVpcAttribute) HandleDeserialize(ctx co return out, metadata, err } -func awsEc2query_deserializeOpErrorDescribeVpcAttribute(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDescribeVolumes(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -39920,14 +40300,14 @@ func awsEc2query_deserializeOpErrorDescribeVpcAttribute(response *smithyhttp.Res } } -type awsEc2query_deserializeOpDescribeVpcBlockPublicAccessExclusions struct { +type awsEc2query_deserializeOpDescribeVolumesModifications struct { } -func (*awsEc2query_deserializeOpDescribeVpcBlockPublicAccessExclusions) ID() string { +func (*awsEc2query_deserializeOpDescribeVolumesModifications) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDescribeVpcBlockPublicAccessExclusions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDescribeVolumesModifications) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -39945,9 +40325,9 @@ func (m *awsEc2query_deserializeOpDescribeVpcBlockPublicAccessExclusions) Handle } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDescribeVpcBlockPublicAccessExclusions(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDescribeVolumesModifications(response, &metadata) } - output := &DescribeVpcBlockPublicAccessExclusionsOutput{} + output := &DescribeVolumesModificationsOutput{} out.Result = output var buff [1024]byte @@ -39968,7 +40348,7 @@ func (m *awsEc2query_deserializeOpDescribeVpcBlockPublicAccessExclusions) Handle } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDescribeVpcBlockPublicAccessExclusionsOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDescribeVolumesModificationsOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -39982,7 +40362,7 @@ func (m *awsEc2query_deserializeOpDescribeVpcBlockPublicAccessExclusions) Handle return out, metadata, err } -func awsEc2query_deserializeOpErrorDescribeVpcBlockPublicAccessExclusions(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDescribeVolumesModifications(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -40015,14 +40395,14 @@ func awsEc2query_deserializeOpErrorDescribeVpcBlockPublicAccessExclusions(respon } } -type awsEc2query_deserializeOpDescribeVpcBlockPublicAccessOptions struct { +type awsEc2query_deserializeOpDescribeVolumeStatus struct { } -func (*awsEc2query_deserializeOpDescribeVpcBlockPublicAccessOptions) ID() string { +func (*awsEc2query_deserializeOpDescribeVolumeStatus) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDescribeVpcBlockPublicAccessOptions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDescribeVolumeStatus) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -40040,9 +40420,9 @@ func (m *awsEc2query_deserializeOpDescribeVpcBlockPublicAccessOptions) HandleDes } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDescribeVpcBlockPublicAccessOptions(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDescribeVolumeStatus(response, &metadata) } - output := &DescribeVpcBlockPublicAccessOptionsOutput{} + output := &DescribeVolumeStatusOutput{} out.Result = output var buff [1024]byte @@ -40063,7 +40443,7 @@ func (m *awsEc2query_deserializeOpDescribeVpcBlockPublicAccessOptions) HandleDes } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDescribeVpcBlockPublicAccessOptionsOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDescribeVolumeStatusOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -40077,7 +40457,7 @@ func (m *awsEc2query_deserializeOpDescribeVpcBlockPublicAccessOptions) HandleDes return out, metadata, err } -func awsEc2query_deserializeOpErrorDescribeVpcBlockPublicAccessOptions(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDescribeVolumeStatus(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -40110,14 +40490,14 @@ func awsEc2query_deserializeOpErrorDescribeVpcBlockPublicAccessOptions(response } } -type awsEc2query_deserializeOpDescribeVpcClassicLink struct { +type awsEc2query_deserializeOpDescribeVpcAttribute struct { } -func (*awsEc2query_deserializeOpDescribeVpcClassicLink) ID() string { +func (*awsEc2query_deserializeOpDescribeVpcAttribute) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDescribeVpcClassicLink) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDescribeVpcAttribute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -40135,9 +40515,9 @@ func (m *awsEc2query_deserializeOpDescribeVpcClassicLink) HandleDeserialize(ctx } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDescribeVpcClassicLink(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDescribeVpcAttribute(response, &metadata) } - output := &DescribeVpcClassicLinkOutput{} + output := &DescribeVpcAttributeOutput{} out.Result = output var buff [1024]byte @@ -40158,7 +40538,7 @@ func (m *awsEc2query_deserializeOpDescribeVpcClassicLink) HandleDeserialize(ctx } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDescribeVpcClassicLinkOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDescribeVpcAttributeOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -40172,7 +40552,7 @@ func (m *awsEc2query_deserializeOpDescribeVpcClassicLink) HandleDeserialize(ctx return out, metadata, err } -func awsEc2query_deserializeOpErrorDescribeVpcClassicLink(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDescribeVpcAttribute(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -40205,14 +40585,14 @@ func awsEc2query_deserializeOpErrorDescribeVpcClassicLink(response *smithyhttp.R } } -type awsEc2query_deserializeOpDescribeVpcClassicLinkDnsSupport struct { +type awsEc2query_deserializeOpDescribeVpcBlockPublicAccessExclusions struct { } -func (*awsEc2query_deserializeOpDescribeVpcClassicLinkDnsSupport) ID() string { +func (*awsEc2query_deserializeOpDescribeVpcBlockPublicAccessExclusions) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDescribeVpcClassicLinkDnsSupport) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDescribeVpcBlockPublicAccessExclusions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -40230,9 +40610,9 @@ func (m *awsEc2query_deserializeOpDescribeVpcClassicLinkDnsSupport) HandleDeseri } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDescribeVpcClassicLinkDnsSupport(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDescribeVpcBlockPublicAccessExclusions(response, &metadata) } - output := &DescribeVpcClassicLinkDnsSupportOutput{} + output := &DescribeVpcBlockPublicAccessExclusionsOutput{} out.Result = output var buff [1024]byte @@ -40253,7 +40633,7 @@ func (m *awsEc2query_deserializeOpDescribeVpcClassicLinkDnsSupport) HandleDeseri } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDescribeVpcClassicLinkDnsSupportOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDescribeVpcBlockPublicAccessExclusionsOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -40267,7 +40647,7 @@ func (m *awsEc2query_deserializeOpDescribeVpcClassicLinkDnsSupport) HandleDeseri return out, metadata, err } -func awsEc2query_deserializeOpErrorDescribeVpcClassicLinkDnsSupport(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDescribeVpcBlockPublicAccessExclusions(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -40300,14 +40680,14 @@ func awsEc2query_deserializeOpErrorDescribeVpcClassicLinkDnsSupport(response *sm } } -type awsEc2query_deserializeOpDescribeVpcEncryptionControls struct { +type awsEc2query_deserializeOpDescribeVpcBlockPublicAccessOptions struct { } -func (*awsEc2query_deserializeOpDescribeVpcEncryptionControls) ID() string { +func (*awsEc2query_deserializeOpDescribeVpcBlockPublicAccessOptions) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDescribeVpcEncryptionControls) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDescribeVpcBlockPublicAccessOptions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -40325,9 +40705,9 @@ func (m *awsEc2query_deserializeOpDescribeVpcEncryptionControls) HandleDeseriali } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDescribeVpcEncryptionControls(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDescribeVpcBlockPublicAccessOptions(response, &metadata) } - output := &DescribeVpcEncryptionControlsOutput{} + output := &DescribeVpcBlockPublicAccessOptionsOutput{} out.Result = output var buff [1024]byte @@ -40348,7 +40728,7 @@ func (m *awsEc2query_deserializeOpDescribeVpcEncryptionControls) HandleDeseriali } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDescribeVpcEncryptionControlsOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDescribeVpcBlockPublicAccessOptionsOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -40362,7 +40742,7 @@ func (m *awsEc2query_deserializeOpDescribeVpcEncryptionControls) HandleDeseriali return out, metadata, err } -func awsEc2query_deserializeOpErrorDescribeVpcEncryptionControls(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDescribeVpcBlockPublicAccessOptions(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -40395,14 +40775,14 @@ func awsEc2query_deserializeOpErrorDescribeVpcEncryptionControls(response *smith } } -type awsEc2query_deserializeOpDescribeVpcEndpointAssociations struct { +type awsEc2query_deserializeOpDescribeVpcClassicLink struct { } -func (*awsEc2query_deserializeOpDescribeVpcEndpointAssociations) ID() string { +func (*awsEc2query_deserializeOpDescribeVpcClassicLink) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDescribeVpcEndpointAssociations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDescribeVpcClassicLink) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -40420,9 +40800,9 @@ func (m *awsEc2query_deserializeOpDescribeVpcEndpointAssociations) HandleDeseria } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDescribeVpcEndpointAssociations(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDescribeVpcClassicLink(response, &metadata) } - output := &DescribeVpcEndpointAssociationsOutput{} + output := &DescribeVpcClassicLinkOutput{} out.Result = output var buff [1024]byte @@ -40443,7 +40823,7 @@ func (m *awsEc2query_deserializeOpDescribeVpcEndpointAssociations) HandleDeseria } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDescribeVpcEndpointAssociationsOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDescribeVpcClassicLinkOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -40457,7 +40837,7 @@ func (m *awsEc2query_deserializeOpDescribeVpcEndpointAssociations) HandleDeseria return out, metadata, err } -func awsEc2query_deserializeOpErrorDescribeVpcEndpointAssociations(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDescribeVpcClassicLink(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -40490,14 +40870,14 @@ func awsEc2query_deserializeOpErrorDescribeVpcEndpointAssociations(response *smi } } -type awsEc2query_deserializeOpDescribeVpcEndpointConnectionNotifications struct { +type awsEc2query_deserializeOpDescribeVpcClassicLinkDnsSupport struct { } -func (*awsEc2query_deserializeOpDescribeVpcEndpointConnectionNotifications) ID() string { +func (*awsEc2query_deserializeOpDescribeVpcClassicLinkDnsSupport) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDescribeVpcEndpointConnectionNotifications) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDescribeVpcClassicLinkDnsSupport) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -40515,9 +40895,9 @@ func (m *awsEc2query_deserializeOpDescribeVpcEndpointConnectionNotifications) Ha } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDescribeVpcEndpointConnectionNotifications(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDescribeVpcClassicLinkDnsSupport(response, &metadata) } - output := &DescribeVpcEndpointConnectionNotificationsOutput{} + output := &DescribeVpcClassicLinkDnsSupportOutput{} out.Result = output var buff [1024]byte @@ -40538,7 +40918,7 @@ func (m *awsEc2query_deserializeOpDescribeVpcEndpointConnectionNotifications) Ha } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDescribeVpcEndpointConnectionNotificationsOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDescribeVpcClassicLinkDnsSupportOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -40552,7 +40932,7 @@ func (m *awsEc2query_deserializeOpDescribeVpcEndpointConnectionNotifications) Ha return out, metadata, err } -func awsEc2query_deserializeOpErrorDescribeVpcEndpointConnectionNotifications(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDescribeVpcClassicLinkDnsSupport(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -40585,14 +40965,14 @@ func awsEc2query_deserializeOpErrorDescribeVpcEndpointConnectionNotifications(re } } -type awsEc2query_deserializeOpDescribeVpcEndpointConnections struct { +type awsEc2query_deserializeOpDescribeVpcEncryptionControls struct { } -func (*awsEc2query_deserializeOpDescribeVpcEndpointConnections) ID() string { +func (*awsEc2query_deserializeOpDescribeVpcEncryptionControls) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDescribeVpcEndpointConnections) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDescribeVpcEncryptionControls) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -40610,9 +40990,9 @@ func (m *awsEc2query_deserializeOpDescribeVpcEndpointConnections) HandleDeserial } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDescribeVpcEndpointConnections(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDescribeVpcEncryptionControls(response, &metadata) } - output := &DescribeVpcEndpointConnectionsOutput{} + output := &DescribeVpcEncryptionControlsOutput{} out.Result = output var buff [1024]byte @@ -40633,7 +41013,7 @@ func (m *awsEc2query_deserializeOpDescribeVpcEndpointConnections) HandleDeserial } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDescribeVpcEndpointConnectionsOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDescribeVpcEncryptionControlsOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -40647,7 +41027,7 @@ func (m *awsEc2query_deserializeOpDescribeVpcEndpointConnections) HandleDeserial return out, metadata, err } -func awsEc2query_deserializeOpErrorDescribeVpcEndpointConnections(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDescribeVpcEncryptionControls(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -40680,14 +41060,14 @@ func awsEc2query_deserializeOpErrorDescribeVpcEndpointConnections(response *smit } } -type awsEc2query_deserializeOpDescribeVpcEndpoints struct { +type awsEc2query_deserializeOpDescribeVpcEndpointAssociations struct { } -func (*awsEc2query_deserializeOpDescribeVpcEndpoints) ID() string { +func (*awsEc2query_deserializeOpDescribeVpcEndpointAssociations) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDescribeVpcEndpoints) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDescribeVpcEndpointAssociations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -40705,9 +41085,9 @@ func (m *awsEc2query_deserializeOpDescribeVpcEndpoints) HandleDeserialize(ctx co } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDescribeVpcEndpoints(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDescribeVpcEndpointAssociations(response, &metadata) } - output := &DescribeVpcEndpointsOutput{} + output := &DescribeVpcEndpointAssociationsOutput{} out.Result = output var buff [1024]byte @@ -40728,7 +41108,7 @@ func (m *awsEc2query_deserializeOpDescribeVpcEndpoints) HandleDeserialize(ctx co } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDescribeVpcEndpointsOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDescribeVpcEndpointAssociationsOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -40742,7 +41122,7 @@ func (m *awsEc2query_deserializeOpDescribeVpcEndpoints) HandleDeserialize(ctx co return out, metadata, err } -func awsEc2query_deserializeOpErrorDescribeVpcEndpoints(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDescribeVpcEndpointAssociations(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -40775,14 +41155,14 @@ func awsEc2query_deserializeOpErrorDescribeVpcEndpoints(response *smithyhttp.Res } } -type awsEc2query_deserializeOpDescribeVpcEndpointServiceConfigurations struct { +type awsEc2query_deserializeOpDescribeVpcEndpointConnectionNotifications struct { } -func (*awsEc2query_deserializeOpDescribeVpcEndpointServiceConfigurations) ID() string { +func (*awsEc2query_deserializeOpDescribeVpcEndpointConnectionNotifications) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDescribeVpcEndpointServiceConfigurations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDescribeVpcEndpointConnectionNotifications) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -40800,9 +41180,9 @@ func (m *awsEc2query_deserializeOpDescribeVpcEndpointServiceConfigurations) Hand } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDescribeVpcEndpointServiceConfigurations(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDescribeVpcEndpointConnectionNotifications(response, &metadata) } - output := &DescribeVpcEndpointServiceConfigurationsOutput{} + output := &DescribeVpcEndpointConnectionNotificationsOutput{} out.Result = output var buff [1024]byte @@ -40823,7 +41203,7 @@ func (m *awsEc2query_deserializeOpDescribeVpcEndpointServiceConfigurations) Hand } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDescribeVpcEndpointServiceConfigurationsOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDescribeVpcEndpointConnectionNotificationsOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -40837,7 +41217,7 @@ func (m *awsEc2query_deserializeOpDescribeVpcEndpointServiceConfigurations) Hand return out, metadata, err } -func awsEc2query_deserializeOpErrorDescribeVpcEndpointServiceConfigurations(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDescribeVpcEndpointConnectionNotifications(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -40870,14 +41250,14 @@ func awsEc2query_deserializeOpErrorDescribeVpcEndpointServiceConfigurations(resp } } -type awsEc2query_deserializeOpDescribeVpcEndpointServicePermissions struct { +type awsEc2query_deserializeOpDescribeVpcEndpointConnections struct { } -func (*awsEc2query_deserializeOpDescribeVpcEndpointServicePermissions) ID() string { +func (*awsEc2query_deserializeOpDescribeVpcEndpointConnections) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDescribeVpcEndpointServicePermissions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDescribeVpcEndpointConnections) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -40895,9 +41275,9 @@ func (m *awsEc2query_deserializeOpDescribeVpcEndpointServicePermissions) HandleD } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDescribeVpcEndpointServicePermissions(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDescribeVpcEndpointConnections(response, &metadata) } - output := &DescribeVpcEndpointServicePermissionsOutput{} + output := &DescribeVpcEndpointConnectionsOutput{} out.Result = output var buff [1024]byte @@ -40918,7 +41298,7 @@ func (m *awsEc2query_deserializeOpDescribeVpcEndpointServicePermissions) HandleD } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDescribeVpcEndpointServicePermissionsOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDescribeVpcEndpointConnectionsOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -40932,7 +41312,7 @@ func (m *awsEc2query_deserializeOpDescribeVpcEndpointServicePermissions) HandleD return out, metadata, err } -func awsEc2query_deserializeOpErrorDescribeVpcEndpointServicePermissions(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDescribeVpcEndpointConnections(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -40965,14 +41345,14 @@ func awsEc2query_deserializeOpErrorDescribeVpcEndpointServicePermissions(respons } } -type awsEc2query_deserializeOpDescribeVpcEndpointServices struct { +type awsEc2query_deserializeOpDescribeVpcEndpoints struct { } -func (*awsEc2query_deserializeOpDescribeVpcEndpointServices) ID() string { +func (*awsEc2query_deserializeOpDescribeVpcEndpoints) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDescribeVpcEndpointServices) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDescribeVpcEndpoints) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -40990,9 +41370,9 @@ func (m *awsEc2query_deserializeOpDescribeVpcEndpointServices) HandleDeserialize } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDescribeVpcEndpointServices(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDescribeVpcEndpoints(response, &metadata) } - output := &DescribeVpcEndpointServicesOutput{} + output := &DescribeVpcEndpointsOutput{} out.Result = output var buff [1024]byte @@ -41013,7 +41393,7 @@ func (m *awsEc2query_deserializeOpDescribeVpcEndpointServices) HandleDeserialize } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDescribeVpcEndpointServicesOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDescribeVpcEndpointsOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -41027,7 +41407,7 @@ func (m *awsEc2query_deserializeOpDescribeVpcEndpointServices) HandleDeserialize return out, metadata, err } -func awsEc2query_deserializeOpErrorDescribeVpcEndpointServices(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDescribeVpcEndpoints(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -41060,14 +41440,14 @@ func awsEc2query_deserializeOpErrorDescribeVpcEndpointServices(response *smithyh } } -type awsEc2query_deserializeOpDescribeVpcPeeringConnections struct { +type awsEc2query_deserializeOpDescribeVpcEndpointServiceConfigurations struct { } -func (*awsEc2query_deserializeOpDescribeVpcPeeringConnections) ID() string { +func (*awsEc2query_deserializeOpDescribeVpcEndpointServiceConfigurations) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDescribeVpcPeeringConnections) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDescribeVpcEndpointServiceConfigurations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -41085,9 +41465,9 @@ func (m *awsEc2query_deserializeOpDescribeVpcPeeringConnections) HandleDeseriali } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDescribeVpcPeeringConnections(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDescribeVpcEndpointServiceConfigurations(response, &metadata) } - output := &DescribeVpcPeeringConnectionsOutput{} + output := &DescribeVpcEndpointServiceConfigurationsOutput{} out.Result = output var buff [1024]byte @@ -41108,7 +41488,7 @@ func (m *awsEc2query_deserializeOpDescribeVpcPeeringConnections) HandleDeseriali } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDescribeVpcPeeringConnectionsOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDescribeVpcEndpointServiceConfigurationsOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -41122,7 +41502,7 @@ func (m *awsEc2query_deserializeOpDescribeVpcPeeringConnections) HandleDeseriali return out, metadata, err } -func awsEc2query_deserializeOpErrorDescribeVpcPeeringConnections(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDescribeVpcEndpointServiceConfigurations(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -41155,14 +41535,14 @@ func awsEc2query_deserializeOpErrorDescribeVpcPeeringConnections(response *smith } } -type awsEc2query_deserializeOpDescribeVpcs struct { +type awsEc2query_deserializeOpDescribeVpcEndpointServicePermissions struct { } -func (*awsEc2query_deserializeOpDescribeVpcs) ID() string { +func (*awsEc2query_deserializeOpDescribeVpcEndpointServicePermissions) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDescribeVpcs) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDescribeVpcEndpointServicePermissions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -41180,9 +41560,9 @@ func (m *awsEc2query_deserializeOpDescribeVpcs) HandleDeserialize(ctx context.Co } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDescribeVpcs(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDescribeVpcEndpointServicePermissions(response, &metadata) } - output := &DescribeVpcsOutput{} + output := &DescribeVpcEndpointServicePermissionsOutput{} out.Result = output var buff [1024]byte @@ -41203,7 +41583,7 @@ func (m *awsEc2query_deserializeOpDescribeVpcs) HandleDeserialize(ctx context.Co } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDescribeVpcsOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDescribeVpcEndpointServicePermissionsOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -41217,7 +41597,7 @@ func (m *awsEc2query_deserializeOpDescribeVpcs) HandleDeserialize(ctx context.Co return out, metadata, err } -func awsEc2query_deserializeOpErrorDescribeVpcs(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDescribeVpcEndpointServicePermissions(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -41250,14 +41630,14 @@ func awsEc2query_deserializeOpErrorDescribeVpcs(response *smithyhttp.Response, m } } -type awsEc2query_deserializeOpDescribeVpnConcentrators struct { +type awsEc2query_deserializeOpDescribeVpcEndpointServices struct { } -func (*awsEc2query_deserializeOpDescribeVpnConcentrators) ID() string { +func (*awsEc2query_deserializeOpDescribeVpcEndpointServices) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDescribeVpnConcentrators) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDescribeVpcEndpointServices) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -41275,9 +41655,9 @@ func (m *awsEc2query_deserializeOpDescribeVpnConcentrators) HandleDeserialize(ct } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDescribeVpnConcentrators(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDescribeVpcEndpointServices(response, &metadata) } - output := &DescribeVpnConcentratorsOutput{} + output := &DescribeVpcEndpointServicesOutput{} out.Result = output var buff [1024]byte @@ -41298,7 +41678,7 @@ func (m *awsEc2query_deserializeOpDescribeVpnConcentrators) HandleDeserialize(ct } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDescribeVpnConcentratorsOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDescribeVpcEndpointServicesOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -41312,7 +41692,7 @@ func (m *awsEc2query_deserializeOpDescribeVpnConcentrators) HandleDeserialize(ct return out, metadata, err } -func awsEc2query_deserializeOpErrorDescribeVpnConcentrators(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDescribeVpcEndpointServices(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -41345,14 +41725,14 @@ func awsEc2query_deserializeOpErrorDescribeVpnConcentrators(response *smithyhttp } } -type awsEc2query_deserializeOpDescribeVpnConnections struct { +type awsEc2query_deserializeOpDescribeVpcPeeringConnections struct { } -func (*awsEc2query_deserializeOpDescribeVpnConnections) ID() string { +func (*awsEc2query_deserializeOpDescribeVpcPeeringConnections) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDescribeVpnConnections) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDescribeVpcPeeringConnections) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -41370,9 +41750,9 @@ func (m *awsEc2query_deserializeOpDescribeVpnConnections) HandleDeserialize(ctx } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDescribeVpnConnections(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDescribeVpcPeeringConnections(response, &metadata) } - output := &DescribeVpnConnectionsOutput{} + output := &DescribeVpcPeeringConnectionsOutput{} out.Result = output var buff [1024]byte @@ -41393,7 +41773,7 @@ func (m *awsEc2query_deserializeOpDescribeVpnConnections) HandleDeserialize(ctx } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDescribeVpnConnectionsOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDescribeVpcPeeringConnectionsOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -41407,7 +41787,7 @@ func (m *awsEc2query_deserializeOpDescribeVpnConnections) HandleDeserialize(ctx return out, metadata, err } -func awsEc2query_deserializeOpErrorDescribeVpnConnections(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDescribeVpcPeeringConnections(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -41440,14 +41820,14 @@ func awsEc2query_deserializeOpErrorDescribeVpnConnections(response *smithyhttp.R } } -type awsEc2query_deserializeOpDescribeVpnGateways struct { +type awsEc2query_deserializeOpDescribeVpcs struct { } -func (*awsEc2query_deserializeOpDescribeVpnGateways) ID() string { +func (*awsEc2query_deserializeOpDescribeVpcs) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDescribeVpnGateways) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDescribeVpcs) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -41465,9 +41845,9 @@ func (m *awsEc2query_deserializeOpDescribeVpnGateways) HandleDeserialize(ctx con } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDescribeVpnGateways(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDescribeVpcs(response, &metadata) } - output := &DescribeVpnGatewaysOutput{} + output := &DescribeVpcsOutput{} out.Result = output var buff [1024]byte @@ -41488,7 +41868,7 @@ func (m *awsEc2query_deserializeOpDescribeVpnGateways) HandleDeserialize(ctx con } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDescribeVpnGatewaysOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDescribeVpcsOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -41502,7 +41882,7 @@ func (m *awsEc2query_deserializeOpDescribeVpnGateways) HandleDeserialize(ctx con return out, metadata, err } -func awsEc2query_deserializeOpErrorDescribeVpnGateways(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDescribeVpcs(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -41535,14 +41915,14 @@ func awsEc2query_deserializeOpErrorDescribeVpnGateways(response *smithyhttp.Resp } } -type awsEc2query_deserializeOpDetachClassicLinkVpc struct { +type awsEc2query_deserializeOpDescribeVpnConcentrators struct { } -func (*awsEc2query_deserializeOpDetachClassicLinkVpc) ID() string { +func (*awsEc2query_deserializeOpDescribeVpnConcentrators) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDetachClassicLinkVpc) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDescribeVpnConcentrators) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -41560,9 +41940,9 @@ func (m *awsEc2query_deserializeOpDetachClassicLinkVpc) HandleDeserialize(ctx co } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDetachClassicLinkVpc(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDescribeVpnConcentrators(response, &metadata) } - output := &DetachClassicLinkVpcOutput{} + output := &DescribeVpnConcentratorsOutput{} out.Result = output var buff [1024]byte @@ -41583,7 +41963,7 @@ func (m *awsEc2query_deserializeOpDetachClassicLinkVpc) HandleDeserialize(ctx co } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDetachClassicLinkVpcOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDescribeVpnConcentratorsOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -41597,7 +41977,7 @@ func (m *awsEc2query_deserializeOpDetachClassicLinkVpc) HandleDeserialize(ctx co return out, metadata, err } -func awsEc2query_deserializeOpErrorDetachClassicLinkVpc(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDescribeVpnConcentrators(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -41630,14 +42010,14 @@ func awsEc2query_deserializeOpErrorDetachClassicLinkVpc(response *smithyhttp.Res } } -type awsEc2query_deserializeOpDetachInternetGateway struct { +type awsEc2query_deserializeOpDescribeVpnConnections struct { } -func (*awsEc2query_deserializeOpDetachInternetGateway) ID() string { +func (*awsEc2query_deserializeOpDescribeVpnConnections) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDetachInternetGateway) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDescribeVpnConnections) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -41655,21 +42035,44 @@ func (m *awsEc2query_deserializeOpDetachInternetGateway) HandleDeserialize(ctx c } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDetachInternetGateway(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDescribeVpnConnections(response, &metadata) } - output := &DetachInternetGatewayOutput{} + output := &DescribeVpnConnectionsOutput{} 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_deserializeOpDocumentDescribeVpnConnectionsOutput(&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_deserializeOpErrorDetachInternetGateway(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDescribeVpnConnections(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -41702,14 +42105,14 @@ func awsEc2query_deserializeOpErrorDetachInternetGateway(response *smithyhttp.Re } } -type awsEc2query_deserializeOpDetachNetworkInterface struct { +type awsEc2query_deserializeOpDescribeVpnGateways struct { } -func (*awsEc2query_deserializeOpDetachNetworkInterface) ID() string { +func (*awsEc2query_deserializeOpDescribeVpnGateways) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDetachNetworkInterface) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDescribeVpnGateways) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -41727,21 +42130,44 @@ func (m *awsEc2query_deserializeOpDetachNetworkInterface) HandleDeserialize(ctx } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDetachNetworkInterface(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDescribeVpnGateways(response, &metadata) } - output := &DetachNetworkInterfaceOutput{} + output := &DescribeVpnGatewaysOutput{} 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_deserializeOpDocumentDescribeVpnGatewaysOutput(&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_deserializeOpErrorDetachNetworkInterface(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDescribeVpnGateways(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -41774,14 +42200,14 @@ func awsEc2query_deserializeOpErrorDetachNetworkInterface(response *smithyhttp.R } } -type awsEc2query_deserializeOpDetachVerifiedAccessTrustProvider struct { +type awsEc2query_deserializeOpDetachClassicLinkVpc struct { } -func (*awsEc2query_deserializeOpDetachVerifiedAccessTrustProvider) ID() string { +func (*awsEc2query_deserializeOpDetachClassicLinkVpc) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDetachVerifiedAccessTrustProvider) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDetachClassicLinkVpc) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -41799,9 +42225,9 @@ func (m *awsEc2query_deserializeOpDetachVerifiedAccessTrustProvider) HandleDeser } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDetachVerifiedAccessTrustProvider(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDetachClassicLinkVpc(response, &metadata) } - output := &DetachVerifiedAccessTrustProviderOutput{} + output := &DetachClassicLinkVpcOutput{} out.Result = output var buff [1024]byte @@ -41822,7 +42248,7 @@ func (m *awsEc2query_deserializeOpDetachVerifiedAccessTrustProvider) HandleDeser } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDetachVerifiedAccessTrustProviderOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDetachClassicLinkVpcOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -41836,7 +42262,7 @@ func (m *awsEc2query_deserializeOpDetachVerifiedAccessTrustProvider) HandleDeser return out, metadata, err } -func awsEc2query_deserializeOpErrorDetachVerifiedAccessTrustProvider(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDetachClassicLinkVpc(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -41869,14 +42295,14 @@ func awsEc2query_deserializeOpErrorDetachVerifiedAccessTrustProvider(response *s } } -type awsEc2query_deserializeOpDetachVolume struct { +type awsEc2query_deserializeOpDetachInternetGateway struct { } -func (*awsEc2query_deserializeOpDetachVolume) ID() string { +func (*awsEc2query_deserializeOpDetachInternetGateway) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDetachVolume) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDetachInternetGateway) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -41894,44 +42320,21 @@ func (m *awsEc2query_deserializeOpDetachVolume) HandleDeserialize(ctx context.Co } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDetachVolume(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDetachInternetGateway(response, &metadata) } - output := &DetachVolumeOutput{} + output := &DetachInternetGatewayOutput{} 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_deserializeOpDocumentDetachVolumeOutput(&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_deserializeOpErrorDetachVolume(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDetachInternetGateway(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -41964,14 +42367,14 @@ func awsEc2query_deserializeOpErrorDetachVolume(response *smithyhttp.Response, m } } -type awsEc2query_deserializeOpDetachVpnGateway struct { +type awsEc2query_deserializeOpDetachNetworkInterface struct { } -func (*awsEc2query_deserializeOpDetachVpnGateway) ID() string { +func (*awsEc2query_deserializeOpDetachNetworkInterface) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDetachVpnGateway) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDetachNetworkInterface) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -41989,9 +42392,9 @@ func (m *awsEc2query_deserializeOpDetachVpnGateway) HandleDeserialize(ctx contex } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDetachVpnGateway(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDetachNetworkInterface(response, &metadata) } - output := &DetachVpnGatewayOutput{} + output := &DetachNetworkInterfaceOutput{} out.Result = output if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { @@ -42003,7 +42406,7 @@ func (m *awsEc2query_deserializeOpDetachVpnGateway) HandleDeserialize(ctx contex return out, metadata, err } -func awsEc2query_deserializeOpErrorDetachVpnGateway(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDetachNetworkInterface(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -42036,14 +42439,14 @@ func awsEc2query_deserializeOpErrorDetachVpnGateway(response *smithyhttp.Respons } } -type awsEc2query_deserializeOpDisableAddressTransfer struct { +type awsEc2query_deserializeOpDetachVerifiedAccessTrustProvider struct { } -func (*awsEc2query_deserializeOpDisableAddressTransfer) ID() string { +func (*awsEc2query_deserializeOpDetachVerifiedAccessTrustProvider) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDisableAddressTransfer) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDetachVerifiedAccessTrustProvider) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -42061,9 +42464,9 @@ func (m *awsEc2query_deserializeOpDisableAddressTransfer) HandleDeserialize(ctx } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDisableAddressTransfer(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDetachVerifiedAccessTrustProvider(response, &metadata) } - output := &DisableAddressTransferOutput{} + output := &DetachVerifiedAccessTrustProviderOutput{} out.Result = output var buff [1024]byte @@ -42084,7 +42487,7 @@ func (m *awsEc2query_deserializeOpDisableAddressTransfer) HandleDeserialize(ctx } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDisableAddressTransferOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDetachVerifiedAccessTrustProviderOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -42098,7 +42501,7 @@ func (m *awsEc2query_deserializeOpDisableAddressTransfer) HandleDeserialize(ctx return out, metadata, err } -func awsEc2query_deserializeOpErrorDisableAddressTransfer(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDetachVerifiedAccessTrustProvider(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -42131,14 +42534,14 @@ func awsEc2query_deserializeOpErrorDisableAddressTransfer(response *smithyhttp.R } } -type awsEc2query_deserializeOpDisableAllowedImagesSettings struct { +type awsEc2query_deserializeOpDetachVolume struct { } -func (*awsEc2query_deserializeOpDisableAllowedImagesSettings) ID() string { +func (*awsEc2query_deserializeOpDetachVolume) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDisableAllowedImagesSettings) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDetachVolume) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -42156,9 +42559,9 @@ func (m *awsEc2query_deserializeOpDisableAllowedImagesSettings) HandleDeserializ } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDisableAllowedImagesSettings(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDetachVolume(response, &metadata) } - output := &DisableAllowedImagesSettingsOutput{} + output := &DetachVolumeOutput{} out.Result = output var buff [1024]byte @@ -42179,7 +42582,7 @@ func (m *awsEc2query_deserializeOpDisableAllowedImagesSettings) HandleDeserializ } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDisableAllowedImagesSettingsOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDetachVolumeOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -42193,7 +42596,7 @@ func (m *awsEc2query_deserializeOpDisableAllowedImagesSettings) HandleDeserializ return out, metadata, err } -func awsEc2query_deserializeOpErrorDisableAllowedImagesSettings(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDetachVolume(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -42226,14 +42629,14 @@ func awsEc2query_deserializeOpErrorDisableAllowedImagesSettings(response *smithy } } -type awsEc2query_deserializeOpDisableAwsNetworkPerformanceMetricSubscription struct { +type awsEc2query_deserializeOpDetachVpnGateway struct { } -func (*awsEc2query_deserializeOpDisableAwsNetworkPerformanceMetricSubscription) ID() string { +func (*awsEc2query_deserializeOpDetachVpnGateway) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDisableAwsNetworkPerformanceMetricSubscription) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDetachVpnGateway) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -42251,44 +42654,21 @@ func (m *awsEc2query_deserializeOpDisableAwsNetworkPerformanceMetricSubscription } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDisableAwsNetworkPerformanceMetricSubscription(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDetachVpnGateway(response, &metadata) } - output := &DisableAwsNetworkPerformanceMetricSubscriptionOutput{} + output := &DetachVpnGatewayOutput{} 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_deserializeOpDocumentDisableAwsNetworkPerformanceMetricSubscriptionOutput(&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_deserializeOpErrorDisableAwsNetworkPerformanceMetricSubscription(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDetachVpnGateway(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -42321,14 +42701,14 @@ func awsEc2query_deserializeOpErrorDisableAwsNetworkPerformanceMetricSubscriptio } } -type awsEc2query_deserializeOpDisableCapacityManager struct { +type awsEc2query_deserializeOpDisableAddressTransfer struct { } -func (*awsEc2query_deserializeOpDisableCapacityManager) ID() string { +func (*awsEc2query_deserializeOpDisableAddressTransfer) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDisableCapacityManager) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDisableAddressTransfer) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -42346,9 +42726,9 @@ func (m *awsEc2query_deserializeOpDisableCapacityManager) HandleDeserialize(ctx } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDisableCapacityManager(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDisableAddressTransfer(response, &metadata) } - output := &DisableCapacityManagerOutput{} + output := &DisableAddressTransferOutput{} out.Result = output var buff [1024]byte @@ -42369,7 +42749,7 @@ func (m *awsEc2query_deserializeOpDisableCapacityManager) HandleDeserialize(ctx } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDisableCapacityManagerOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDisableAddressTransferOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -42383,7 +42763,7 @@ func (m *awsEc2query_deserializeOpDisableCapacityManager) HandleDeserialize(ctx return out, metadata, err } -func awsEc2query_deserializeOpErrorDisableCapacityManager(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDisableAddressTransfer(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -42416,14 +42796,14 @@ func awsEc2query_deserializeOpErrorDisableCapacityManager(response *smithyhttp.R } } -type awsEc2query_deserializeOpDisableEbsEncryptionByDefault struct { +type awsEc2query_deserializeOpDisableAllowedImagesSettings struct { } -func (*awsEc2query_deserializeOpDisableEbsEncryptionByDefault) ID() string { +func (*awsEc2query_deserializeOpDisableAllowedImagesSettings) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDisableEbsEncryptionByDefault) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDisableAllowedImagesSettings) HandleDeserialize(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,9 +42821,9 @@ func (m *awsEc2query_deserializeOpDisableEbsEncryptionByDefault) HandleDeseriali } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDisableEbsEncryptionByDefault(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDisableAllowedImagesSettings(response, &metadata) } - output := &DisableEbsEncryptionByDefaultOutput{} + output := &DisableAllowedImagesSettingsOutput{} out.Result = output var buff [1024]byte @@ -42464,7 +42844,7 @@ func (m *awsEc2query_deserializeOpDisableEbsEncryptionByDefault) HandleDeseriali } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDisableEbsEncryptionByDefaultOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDisableAllowedImagesSettingsOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -42478,7 +42858,7 @@ func (m *awsEc2query_deserializeOpDisableEbsEncryptionByDefault) HandleDeseriali return out, metadata, err } -func awsEc2query_deserializeOpErrorDisableEbsEncryptionByDefault(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDisableAllowedImagesSettings(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -42511,14 +42891,14 @@ func awsEc2query_deserializeOpErrorDisableEbsEncryptionByDefault(response *smith } } -type awsEc2query_deserializeOpDisableFastLaunch struct { +type awsEc2query_deserializeOpDisableAwsNetworkPerformanceMetricSubscription struct { } -func (*awsEc2query_deserializeOpDisableFastLaunch) ID() string { +func (*awsEc2query_deserializeOpDisableAwsNetworkPerformanceMetricSubscription) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDisableFastLaunch) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDisableAwsNetworkPerformanceMetricSubscription) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -42536,9 +42916,9 @@ func (m *awsEc2query_deserializeOpDisableFastLaunch) HandleDeserialize(ctx conte } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDisableFastLaunch(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDisableAwsNetworkPerformanceMetricSubscription(response, &metadata) } - output := &DisableFastLaunchOutput{} + output := &DisableAwsNetworkPerformanceMetricSubscriptionOutput{} out.Result = output var buff [1024]byte @@ -42559,7 +42939,7 @@ func (m *awsEc2query_deserializeOpDisableFastLaunch) HandleDeserialize(ctx conte } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDisableFastLaunchOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDisableAwsNetworkPerformanceMetricSubscriptionOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -42573,7 +42953,7 @@ func (m *awsEc2query_deserializeOpDisableFastLaunch) HandleDeserialize(ctx conte return out, metadata, err } -func awsEc2query_deserializeOpErrorDisableFastLaunch(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDisableAwsNetworkPerformanceMetricSubscription(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -42606,14 +42986,14 @@ func awsEc2query_deserializeOpErrorDisableFastLaunch(response *smithyhttp.Respon } } -type awsEc2query_deserializeOpDisableFastSnapshotRestores struct { +type awsEc2query_deserializeOpDisableCapacityManager struct { } -func (*awsEc2query_deserializeOpDisableFastSnapshotRestores) ID() string { +func (*awsEc2query_deserializeOpDisableCapacityManager) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDisableFastSnapshotRestores) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDisableCapacityManager) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -42631,9 +43011,9 @@ func (m *awsEc2query_deserializeOpDisableFastSnapshotRestores) HandleDeserialize } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDisableFastSnapshotRestores(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDisableCapacityManager(response, &metadata) } - output := &DisableFastSnapshotRestoresOutput{} + output := &DisableCapacityManagerOutput{} out.Result = output var buff [1024]byte @@ -42654,7 +43034,7 @@ func (m *awsEc2query_deserializeOpDisableFastSnapshotRestores) HandleDeserialize } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDisableFastSnapshotRestoresOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDisableCapacityManagerOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -42668,7 +43048,7 @@ func (m *awsEc2query_deserializeOpDisableFastSnapshotRestores) HandleDeserialize return out, metadata, err } -func awsEc2query_deserializeOpErrorDisableFastSnapshotRestores(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDisableCapacityManager(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -42701,14 +43081,14 @@ func awsEc2query_deserializeOpErrorDisableFastSnapshotRestores(response *smithyh } } -type awsEc2query_deserializeOpDisableImage struct { +type awsEc2query_deserializeOpDisableEbsEncryptionByDefault struct { } -func (*awsEc2query_deserializeOpDisableImage) ID() string { +func (*awsEc2query_deserializeOpDisableEbsEncryptionByDefault) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDisableImage) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDisableEbsEncryptionByDefault) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -42726,9 +43106,9 @@ func (m *awsEc2query_deserializeOpDisableImage) HandleDeserialize(ctx context.Co } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDisableImage(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDisableEbsEncryptionByDefault(response, &metadata) } - output := &DisableImageOutput{} + output := &DisableEbsEncryptionByDefaultOutput{} out.Result = output var buff [1024]byte @@ -42749,7 +43129,7 @@ func (m *awsEc2query_deserializeOpDisableImage) HandleDeserialize(ctx context.Co } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDisableImageOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDisableEbsEncryptionByDefaultOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -42763,7 +43143,7 @@ func (m *awsEc2query_deserializeOpDisableImage) HandleDeserialize(ctx context.Co return out, metadata, err } -func awsEc2query_deserializeOpErrorDisableImage(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDisableEbsEncryptionByDefault(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -42796,14 +43176,14 @@ func awsEc2query_deserializeOpErrorDisableImage(response *smithyhttp.Response, m } } -type awsEc2query_deserializeOpDisableImageBlockPublicAccess struct { +type awsEc2query_deserializeOpDisableFastLaunch struct { } -func (*awsEc2query_deserializeOpDisableImageBlockPublicAccess) ID() string { +func (*awsEc2query_deserializeOpDisableFastLaunch) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDisableImageBlockPublicAccess) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDisableFastLaunch) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -42821,9 +43201,9 @@ func (m *awsEc2query_deserializeOpDisableImageBlockPublicAccess) HandleDeseriali } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDisableImageBlockPublicAccess(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDisableFastLaunch(response, &metadata) } - output := &DisableImageBlockPublicAccessOutput{} + output := &DisableFastLaunchOutput{} out.Result = output var buff [1024]byte @@ -42844,7 +43224,7 @@ func (m *awsEc2query_deserializeOpDisableImageBlockPublicAccess) HandleDeseriali } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDisableImageBlockPublicAccessOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDisableFastLaunchOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -42858,7 +43238,7 @@ func (m *awsEc2query_deserializeOpDisableImageBlockPublicAccess) HandleDeseriali return out, metadata, err } -func awsEc2query_deserializeOpErrorDisableImageBlockPublicAccess(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDisableFastLaunch(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -42891,14 +43271,14 @@ func awsEc2query_deserializeOpErrorDisableImageBlockPublicAccess(response *smith } } -type awsEc2query_deserializeOpDisableImageDeprecation struct { +type awsEc2query_deserializeOpDisableFastSnapshotRestores struct { } -func (*awsEc2query_deserializeOpDisableImageDeprecation) ID() string { +func (*awsEc2query_deserializeOpDisableFastSnapshotRestores) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDisableImageDeprecation) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDisableFastSnapshotRestores) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -42916,9 +43296,9 @@ func (m *awsEc2query_deserializeOpDisableImageDeprecation) HandleDeserialize(ctx } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDisableImageDeprecation(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDisableFastSnapshotRestores(response, &metadata) } - output := &DisableImageDeprecationOutput{} + output := &DisableFastSnapshotRestoresOutput{} out.Result = output var buff [1024]byte @@ -42939,7 +43319,7 @@ func (m *awsEc2query_deserializeOpDisableImageDeprecation) HandleDeserialize(ctx } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDisableImageDeprecationOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDisableFastSnapshotRestoresOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -42953,7 +43333,7 @@ func (m *awsEc2query_deserializeOpDisableImageDeprecation) HandleDeserialize(ctx return out, metadata, err } -func awsEc2query_deserializeOpErrorDisableImageDeprecation(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDisableFastSnapshotRestores(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -42986,14 +43366,14 @@ func awsEc2query_deserializeOpErrorDisableImageDeprecation(response *smithyhttp. } } -type awsEc2query_deserializeOpDisableImageDeregistrationProtection struct { +type awsEc2query_deserializeOpDisableImage struct { } -func (*awsEc2query_deserializeOpDisableImageDeregistrationProtection) ID() string { +func (*awsEc2query_deserializeOpDisableImage) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDisableImageDeregistrationProtection) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDisableImage) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -43011,9 +43391,9 @@ func (m *awsEc2query_deserializeOpDisableImageDeregistrationProtection) HandleDe } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDisableImageDeregistrationProtection(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDisableImage(response, &metadata) } - output := &DisableImageDeregistrationProtectionOutput{} + output := &DisableImageOutput{} out.Result = output var buff [1024]byte @@ -43034,7 +43414,7 @@ func (m *awsEc2query_deserializeOpDisableImageDeregistrationProtection) HandleDe } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDisableImageDeregistrationProtectionOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDisableImageOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -43048,7 +43428,7 @@ func (m *awsEc2query_deserializeOpDisableImageDeregistrationProtection) HandleDe return out, metadata, err } -func awsEc2query_deserializeOpErrorDisableImageDeregistrationProtection(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDisableImage(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -43081,14 +43461,14 @@ func awsEc2query_deserializeOpErrorDisableImageDeregistrationProtection(response } } -type awsEc2query_deserializeOpDisableInstanceSqlHaStandbyDetections struct { +type awsEc2query_deserializeOpDisableImageBlockPublicAccess struct { } -func (*awsEc2query_deserializeOpDisableInstanceSqlHaStandbyDetections) ID() string { +func (*awsEc2query_deserializeOpDisableImageBlockPublicAccess) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDisableInstanceSqlHaStandbyDetections) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDisableImageBlockPublicAccess) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -43106,9 +43486,9 @@ func (m *awsEc2query_deserializeOpDisableInstanceSqlHaStandbyDetections) HandleD } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDisableInstanceSqlHaStandbyDetections(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDisableImageBlockPublicAccess(response, &metadata) } - output := &DisableInstanceSqlHaStandbyDetectionsOutput{} + output := &DisableImageBlockPublicAccessOutput{} out.Result = output var buff [1024]byte @@ -43129,7 +43509,7 @@ func (m *awsEc2query_deserializeOpDisableInstanceSqlHaStandbyDetections) HandleD } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDisableInstanceSqlHaStandbyDetectionsOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDisableImageBlockPublicAccessOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -43143,7 +43523,7 @@ func (m *awsEc2query_deserializeOpDisableInstanceSqlHaStandbyDetections) HandleD return out, metadata, err } -func awsEc2query_deserializeOpErrorDisableInstanceSqlHaStandbyDetections(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDisableImageBlockPublicAccess(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -43176,14 +43556,14 @@ func awsEc2query_deserializeOpErrorDisableInstanceSqlHaStandbyDetections(respons } } -type awsEc2query_deserializeOpDisableIpamOrganizationAdminAccount struct { +type awsEc2query_deserializeOpDisableImageDeprecation struct { } -func (*awsEc2query_deserializeOpDisableIpamOrganizationAdminAccount) ID() string { +func (*awsEc2query_deserializeOpDisableImageDeprecation) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDisableIpamOrganizationAdminAccount) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDisableImageDeprecation) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -43201,9 +43581,9 @@ func (m *awsEc2query_deserializeOpDisableIpamOrganizationAdminAccount) HandleDes } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDisableIpamOrganizationAdminAccount(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDisableImageDeprecation(response, &metadata) } - output := &DisableIpamOrganizationAdminAccountOutput{} + output := &DisableImageDeprecationOutput{} out.Result = output var buff [1024]byte @@ -43224,7 +43604,7 @@ func (m *awsEc2query_deserializeOpDisableIpamOrganizationAdminAccount) HandleDes } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDisableIpamOrganizationAdminAccountOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDisableImageDeprecationOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -43238,7 +43618,7 @@ func (m *awsEc2query_deserializeOpDisableIpamOrganizationAdminAccount) HandleDes return out, metadata, err } -func awsEc2query_deserializeOpErrorDisableIpamOrganizationAdminAccount(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDisableImageDeprecation(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -43271,14 +43651,14 @@ func awsEc2query_deserializeOpErrorDisableIpamOrganizationAdminAccount(response } } -type awsEc2query_deserializeOpDisableIpamPolicy struct { +type awsEc2query_deserializeOpDisableImageDeregistrationProtection struct { } -func (*awsEc2query_deserializeOpDisableIpamPolicy) ID() string { +func (*awsEc2query_deserializeOpDisableImageDeregistrationProtection) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDisableIpamPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDisableImageDeregistrationProtection) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -43296,9 +43676,9 @@ func (m *awsEc2query_deserializeOpDisableIpamPolicy) HandleDeserialize(ctx conte } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDisableIpamPolicy(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDisableImageDeregistrationProtection(response, &metadata) } - output := &DisableIpamPolicyOutput{} + output := &DisableImageDeregistrationProtectionOutput{} out.Result = output var buff [1024]byte @@ -43319,7 +43699,7 @@ func (m *awsEc2query_deserializeOpDisableIpamPolicy) HandleDeserialize(ctx conte } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDisableIpamPolicyOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDisableImageDeregistrationProtectionOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -43333,7 +43713,7 @@ func (m *awsEc2query_deserializeOpDisableIpamPolicy) HandleDeserialize(ctx conte return out, metadata, err } -func awsEc2query_deserializeOpErrorDisableIpamPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDisableImageDeregistrationProtection(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -43366,14 +43746,14 @@ func awsEc2query_deserializeOpErrorDisableIpamPolicy(response *smithyhttp.Respon } } -type awsEc2query_deserializeOpDisableRouteServerPropagation struct { +type awsEc2query_deserializeOpDisableInstanceSqlHaStandbyDetections struct { } -func (*awsEc2query_deserializeOpDisableRouteServerPropagation) ID() string { +func (*awsEc2query_deserializeOpDisableInstanceSqlHaStandbyDetections) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDisableRouteServerPropagation) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDisableInstanceSqlHaStandbyDetections) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -43391,9 +43771,9 @@ func (m *awsEc2query_deserializeOpDisableRouteServerPropagation) HandleDeseriali } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDisableRouteServerPropagation(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDisableInstanceSqlHaStandbyDetections(response, &metadata) } - output := &DisableRouteServerPropagationOutput{} + output := &DisableInstanceSqlHaStandbyDetectionsOutput{} out.Result = output var buff [1024]byte @@ -43414,7 +43794,7 @@ func (m *awsEc2query_deserializeOpDisableRouteServerPropagation) HandleDeseriali } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDisableRouteServerPropagationOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDisableInstanceSqlHaStandbyDetectionsOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -43428,7 +43808,7 @@ func (m *awsEc2query_deserializeOpDisableRouteServerPropagation) HandleDeseriali return out, metadata, err } -func awsEc2query_deserializeOpErrorDisableRouteServerPropagation(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDisableInstanceSqlHaStandbyDetections(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -43461,14 +43841,14 @@ func awsEc2query_deserializeOpErrorDisableRouteServerPropagation(response *smith } } -type awsEc2query_deserializeOpDisableSerialConsoleAccess struct { +type awsEc2query_deserializeOpDisableIpamOrganizationAdminAccount struct { } -func (*awsEc2query_deserializeOpDisableSerialConsoleAccess) ID() string { +func (*awsEc2query_deserializeOpDisableIpamOrganizationAdminAccount) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDisableSerialConsoleAccess) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDisableIpamOrganizationAdminAccount) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -43486,9 +43866,9 @@ func (m *awsEc2query_deserializeOpDisableSerialConsoleAccess) HandleDeserialize( } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDisableSerialConsoleAccess(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDisableIpamOrganizationAdminAccount(response, &metadata) } - output := &DisableSerialConsoleAccessOutput{} + output := &DisableIpamOrganizationAdminAccountOutput{} out.Result = output var buff [1024]byte @@ -43509,7 +43889,7 @@ func (m *awsEc2query_deserializeOpDisableSerialConsoleAccess) HandleDeserialize( } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDisableSerialConsoleAccessOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDisableIpamOrganizationAdminAccountOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -43523,7 +43903,7 @@ func (m *awsEc2query_deserializeOpDisableSerialConsoleAccess) HandleDeserialize( return out, metadata, err } -func awsEc2query_deserializeOpErrorDisableSerialConsoleAccess(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDisableIpamOrganizationAdminAccount(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -43556,14 +43936,14 @@ func awsEc2query_deserializeOpErrorDisableSerialConsoleAccess(response *smithyht } } -type awsEc2query_deserializeOpDisableSnapshotBlockPublicAccess struct { +type awsEc2query_deserializeOpDisableIpamPolicy struct { } -func (*awsEc2query_deserializeOpDisableSnapshotBlockPublicAccess) ID() string { +func (*awsEc2query_deserializeOpDisableIpamPolicy) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDisableSnapshotBlockPublicAccess) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDisableIpamPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -43581,9 +43961,9 @@ func (m *awsEc2query_deserializeOpDisableSnapshotBlockPublicAccess) HandleDeseri } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDisableSnapshotBlockPublicAccess(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDisableIpamPolicy(response, &metadata) } - output := &DisableSnapshotBlockPublicAccessOutput{} + output := &DisableIpamPolicyOutput{} out.Result = output var buff [1024]byte @@ -43604,7 +43984,7 @@ func (m *awsEc2query_deserializeOpDisableSnapshotBlockPublicAccess) HandleDeseri } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDisableSnapshotBlockPublicAccessOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDisableIpamPolicyOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -43618,7 +43998,7 @@ func (m *awsEc2query_deserializeOpDisableSnapshotBlockPublicAccess) HandleDeseri return out, metadata, err } -func awsEc2query_deserializeOpErrorDisableSnapshotBlockPublicAccess(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDisableIpamPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -43651,14 +44031,14 @@ func awsEc2query_deserializeOpErrorDisableSnapshotBlockPublicAccess(response *sm } } -type awsEc2query_deserializeOpDisableTransitGatewayRouteTablePropagation struct { +type awsEc2query_deserializeOpDisableRouteServerPropagation struct { } -func (*awsEc2query_deserializeOpDisableTransitGatewayRouteTablePropagation) ID() string { +func (*awsEc2query_deserializeOpDisableRouteServerPropagation) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDisableTransitGatewayRouteTablePropagation) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDisableRouteServerPropagation) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -43676,9 +44056,9 @@ func (m *awsEc2query_deserializeOpDisableTransitGatewayRouteTablePropagation) Ha } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDisableTransitGatewayRouteTablePropagation(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDisableRouteServerPropagation(response, &metadata) } - output := &DisableTransitGatewayRouteTablePropagationOutput{} + output := &DisableRouteServerPropagationOutput{} out.Result = output var buff [1024]byte @@ -43699,7 +44079,7 @@ func (m *awsEc2query_deserializeOpDisableTransitGatewayRouteTablePropagation) Ha } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDisableTransitGatewayRouteTablePropagationOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDisableRouteServerPropagationOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -43713,7 +44093,7 @@ func (m *awsEc2query_deserializeOpDisableTransitGatewayRouteTablePropagation) Ha return out, metadata, err } -func awsEc2query_deserializeOpErrorDisableTransitGatewayRouteTablePropagation(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDisableRouteServerPropagation(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -43746,14 +44126,14 @@ func awsEc2query_deserializeOpErrorDisableTransitGatewayRouteTablePropagation(re } } -type awsEc2query_deserializeOpDisableVgwRoutePropagation struct { +type awsEc2query_deserializeOpDisableSerialConsoleAccess struct { } -func (*awsEc2query_deserializeOpDisableVgwRoutePropagation) ID() string { +func (*awsEc2query_deserializeOpDisableSerialConsoleAccess) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDisableVgwRoutePropagation) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDisableSerialConsoleAccess) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -43771,21 +44151,44 @@ func (m *awsEc2query_deserializeOpDisableVgwRoutePropagation) HandleDeserialize( } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDisableVgwRoutePropagation(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDisableSerialConsoleAccess(response, &metadata) } - output := &DisableVgwRoutePropagationOutput{} + output := &DisableSerialConsoleAccessOutput{} 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_deserializeOpDocumentDisableSerialConsoleAccessOutput(&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_deserializeOpErrorDisableVgwRoutePropagation(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDisableSerialConsoleAccess(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -43818,14 +44221,14 @@ func awsEc2query_deserializeOpErrorDisableVgwRoutePropagation(response *smithyht } } -type awsEc2query_deserializeOpDisableVpcClassicLink struct { +type awsEc2query_deserializeOpDisableSnapshotBlockPublicAccess struct { } -func (*awsEc2query_deserializeOpDisableVpcClassicLink) ID() string { +func (*awsEc2query_deserializeOpDisableSnapshotBlockPublicAccess) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDisableVpcClassicLink) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDisableSnapshotBlockPublicAccess) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -43843,9 +44246,9 @@ func (m *awsEc2query_deserializeOpDisableVpcClassicLink) HandleDeserialize(ctx c } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDisableVpcClassicLink(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDisableSnapshotBlockPublicAccess(response, &metadata) } - output := &DisableVpcClassicLinkOutput{} + output := &DisableSnapshotBlockPublicAccessOutput{} out.Result = output var buff [1024]byte @@ -43866,7 +44269,7 @@ func (m *awsEc2query_deserializeOpDisableVpcClassicLink) HandleDeserialize(ctx c } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDisableVpcClassicLinkOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDisableSnapshotBlockPublicAccessOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -43880,7 +44283,7 @@ func (m *awsEc2query_deserializeOpDisableVpcClassicLink) HandleDeserialize(ctx c return out, metadata, err } -func awsEc2query_deserializeOpErrorDisableVpcClassicLink(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDisableSnapshotBlockPublicAccess(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -43913,14 +44316,14 @@ func awsEc2query_deserializeOpErrorDisableVpcClassicLink(response *smithyhttp.Re } } -type awsEc2query_deserializeOpDisableVpcClassicLinkDnsSupport struct { +type awsEc2query_deserializeOpDisableTransitGatewayRouteTablePropagation struct { } -func (*awsEc2query_deserializeOpDisableVpcClassicLinkDnsSupport) ID() string { +func (*awsEc2query_deserializeOpDisableTransitGatewayRouteTablePropagation) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDisableVpcClassicLinkDnsSupport) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDisableTransitGatewayRouteTablePropagation) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -43938,9 +44341,9 @@ func (m *awsEc2query_deserializeOpDisableVpcClassicLinkDnsSupport) HandleDeseria } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDisableVpcClassicLinkDnsSupport(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDisableTransitGatewayRouteTablePropagation(response, &metadata) } - output := &DisableVpcClassicLinkDnsSupportOutput{} + output := &DisableTransitGatewayRouteTablePropagationOutput{} out.Result = output var buff [1024]byte @@ -43961,7 +44364,7 @@ func (m *awsEc2query_deserializeOpDisableVpcClassicLinkDnsSupport) HandleDeseria } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDisableVpcClassicLinkDnsSupportOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDisableTransitGatewayRouteTablePropagationOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -43975,7 +44378,7 @@ func (m *awsEc2query_deserializeOpDisableVpcClassicLinkDnsSupport) HandleDeseria return out, metadata, err } -func awsEc2query_deserializeOpErrorDisableVpcClassicLinkDnsSupport(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDisableTransitGatewayRouteTablePropagation(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -44008,14 +44411,14 @@ func awsEc2query_deserializeOpErrorDisableVpcClassicLinkDnsSupport(response *smi } } -type awsEc2query_deserializeOpDisassociateAddress struct { +type awsEc2query_deserializeOpDisableVgwRoutePropagation struct { } -func (*awsEc2query_deserializeOpDisassociateAddress) ID() string { +func (*awsEc2query_deserializeOpDisableVgwRoutePropagation) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDisassociateAddress) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDisableVgwRoutePropagation) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -44033,9 +44436,9 @@ func (m *awsEc2query_deserializeOpDisassociateAddress) HandleDeserialize(ctx con } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDisassociateAddress(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDisableVgwRoutePropagation(response, &metadata) } - output := &DisassociateAddressOutput{} + output := &DisableVgwRoutePropagationOutput{} out.Result = output if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { @@ -44047,7 +44450,7 @@ func (m *awsEc2query_deserializeOpDisassociateAddress) HandleDeserialize(ctx con return out, metadata, err } -func awsEc2query_deserializeOpErrorDisassociateAddress(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDisableVgwRoutePropagation(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.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 +44483,14 @@ func awsEc2query_deserializeOpErrorDisassociateAddress(response *smithyhttp.Resp } } -type awsEc2query_deserializeOpDisassociateCapacityReservationBillingOwner struct { +type awsEc2query_deserializeOpDisableVpcClassicLink struct { } -func (*awsEc2query_deserializeOpDisassociateCapacityReservationBillingOwner) ID() string { +func (*awsEc2query_deserializeOpDisableVpcClassicLink) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDisassociateCapacityReservationBillingOwner) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDisableVpcClassicLink) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -44105,9 +44508,9 @@ func (m *awsEc2query_deserializeOpDisassociateCapacityReservationBillingOwner) H } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDisassociateCapacityReservationBillingOwner(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDisableVpcClassicLink(response, &metadata) } - output := &DisassociateCapacityReservationBillingOwnerOutput{} + output := &DisableVpcClassicLinkOutput{} out.Result = output var buff [1024]byte @@ -44128,7 +44531,7 @@ func (m *awsEc2query_deserializeOpDisassociateCapacityReservationBillingOwner) H } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDisassociateCapacityReservationBillingOwnerOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDisableVpcClassicLinkOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -44142,7 +44545,7 @@ func (m *awsEc2query_deserializeOpDisassociateCapacityReservationBillingOwner) H return out, metadata, err } -func awsEc2query_deserializeOpErrorDisassociateCapacityReservationBillingOwner(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDisableVpcClassicLink(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -44175,14 +44578,14 @@ func awsEc2query_deserializeOpErrorDisassociateCapacityReservationBillingOwner(r } } -type awsEc2query_deserializeOpDisassociateClientVpnTargetNetwork struct { +type awsEc2query_deserializeOpDisableVpcClassicLinkDnsSupport struct { } -func (*awsEc2query_deserializeOpDisassociateClientVpnTargetNetwork) ID() string { +func (*awsEc2query_deserializeOpDisableVpcClassicLinkDnsSupport) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDisassociateClientVpnTargetNetwork) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDisableVpcClassicLinkDnsSupport) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -44200,9 +44603,9 @@ func (m *awsEc2query_deserializeOpDisassociateClientVpnTargetNetwork) HandleDese } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDisassociateClientVpnTargetNetwork(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDisableVpcClassicLinkDnsSupport(response, &metadata) } - output := &DisassociateClientVpnTargetNetworkOutput{} + output := &DisableVpcClassicLinkDnsSupportOutput{} out.Result = output var buff [1024]byte @@ -44223,7 +44626,7 @@ func (m *awsEc2query_deserializeOpDisassociateClientVpnTargetNetwork) HandleDese } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDisassociateClientVpnTargetNetworkOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDisableVpcClassicLinkDnsSupportOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -44237,7 +44640,7 @@ func (m *awsEc2query_deserializeOpDisassociateClientVpnTargetNetwork) HandleDese return out, metadata, err } -func awsEc2query_deserializeOpErrorDisassociateClientVpnTargetNetwork(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDisableVpcClassicLinkDnsSupport(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -44270,14 +44673,14 @@ func awsEc2query_deserializeOpErrorDisassociateClientVpnTargetNetwork(response * } } -type awsEc2query_deserializeOpDisassociateEnclaveCertificateIamRole struct { +type awsEc2query_deserializeOpDisassociateAddress struct { } -func (*awsEc2query_deserializeOpDisassociateEnclaveCertificateIamRole) ID() string { +func (*awsEc2query_deserializeOpDisassociateAddress) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDisassociateEnclaveCertificateIamRole) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDisassociateAddress) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -44295,44 +44698,21 @@ func (m *awsEc2query_deserializeOpDisassociateEnclaveCertificateIamRole) HandleD } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDisassociateEnclaveCertificateIamRole(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDisassociateAddress(response, &metadata) } - output := &DisassociateEnclaveCertificateIamRoleOutput{} + output := &DisassociateAddressOutput{} 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_deserializeOpDocumentDisassociateEnclaveCertificateIamRoleOutput(&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_deserializeOpErrorDisassociateEnclaveCertificateIamRole(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDisassociateAddress(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -44365,14 +44745,14 @@ func awsEc2query_deserializeOpErrorDisassociateEnclaveCertificateIamRole(respons } } -type awsEc2query_deserializeOpDisassociateIamInstanceProfile struct { +type awsEc2query_deserializeOpDisassociateCapacityReservationBillingOwner struct { } -func (*awsEc2query_deserializeOpDisassociateIamInstanceProfile) ID() string { +func (*awsEc2query_deserializeOpDisassociateCapacityReservationBillingOwner) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDisassociateIamInstanceProfile) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDisassociateCapacityReservationBillingOwner) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -44390,9 +44770,9 @@ func (m *awsEc2query_deserializeOpDisassociateIamInstanceProfile) HandleDeserial } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDisassociateIamInstanceProfile(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDisassociateCapacityReservationBillingOwner(response, &metadata) } - output := &DisassociateIamInstanceProfileOutput{} + output := &DisassociateCapacityReservationBillingOwnerOutput{} out.Result = output var buff [1024]byte @@ -44413,7 +44793,7 @@ func (m *awsEc2query_deserializeOpDisassociateIamInstanceProfile) HandleDeserial } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDisassociateIamInstanceProfileOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDisassociateCapacityReservationBillingOwnerOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -44427,7 +44807,7 @@ func (m *awsEc2query_deserializeOpDisassociateIamInstanceProfile) HandleDeserial return out, metadata, err } -func awsEc2query_deserializeOpErrorDisassociateIamInstanceProfile(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDisassociateCapacityReservationBillingOwner(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -44460,14 +44840,14 @@ func awsEc2query_deserializeOpErrorDisassociateIamInstanceProfile(response *smit } } -type awsEc2query_deserializeOpDisassociateInstanceEventWindow struct { +type awsEc2query_deserializeOpDisassociateClientVpnTargetNetwork struct { } -func (*awsEc2query_deserializeOpDisassociateInstanceEventWindow) ID() string { +func (*awsEc2query_deserializeOpDisassociateClientVpnTargetNetwork) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDisassociateInstanceEventWindow) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDisassociateClientVpnTargetNetwork) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -44485,9 +44865,9 @@ func (m *awsEc2query_deserializeOpDisassociateInstanceEventWindow) HandleDeseria } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDisassociateInstanceEventWindow(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDisassociateClientVpnTargetNetwork(response, &metadata) } - output := &DisassociateInstanceEventWindowOutput{} + output := &DisassociateClientVpnTargetNetworkOutput{} out.Result = output var buff [1024]byte @@ -44508,7 +44888,7 @@ func (m *awsEc2query_deserializeOpDisassociateInstanceEventWindow) HandleDeseria } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDisassociateInstanceEventWindowOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDisassociateClientVpnTargetNetworkOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -44522,7 +44902,7 @@ func (m *awsEc2query_deserializeOpDisassociateInstanceEventWindow) HandleDeseria return out, metadata, err } -func awsEc2query_deserializeOpErrorDisassociateInstanceEventWindow(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDisassociateClientVpnTargetNetwork(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -44555,14 +44935,14 @@ func awsEc2query_deserializeOpErrorDisassociateInstanceEventWindow(response *smi } } -type awsEc2query_deserializeOpDisassociateIpamByoasn struct { +type awsEc2query_deserializeOpDisassociateEnclaveCertificateIamRole struct { } -func (*awsEc2query_deserializeOpDisassociateIpamByoasn) ID() string { +func (*awsEc2query_deserializeOpDisassociateEnclaveCertificateIamRole) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDisassociateIpamByoasn) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDisassociateEnclaveCertificateIamRole) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -44580,9 +44960,9 @@ func (m *awsEc2query_deserializeOpDisassociateIpamByoasn) HandleDeserialize(ctx } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDisassociateIpamByoasn(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDisassociateEnclaveCertificateIamRole(response, &metadata) } - output := &DisassociateIpamByoasnOutput{} + output := &DisassociateEnclaveCertificateIamRoleOutput{} out.Result = output var buff [1024]byte @@ -44603,7 +44983,7 @@ func (m *awsEc2query_deserializeOpDisassociateIpamByoasn) HandleDeserialize(ctx } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDisassociateIpamByoasnOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDisassociateEnclaveCertificateIamRoleOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -44617,7 +44997,7 @@ func (m *awsEc2query_deserializeOpDisassociateIpamByoasn) HandleDeserialize(ctx return out, metadata, err } -func awsEc2query_deserializeOpErrorDisassociateIpamByoasn(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDisassociateEnclaveCertificateIamRole(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -44650,14 +45030,14 @@ func awsEc2query_deserializeOpErrorDisassociateIpamByoasn(response *smithyhttp.R } } -type awsEc2query_deserializeOpDisassociateIpamResourceDiscovery struct { +type awsEc2query_deserializeOpDisassociateIamInstanceProfile struct { } -func (*awsEc2query_deserializeOpDisassociateIpamResourceDiscovery) ID() string { +func (*awsEc2query_deserializeOpDisassociateIamInstanceProfile) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDisassociateIpamResourceDiscovery) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDisassociateIamInstanceProfile) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -44675,9 +45055,9 @@ func (m *awsEc2query_deserializeOpDisassociateIpamResourceDiscovery) HandleDeser } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDisassociateIpamResourceDiscovery(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDisassociateIamInstanceProfile(response, &metadata) } - output := &DisassociateIpamResourceDiscoveryOutput{} + output := &DisassociateIamInstanceProfileOutput{} out.Result = output var buff [1024]byte @@ -44698,7 +45078,7 @@ func (m *awsEc2query_deserializeOpDisassociateIpamResourceDiscovery) HandleDeser } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDisassociateIpamResourceDiscoveryOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDisassociateIamInstanceProfileOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -44712,7 +45092,7 @@ func (m *awsEc2query_deserializeOpDisassociateIpamResourceDiscovery) HandleDeser return out, metadata, err } -func awsEc2query_deserializeOpErrorDisassociateIpamResourceDiscovery(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDisassociateIamInstanceProfile(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -44745,14 +45125,14 @@ func awsEc2query_deserializeOpErrorDisassociateIpamResourceDiscovery(response *s } } -type awsEc2query_deserializeOpDisassociateNatGatewayAddress struct { +type awsEc2query_deserializeOpDisassociateInstanceEventWindow struct { } -func (*awsEc2query_deserializeOpDisassociateNatGatewayAddress) ID() string { +func (*awsEc2query_deserializeOpDisassociateInstanceEventWindow) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDisassociateNatGatewayAddress) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDisassociateInstanceEventWindow) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -44770,9 +45150,9 @@ func (m *awsEc2query_deserializeOpDisassociateNatGatewayAddress) HandleDeseriali } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDisassociateNatGatewayAddress(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDisassociateInstanceEventWindow(response, &metadata) } - output := &DisassociateNatGatewayAddressOutput{} + output := &DisassociateInstanceEventWindowOutput{} out.Result = output var buff [1024]byte @@ -44793,7 +45173,7 @@ func (m *awsEc2query_deserializeOpDisassociateNatGatewayAddress) HandleDeseriali } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDisassociateNatGatewayAddressOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDisassociateInstanceEventWindowOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -44807,7 +45187,7 @@ func (m *awsEc2query_deserializeOpDisassociateNatGatewayAddress) HandleDeseriali return out, metadata, err } -func awsEc2query_deserializeOpErrorDisassociateNatGatewayAddress(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDisassociateInstanceEventWindow(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -44840,14 +45220,14 @@ func awsEc2query_deserializeOpErrorDisassociateNatGatewayAddress(response *smith } } -type awsEc2query_deserializeOpDisassociateRouteServer struct { +type awsEc2query_deserializeOpDisassociateIpamByoasn struct { } -func (*awsEc2query_deserializeOpDisassociateRouteServer) ID() string { +func (*awsEc2query_deserializeOpDisassociateIpamByoasn) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDisassociateRouteServer) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDisassociateIpamByoasn) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -44865,9 +45245,9 @@ func (m *awsEc2query_deserializeOpDisassociateRouteServer) HandleDeserialize(ctx } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDisassociateRouteServer(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDisassociateIpamByoasn(response, &metadata) } - output := &DisassociateRouteServerOutput{} + output := &DisassociateIpamByoasnOutput{} out.Result = output var buff [1024]byte @@ -44888,7 +45268,7 @@ func (m *awsEc2query_deserializeOpDisassociateRouteServer) HandleDeserialize(ctx } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDisassociateRouteServerOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDisassociateIpamByoasnOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -44902,7 +45282,7 @@ func (m *awsEc2query_deserializeOpDisassociateRouteServer) HandleDeserialize(ctx return out, metadata, err } -func awsEc2query_deserializeOpErrorDisassociateRouteServer(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDisassociateIpamByoasn(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -44935,14 +45315,14 @@ func awsEc2query_deserializeOpErrorDisassociateRouteServer(response *smithyhttp. } } -type awsEc2query_deserializeOpDisassociateRouteTable struct { +type awsEc2query_deserializeOpDisassociateIpamResourceDiscovery struct { } -func (*awsEc2query_deserializeOpDisassociateRouteTable) ID() string { +func (*awsEc2query_deserializeOpDisassociateIpamResourceDiscovery) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDisassociateRouteTable) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +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) @@ -44960,21 +45340,44 @@ func (m *awsEc2query_deserializeOpDisassociateRouteTable) HandleDeserialize(ctx } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDisassociateRouteTable(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDisassociateIpamResourceDiscovery(response, &metadata) } - output := &DisassociateRouteTableOutput{} + output := &DisassociateIpamResourceDiscoveryOutput{} 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_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_deserializeOpErrorDisassociateRouteTable(response *smithyhttp.Response, metadata *middleware.Metadata) error { +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)} @@ -45007,14 +45410,14 @@ func awsEc2query_deserializeOpErrorDisassociateRouteTable(response *smithyhttp.R } } -type awsEc2query_deserializeOpDisassociateSecurityGroupVpc struct { +type awsEc2query_deserializeOpDisassociateNatGatewayAddress struct { } -func (*awsEc2query_deserializeOpDisassociateSecurityGroupVpc) ID() string { +func (*awsEc2query_deserializeOpDisassociateNatGatewayAddress) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDisassociateSecurityGroupVpc) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDisassociateNatGatewayAddress) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -45032,9 +45435,9 @@ func (m *awsEc2query_deserializeOpDisassociateSecurityGroupVpc) HandleDeserializ } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDisassociateSecurityGroupVpc(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDisassociateNatGatewayAddress(response, &metadata) } - output := &DisassociateSecurityGroupVpcOutput{} + output := &DisassociateNatGatewayAddressOutput{} out.Result = output var buff [1024]byte @@ -45055,7 +45458,7 @@ func (m *awsEc2query_deserializeOpDisassociateSecurityGroupVpc) HandleDeserializ } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDisassociateSecurityGroupVpcOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDisassociateNatGatewayAddressOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -45069,7 +45472,7 @@ func (m *awsEc2query_deserializeOpDisassociateSecurityGroupVpc) HandleDeserializ return out, metadata, err } -func awsEc2query_deserializeOpErrorDisassociateSecurityGroupVpc(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDisassociateNatGatewayAddress(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -45102,14 +45505,14 @@ func awsEc2query_deserializeOpErrorDisassociateSecurityGroupVpc(response *smithy } } -type awsEc2query_deserializeOpDisassociateSubnetCidrBlock struct { +type awsEc2query_deserializeOpDisassociateRouteServer struct { } -func (*awsEc2query_deserializeOpDisassociateSubnetCidrBlock) ID() string { +func (*awsEc2query_deserializeOpDisassociateRouteServer) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDisassociateSubnetCidrBlock) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDisassociateRouteServer) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -45127,9 +45530,9 @@ func (m *awsEc2query_deserializeOpDisassociateSubnetCidrBlock) HandleDeserialize } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDisassociateSubnetCidrBlock(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDisassociateRouteServer(response, &metadata) } - output := &DisassociateSubnetCidrBlockOutput{} + output := &DisassociateRouteServerOutput{} out.Result = output var buff [1024]byte @@ -45150,7 +45553,7 @@ func (m *awsEc2query_deserializeOpDisassociateSubnetCidrBlock) HandleDeserialize } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDisassociateSubnetCidrBlockOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDisassociateRouteServerOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -45164,7 +45567,7 @@ func (m *awsEc2query_deserializeOpDisassociateSubnetCidrBlock) HandleDeserialize return out, metadata, err } -func awsEc2query_deserializeOpErrorDisassociateSubnetCidrBlock(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDisassociateRouteServer(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -45197,14 +45600,14 @@ func awsEc2query_deserializeOpErrorDisassociateSubnetCidrBlock(response *smithyh } } -type awsEc2query_deserializeOpDisassociateTransitGatewayMulticastDomain struct { +type awsEc2query_deserializeOpDisassociateRouteTable struct { } -func (*awsEc2query_deserializeOpDisassociateTransitGatewayMulticastDomain) ID() string { +func (*awsEc2query_deserializeOpDisassociateRouteTable) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDisassociateTransitGatewayMulticastDomain) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDisassociateRouteTable) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -45222,44 +45625,21 @@ func (m *awsEc2query_deserializeOpDisassociateTransitGatewayMulticastDomain) Han } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDisassociateTransitGatewayMulticastDomain(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDisassociateRouteTable(response, &metadata) } - output := &DisassociateTransitGatewayMulticastDomainOutput{} + output := &DisassociateRouteTableOutput{} 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_deserializeOpDocumentDisassociateTransitGatewayMulticastDomainOutput(&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_deserializeOpErrorDisassociateTransitGatewayMulticastDomain(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDisassociateRouteTable(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -45292,14 +45672,14 @@ func awsEc2query_deserializeOpErrorDisassociateTransitGatewayMulticastDomain(res } } -type awsEc2query_deserializeOpDisassociateTransitGatewayPolicyTable struct { +type awsEc2query_deserializeOpDisassociateSecurityGroupVpc struct { } -func (*awsEc2query_deserializeOpDisassociateTransitGatewayPolicyTable) ID() string { +func (*awsEc2query_deserializeOpDisassociateSecurityGroupVpc) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDisassociateTransitGatewayPolicyTable) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDisassociateSecurityGroupVpc) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -45317,9 +45697,9 @@ func (m *awsEc2query_deserializeOpDisassociateTransitGatewayPolicyTable) HandleD } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDisassociateTransitGatewayPolicyTable(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDisassociateSecurityGroupVpc(response, &metadata) } - output := &DisassociateTransitGatewayPolicyTableOutput{} + output := &DisassociateSecurityGroupVpcOutput{} out.Result = output var buff [1024]byte @@ -45340,7 +45720,7 @@ func (m *awsEc2query_deserializeOpDisassociateTransitGatewayPolicyTable) HandleD } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDisassociateTransitGatewayPolicyTableOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDisassociateSecurityGroupVpcOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -45354,7 +45734,7 @@ func (m *awsEc2query_deserializeOpDisassociateTransitGatewayPolicyTable) HandleD return out, metadata, err } -func awsEc2query_deserializeOpErrorDisassociateTransitGatewayPolicyTable(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDisassociateSecurityGroupVpc(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -45387,14 +45767,14 @@ func awsEc2query_deserializeOpErrorDisassociateTransitGatewayPolicyTable(respons } } -type awsEc2query_deserializeOpDisassociateTransitGatewayRouteTable struct { +type awsEc2query_deserializeOpDisassociateSubnetCidrBlock struct { } -func (*awsEc2query_deserializeOpDisassociateTransitGatewayRouteTable) ID() string { +func (*awsEc2query_deserializeOpDisassociateSubnetCidrBlock) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDisassociateTransitGatewayRouteTable) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDisassociateSubnetCidrBlock) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -45412,9 +45792,9 @@ func (m *awsEc2query_deserializeOpDisassociateTransitGatewayRouteTable) HandleDe } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDisassociateTransitGatewayRouteTable(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDisassociateSubnetCidrBlock(response, &metadata) } - output := &DisassociateTransitGatewayRouteTableOutput{} + output := &DisassociateSubnetCidrBlockOutput{} out.Result = output var buff [1024]byte @@ -45435,7 +45815,7 @@ func (m *awsEc2query_deserializeOpDisassociateTransitGatewayRouteTable) HandleDe } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDisassociateTransitGatewayRouteTableOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDisassociateSubnetCidrBlockOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -45449,7 +45829,7 @@ func (m *awsEc2query_deserializeOpDisassociateTransitGatewayRouteTable) HandleDe return out, metadata, err } -func awsEc2query_deserializeOpErrorDisassociateTransitGatewayRouteTable(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDisassociateSubnetCidrBlock(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -45482,14 +45862,14 @@ func awsEc2query_deserializeOpErrorDisassociateTransitGatewayRouteTable(response } } -type awsEc2query_deserializeOpDisassociateTrunkInterface struct { +type awsEc2query_deserializeOpDisassociateTransitGatewayMulticastDomain struct { } -func (*awsEc2query_deserializeOpDisassociateTrunkInterface) ID() string { +func (*awsEc2query_deserializeOpDisassociateTransitGatewayMulticastDomain) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDisassociateTrunkInterface) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDisassociateTransitGatewayMulticastDomain) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -45507,9 +45887,9 @@ func (m *awsEc2query_deserializeOpDisassociateTrunkInterface) HandleDeserialize( } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDisassociateTrunkInterface(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDisassociateTransitGatewayMulticastDomain(response, &metadata) } - output := &DisassociateTrunkInterfaceOutput{} + output := &DisassociateTransitGatewayMulticastDomainOutput{} out.Result = output var buff [1024]byte @@ -45530,7 +45910,7 @@ func (m *awsEc2query_deserializeOpDisassociateTrunkInterface) HandleDeserialize( } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDisassociateTrunkInterfaceOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDisassociateTransitGatewayMulticastDomainOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -45544,7 +45924,7 @@ func (m *awsEc2query_deserializeOpDisassociateTrunkInterface) HandleDeserialize( return out, metadata, err } -func awsEc2query_deserializeOpErrorDisassociateTrunkInterface(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDisassociateTransitGatewayMulticastDomain(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -45577,14 +45957,14 @@ func awsEc2query_deserializeOpErrorDisassociateTrunkInterface(response *smithyht } } -type awsEc2query_deserializeOpDisassociateVpcCidrBlock struct { +type awsEc2query_deserializeOpDisassociateTransitGatewayPolicyTable struct { } -func (*awsEc2query_deserializeOpDisassociateVpcCidrBlock) ID() string { +func (*awsEc2query_deserializeOpDisassociateTransitGatewayPolicyTable) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpDisassociateVpcCidrBlock) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDisassociateTransitGatewayPolicyTable) HandleDeserialize(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 +45982,9 @@ func (m *awsEc2query_deserializeOpDisassociateVpcCidrBlock) HandleDeserialize(ct } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorDisassociateVpcCidrBlock(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDisassociateTransitGatewayPolicyTable(response, &metadata) } - output := &DisassociateVpcCidrBlockOutput{} + output := &DisassociateTransitGatewayPolicyTableOutput{} out.Result = output var buff [1024]byte @@ -45625,7 +46005,7 @@ func (m *awsEc2query_deserializeOpDisassociateVpcCidrBlock) HandleDeserialize(ct } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentDisassociateVpcCidrBlockOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDisassociateTransitGatewayPolicyTableOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -45639,7 +46019,7 @@ func (m *awsEc2query_deserializeOpDisassociateVpcCidrBlock) HandleDeserialize(ct return out, metadata, err } -func awsEc2query_deserializeOpErrorDisassociateVpcCidrBlock(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDisassociateTransitGatewayPolicyTable(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.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 +46052,14 @@ func awsEc2query_deserializeOpErrorDisassociateVpcCidrBlock(response *smithyhttp } } -type awsEc2query_deserializeOpEnableAddressTransfer struct { +type awsEc2query_deserializeOpDisassociateTransitGatewayRouteTable struct { } -func (*awsEc2query_deserializeOpEnableAddressTransfer) ID() string { +func (*awsEc2query_deserializeOpDisassociateTransitGatewayRouteTable) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpEnableAddressTransfer) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDisassociateTransitGatewayRouteTable) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -45697,9 +46077,9 @@ func (m *awsEc2query_deserializeOpEnableAddressTransfer) HandleDeserialize(ctx c } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorEnableAddressTransfer(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDisassociateTransitGatewayRouteTable(response, &metadata) } - output := &EnableAddressTransferOutput{} + output := &DisassociateTransitGatewayRouteTableOutput{} out.Result = output var buff [1024]byte @@ -45720,7 +46100,7 @@ func (m *awsEc2query_deserializeOpEnableAddressTransfer) HandleDeserialize(ctx c } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentEnableAddressTransferOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDisassociateTransitGatewayRouteTableOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -45734,7 +46114,7 @@ func (m *awsEc2query_deserializeOpEnableAddressTransfer) HandleDeserialize(ctx c return out, metadata, err } -func awsEc2query_deserializeOpErrorEnableAddressTransfer(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDisassociateTransitGatewayRouteTable(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -45767,14 +46147,14 @@ func awsEc2query_deserializeOpErrorEnableAddressTransfer(response *smithyhttp.Re } } -type awsEc2query_deserializeOpEnableAllowedImagesSettings struct { +type awsEc2query_deserializeOpDisassociateTrunkInterface struct { } -func (*awsEc2query_deserializeOpEnableAllowedImagesSettings) ID() string { +func (*awsEc2query_deserializeOpDisassociateTrunkInterface) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpEnableAllowedImagesSettings) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDisassociateTrunkInterface) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -45792,9 +46172,9 @@ func (m *awsEc2query_deserializeOpEnableAllowedImagesSettings) HandleDeserialize } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorEnableAllowedImagesSettings(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDisassociateTrunkInterface(response, &metadata) } - output := &EnableAllowedImagesSettingsOutput{} + output := &DisassociateTrunkInterfaceOutput{} out.Result = output var buff [1024]byte @@ -45815,7 +46195,7 @@ func (m *awsEc2query_deserializeOpEnableAllowedImagesSettings) HandleDeserialize } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentEnableAllowedImagesSettingsOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDisassociateTrunkInterfaceOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -45829,7 +46209,7 @@ func (m *awsEc2query_deserializeOpEnableAllowedImagesSettings) HandleDeserialize return out, metadata, err } -func awsEc2query_deserializeOpErrorEnableAllowedImagesSettings(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDisassociateTrunkInterface(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -45862,14 +46242,14 @@ func awsEc2query_deserializeOpErrorEnableAllowedImagesSettings(response *smithyh } } -type awsEc2query_deserializeOpEnableAwsNetworkPerformanceMetricSubscription struct { +type awsEc2query_deserializeOpDisassociateVpcCidrBlock struct { } -func (*awsEc2query_deserializeOpEnableAwsNetworkPerformanceMetricSubscription) ID() string { +func (*awsEc2query_deserializeOpDisassociateVpcCidrBlock) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpEnableAwsNetworkPerformanceMetricSubscription) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpDisassociateVpcCidrBlock) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -45887,9 +46267,9 @@ func (m *awsEc2query_deserializeOpEnableAwsNetworkPerformanceMetricSubscription) } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorEnableAwsNetworkPerformanceMetricSubscription(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorDisassociateVpcCidrBlock(response, &metadata) } - output := &EnableAwsNetworkPerformanceMetricSubscriptionOutput{} + output := &DisassociateVpcCidrBlockOutput{} out.Result = output var buff [1024]byte @@ -45910,7 +46290,7 @@ func (m *awsEc2query_deserializeOpEnableAwsNetworkPerformanceMetricSubscription) } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentEnableAwsNetworkPerformanceMetricSubscriptionOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentDisassociateVpcCidrBlockOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -45924,7 +46304,7 @@ func (m *awsEc2query_deserializeOpEnableAwsNetworkPerformanceMetricSubscription) return out, metadata, err } -func awsEc2query_deserializeOpErrorEnableAwsNetworkPerformanceMetricSubscription(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorDisassociateVpcCidrBlock(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -45957,14 +46337,14 @@ func awsEc2query_deserializeOpErrorEnableAwsNetworkPerformanceMetricSubscription } } -type awsEc2query_deserializeOpEnableCapacityManager struct { +type awsEc2query_deserializeOpEnableAddressTransfer struct { } -func (*awsEc2query_deserializeOpEnableCapacityManager) ID() string { +func (*awsEc2query_deserializeOpEnableAddressTransfer) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpEnableCapacityManager) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpEnableAddressTransfer) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -45982,9 +46362,9 @@ func (m *awsEc2query_deserializeOpEnableCapacityManager) HandleDeserialize(ctx c } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorEnableCapacityManager(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorEnableAddressTransfer(response, &metadata) } - output := &EnableCapacityManagerOutput{} + output := &EnableAddressTransferOutput{} out.Result = output var buff [1024]byte @@ -46005,7 +46385,7 @@ func (m *awsEc2query_deserializeOpEnableCapacityManager) HandleDeserialize(ctx c } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentEnableCapacityManagerOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentEnableAddressTransferOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -46019,7 +46399,7 @@ func (m *awsEc2query_deserializeOpEnableCapacityManager) HandleDeserialize(ctx c return out, metadata, err } -func awsEc2query_deserializeOpErrorEnableCapacityManager(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorEnableAddressTransfer(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -46052,14 +46432,14 @@ func awsEc2query_deserializeOpErrorEnableCapacityManager(response *smithyhttp.Re } } -type awsEc2query_deserializeOpEnableEbsEncryptionByDefault struct { +type awsEc2query_deserializeOpEnableAllowedImagesSettings struct { } -func (*awsEc2query_deserializeOpEnableEbsEncryptionByDefault) ID() string { +func (*awsEc2query_deserializeOpEnableAllowedImagesSettings) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpEnableEbsEncryptionByDefault) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpEnableAllowedImagesSettings) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -46077,9 +46457,9 @@ func (m *awsEc2query_deserializeOpEnableEbsEncryptionByDefault) HandleDeserializ } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorEnableEbsEncryptionByDefault(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorEnableAllowedImagesSettings(response, &metadata) } - output := &EnableEbsEncryptionByDefaultOutput{} + output := &EnableAllowedImagesSettingsOutput{} out.Result = output var buff [1024]byte @@ -46100,7 +46480,7 @@ func (m *awsEc2query_deserializeOpEnableEbsEncryptionByDefault) HandleDeserializ } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentEnableEbsEncryptionByDefaultOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentEnableAllowedImagesSettingsOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -46114,7 +46494,7 @@ func (m *awsEc2query_deserializeOpEnableEbsEncryptionByDefault) HandleDeserializ return out, metadata, err } -func awsEc2query_deserializeOpErrorEnableEbsEncryptionByDefault(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorEnableAllowedImagesSettings(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -46147,14 +46527,14 @@ func awsEc2query_deserializeOpErrorEnableEbsEncryptionByDefault(response *smithy } } -type awsEc2query_deserializeOpEnableFastLaunch struct { +type awsEc2query_deserializeOpEnableAwsNetworkPerformanceMetricSubscription struct { } -func (*awsEc2query_deserializeOpEnableFastLaunch) ID() string { +func (*awsEc2query_deserializeOpEnableAwsNetworkPerformanceMetricSubscription) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpEnableFastLaunch) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpEnableAwsNetworkPerformanceMetricSubscription) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -46172,9 +46552,9 @@ func (m *awsEc2query_deserializeOpEnableFastLaunch) HandleDeserialize(ctx contex } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorEnableFastLaunch(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorEnableAwsNetworkPerformanceMetricSubscription(response, &metadata) } - output := &EnableFastLaunchOutput{} + output := &EnableAwsNetworkPerformanceMetricSubscriptionOutput{} out.Result = output var buff [1024]byte @@ -46195,7 +46575,7 @@ func (m *awsEc2query_deserializeOpEnableFastLaunch) HandleDeserialize(ctx contex } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentEnableFastLaunchOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentEnableAwsNetworkPerformanceMetricSubscriptionOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -46209,7 +46589,7 @@ func (m *awsEc2query_deserializeOpEnableFastLaunch) HandleDeserialize(ctx contex return out, metadata, err } -func awsEc2query_deserializeOpErrorEnableFastLaunch(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorEnableAwsNetworkPerformanceMetricSubscription(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -46242,14 +46622,14 @@ func awsEc2query_deserializeOpErrorEnableFastLaunch(response *smithyhttp.Respons } } -type awsEc2query_deserializeOpEnableFastSnapshotRestores struct { +type awsEc2query_deserializeOpEnableCapacityManager struct { } -func (*awsEc2query_deserializeOpEnableFastSnapshotRestores) ID() string { +func (*awsEc2query_deserializeOpEnableCapacityManager) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpEnableFastSnapshotRestores) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpEnableCapacityManager) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -46267,9 +46647,9 @@ func (m *awsEc2query_deserializeOpEnableFastSnapshotRestores) HandleDeserialize( } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorEnableFastSnapshotRestores(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorEnableCapacityManager(response, &metadata) } - output := &EnableFastSnapshotRestoresOutput{} + output := &EnableCapacityManagerOutput{} out.Result = output var buff [1024]byte @@ -46290,7 +46670,7 @@ func (m *awsEc2query_deserializeOpEnableFastSnapshotRestores) HandleDeserialize( } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentEnableFastSnapshotRestoresOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentEnableCapacityManagerOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -46304,7 +46684,7 @@ func (m *awsEc2query_deserializeOpEnableFastSnapshotRestores) HandleDeserialize( return out, metadata, err } -func awsEc2query_deserializeOpErrorEnableFastSnapshotRestores(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorEnableCapacityManager(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -46337,14 +46717,14 @@ func awsEc2query_deserializeOpErrorEnableFastSnapshotRestores(response *smithyht } } -type awsEc2query_deserializeOpEnableImage struct { +type awsEc2query_deserializeOpEnableEbsEncryptionByDefault struct { } -func (*awsEc2query_deserializeOpEnableImage) ID() string { +func (*awsEc2query_deserializeOpEnableEbsEncryptionByDefault) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpEnableImage) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpEnableEbsEncryptionByDefault) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -46362,9 +46742,9 @@ func (m *awsEc2query_deserializeOpEnableImage) HandleDeserialize(ctx context.Con } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorEnableImage(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorEnableEbsEncryptionByDefault(response, &metadata) } - output := &EnableImageOutput{} + output := &EnableEbsEncryptionByDefaultOutput{} out.Result = output var buff [1024]byte @@ -46385,7 +46765,7 @@ func (m *awsEc2query_deserializeOpEnableImage) HandleDeserialize(ctx context.Con } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentEnableImageOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentEnableEbsEncryptionByDefaultOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -46399,7 +46779,7 @@ func (m *awsEc2query_deserializeOpEnableImage) HandleDeserialize(ctx context.Con return out, metadata, err } -func awsEc2query_deserializeOpErrorEnableImage(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorEnableEbsEncryptionByDefault(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -46432,14 +46812,14 @@ func awsEc2query_deserializeOpErrorEnableImage(response *smithyhttp.Response, me } } -type awsEc2query_deserializeOpEnableImageBlockPublicAccess struct { +type awsEc2query_deserializeOpEnableFastLaunch struct { } -func (*awsEc2query_deserializeOpEnableImageBlockPublicAccess) ID() string { +func (*awsEc2query_deserializeOpEnableFastLaunch) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpEnableImageBlockPublicAccess) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpEnableFastLaunch) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -46457,9 +46837,9 @@ func (m *awsEc2query_deserializeOpEnableImageBlockPublicAccess) HandleDeserializ } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorEnableImageBlockPublicAccess(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorEnableFastLaunch(response, &metadata) } - output := &EnableImageBlockPublicAccessOutput{} + output := &EnableFastLaunchOutput{} out.Result = output var buff [1024]byte @@ -46480,7 +46860,7 @@ func (m *awsEc2query_deserializeOpEnableImageBlockPublicAccess) HandleDeserializ } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentEnableImageBlockPublicAccessOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentEnableFastLaunchOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -46494,7 +46874,7 @@ func (m *awsEc2query_deserializeOpEnableImageBlockPublicAccess) HandleDeserializ return out, metadata, err } -func awsEc2query_deserializeOpErrorEnableImageBlockPublicAccess(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorEnableFastLaunch(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -46527,14 +46907,14 @@ func awsEc2query_deserializeOpErrorEnableImageBlockPublicAccess(response *smithy } } -type awsEc2query_deserializeOpEnableImageDeprecation struct { +type awsEc2query_deserializeOpEnableFastSnapshotRestores struct { } -func (*awsEc2query_deserializeOpEnableImageDeprecation) ID() string { +func (*awsEc2query_deserializeOpEnableFastSnapshotRestores) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpEnableImageDeprecation) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpEnableFastSnapshotRestores) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -46552,9 +46932,9 @@ func (m *awsEc2query_deserializeOpEnableImageDeprecation) HandleDeserialize(ctx } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorEnableImageDeprecation(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorEnableFastSnapshotRestores(response, &metadata) } - output := &EnableImageDeprecationOutput{} + output := &EnableFastSnapshotRestoresOutput{} out.Result = output var buff [1024]byte @@ -46575,7 +46955,7 @@ func (m *awsEc2query_deserializeOpEnableImageDeprecation) HandleDeserialize(ctx } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentEnableImageDeprecationOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentEnableFastSnapshotRestoresOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -46589,7 +46969,7 @@ func (m *awsEc2query_deserializeOpEnableImageDeprecation) HandleDeserialize(ctx return out, metadata, err } -func awsEc2query_deserializeOpErrorEnableImageDeprecation(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorEnableFastSnapshotRestores(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -46622,14 +47002,14 @@ func awsEc2query_deserializeOpErrorEnableImageDeprecation(response *smithyhttp.R } } -type awsEc2query_deserializeOpEnableImageDeregistrationProtection struct { +type awsEc2query_deserializeOpEnableImage struct { } -func (*awsEc2query_deserializeOpEnableImageDeregistrationProtection) ID() string { +func (*awsEc2query_deserializeOpEnableImage) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpEnableImageDeregistrationProtection) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpEnableImage) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -46647,9 +47027,9 @@ func (m *awsEc2query_deserializeOpEnableImageDeregistrationProtection) HandleDes } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorEnableImageDeregistrationProtection(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorEnableImage(response, &metadata) } - output := &EnableImageDeregistrationProtectionOutput{} + output := &EnableImageOutput{} out.Result = output var buff [1024]byte @@ -46670,7 +47050,7 @@ func (m *awsEc2query_deserializeOpEnableImageDeregistrationProtection) HandleDes } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentEnableImageDeregistrationProtectionOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentEnableImageOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -46684,7 +47064,7 @@ func (m *awsEc2query_deserializeOpEnableImageDeregistrationProtection) HandleDes return out, metadata, err } -func awsEc2query_deserializeOpErrorEnableImageDeregistrationProtection(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorEnableImage(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -46717,14 +47097,14 @@ func awsEc2query_deserializeOpErrorEnableImageDeregistrationProtection(response } } -type awsEc2query_deserializeOpEnableInstanceSqlHaStandbyDetections struct { +type awsEc2query_deserializeOpEnableImageBlockPublicAccess struct { } -func (*awsEc2query_deserializeOpEnableInstanceSqlHaStandbyDetections) ID() string { +func (*awsEc2query_deserializeOpEnableImageBlockPublicAccess) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpEnableInstanceSqlHaStandbyDetections) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpEnableImageBlockPublicAccess) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -46742,9 +47122,9 @@ func (m *awsEc2query_deserializeOpEnableInstanceSqlHaStandbyDetections) HandleDe } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorEnableInstanceSqlHaStandbyDetections(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorEnableImageBlockPublicAccess(response, &metadata) } - output := &EnableInstanceSqlHaStandbyDetectionsOutput{} + output := &EnableImageBlockPublicAccessOutput{} out.Result = output var buff [1024]byte @@ -46765,7 +47145,7 @@ func (m *awsEc2query_deserializeOpEnableInstanceSqlHaStandbyDetections) HandleDe } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentEnableInstanceSqlHaStandbyDetectionsOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentEnableImageBlockPublicAccessOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -46779,7 +47159,7 @@ func (m *awsEc2query_deserializeOpEnableInstanceSqlHaStandbyDetections) HandleDe return out, metadata, err } -func awsEc2query_deserializeOpErrorEnableInstanceSqlHaStandbyDetections(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorEnableImageBlockPublicAccess(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -46812,14 +47192,14 @@ func awsEc2query_deserializeOpErrorEnableInstanceSqlHaStandbyDetections(response } } -type awsEc2query_deserializeOpEnableIpamOrganizationAdminAccount struct { +type awsEc2query_deserializeOpEnableImageDeprecation struct { } -func (*awsEc2query_deserializeOpEnableIpamOrganizationAdminAccount) ID() string { +func (*awsEc2query_deserializeOpEnableImageDeprecation) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpEnableIpamOrganizationAdminAccount) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpEnableImageDeprecation) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -46837,9 +47217,9 @@ func (m *awsEc2query_deserializeOpEnableIpamOrganizationAdminAccount) HandleDese } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorEnableIpamOrganizationAdminAccount(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorEnableImageDeprecation(response, &metadata) } - output := &EnableIpamOrganizationAdminAccountOutput{} + output := &EnableImageDeprecationOutput{} out.Result = output var buff [1024]byte @@ -46860,7 +47240,7 @@ func (m *awsEc2query_deserializeOpEnableIpamOrganizationAdminAccount) HandleDese } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentEnableIpamOrganizationAdminAccountOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentEnableImageDeprecationOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -46874,7 +47254,7 @@ func (m *awsEc2query_deserializeOpEnableIpamOrganizationAdminAccount) HandleDese return out, metadata, err } -func awsEc2query_deserializeOpErrorEnableIpamOrganizationAdminAccount(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorEnableImageDeprecation(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -46907,14 +47287,14 @@ func awsEc2query_deserializeOpErrorEnableIpamOrganizationAdminAccount(response * } } -type awsEc2query_deserializeOpEnableIpamPolicy struct { +type awsEc2query_deserializeOpEnableImageDeregistrationProtection struct { } -func (*awsEc2query_deserializeOpEnableIpamPolicy) ID() string { +func (*awsEc2query_deserializeOpEnableImageDeregistrationProtection) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpEnableIpamPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpEnableImageDeregistrationProtection) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -46932,9 +47312,9 @@ func (m *awsEc2query_deserializeOpEnableIpamPolicy) HandleDeserialize(ctx contex } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorEnableIpamPolicy(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorEnableImageDeregistrationProtection(response, &metadata) } - output := &EnableIpamPolicyOutput{} + output := &EnableImageDeregistrationProtectionOutput{} out.Result = output var buff [1024]byte @@ -46955,7 +47335,7 @@ func (m *awsEc2query_deserializeOpEnableIpamPolicy) HandleDeserialize(ctx contex } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentEnableIpamPolicyOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentEnableImageDeregistrationProtectionOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -46969,7 +47349,7 @@ func (m *awsEc2query_deserializeOpEnableIpamPolicy) HandleDeserialize(ctx contex return out, metadata, err } -func awsEc2query_deserializeOpErrorEnableIpamPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorEnableImageDeregistrationProtection(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -47002,14 +47382,14 @@ func awsEc2query_deserializeOpErrorEnableIpamPolicy(response *smithyhttp.Respons } } -type awsEc2query_deserializeOpEnableReachabilityAnalyzerOrganizationSharing struct { +type awsEc2query_deserializeOpEnableInstanceSqlHaStandbyDetections struct { } -func (*awsEc2query_deserializeOpEnableReachabilityAnalyzerOrganizationSharing) ID() string { +func (*awsEc2query_deserializeOpEnableInstanceSqlHaStandbyDetections) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpEnableReachabilityAnalyzerOrganizationSharing) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpEnableInstanceSqlHaStandbyDetections) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -47027,9 +47407,9 @@ func (m *awsEc2query_deserializeOpEnableReachabilityAnalyzerOrganizationSharing) } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorEnableReachabilityAnalyzerOrganizationSharing(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorEnableInstanceSqlHaStandbyDetections(response, &metadata) } - output := &EnableReachabilityAnalyzerOrganizationSharingOutput{} + output := &EnableInstanceSqlHaStandbyDetectionsOutput{} out.Result = output var buff [1024]byte @@ -47050,7 +47430,7 @@ func (m *awsEc2query_deserializeOpEnableReachabilityAnalyzerOrganizationSharing) } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentEnableReachabilityAnalyzerOrganizationSharingOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentEnableInstanceSqlHaStandbyDetectionsOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -47064,7 +47444,7 @@ func (m *awsEc2query_deserializeOpEnableReachabilityAnalyzerOrganizationSharing) return out, metadata, err } -func awsEc2query_deserializeOpErrorEnableReachabilityAnalyzerOrganizationSharing(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorEnableInstanceSqlHaStandbyDetections(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -47097,14 +47477,14 @@ func awsEc2query_deserializeOpErrorEnableReachabilityAnalyzerOrganizationSharing } } -type awsEc2query_deserializeOpEnableRouteServerPropagation struct { +type awsEc2query_deserializeOpEnableIpamOrganizationAdminAccount struct { } -func (*awsEc2query_deserializeOpEnableRouteServerPropagation) ID() string { +func (*awsEc2query_deserializeOpEnableIpamOrganizationAdminAccount) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpEnableRouteServerPropagation) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpEnableIpamOrganizationAdminAccount) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -47122,9 +47502,9 @@ func (m *awsEc2query_deserializeOpEnableRouteServerPropagation) HandleDeserializ } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorEnableRouteServerPropagation(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorEnableIpamOrganizationAdminAccount(response, &metadata) } - output := &EnableRouteServerPropagationOutput{} + output := &EnableIpamOrganizationAdminAccountOutput{} out.Result = output var buff [1024]byte @@ -47145,7 +47525,7 @@ func (m *awsEc2query_deserializeOpEnableRouteServerPropagation) HandleDeserializ } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentEnableRouteServerPropagationOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentEnableIpamOrganizationAdminAccountOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -47159,7 +47539,7 @@ func (m *awsEc2query_deserializeOpEnableRouteServerPropagation) HandleDeserializ return out, metadata, err } -func awsEc2query_deserializeOpErrorEnableRouteServerPropagation(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorEnableIpamOrganizationAdminAccount(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -47192,14 +47572,14 @@ func awsEc2query_deserializeOpErrorEnableRouteServerPropagation(response *smithy } } -type awsEc2query_deserializeOpEnableSerialConsoleAccess struct { +type awsEc2query_deserializeOpEnableIpamPolicy struct { } -func (*awsEc2query_deserializeOpEnableSerialConsoleAccess) ID() string { +func (*awsEc2query_deserializeOpEnableIpamPolicy) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpEnableSerialConsoleAccess) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpEnableIpamPolicy) HandleDeserialize(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,9 +47597,9 @@ func (m *awsEc2query_deserializeOpEnableSerialConsoleAccess) HandleDeserialize(c } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorEnableSerialConsoleAccess(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorEnableIpamPolicy(response, &metadata) } - output := &EnableSerialConsoleAccessOutput{} + output := &EnableIpamPolicyOutput{} out.Result = output var buff [1024]byte @@ -47240,7 +47620,7 @@ func (m *awsEc2query_deserializeOpEnableSerialConsoleAccess) HandleDeserialize(c } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentEnableSerialConsoleAccessOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentEnableIpamPolicyOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -47254,7 +47634,7 @@ func (m *awsEc2query_deserializeOpEnableSerialConsoleAccess) HandleDeserialize(c return out, metadata, err } -func awsEc2query_deserializeOpErrorEnableSerialConsoleAccess(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorEnableIpamPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -47287,14 +47667,14 @@ func awsEc2query_deserializeOpErrorEnableSerialConsoleAccess(response *smithyhtt } } -type awsEc2query_deserializeOpEnableSnapshotBlockPublicAccess struct { +type awsEc2query_deserializeOpEnableReachabilityAnalyzerOrganizationSharing struct { } -func (*awsEc2query_deserializeOpEnableSnapshotBlockPublicAccess) ID() string { +func (*awsEc2query_deserializeOpEnableReachabilityAnalyzerOrganizationSharing) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpEnableSnapshotBlockPublicAccess) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpEnableReachabilityAnalyzerOrganizationSharing) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -47312,9 +47692,9 @@ func (m *awsEc2query_deserializeOpEnableSnapshotBlockPublicAccess) HandleDeseria } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorEnableSnapshotBlockPublicAccess(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorEnableReachabilityAnalyzerOrganizationSharing(response, &metadata) } - output := &EnableSnapshotBlockPublicAccessOutput{} + output := &EnableReachabilityAnalyzerOrganizationSharingOutput{} out.Result = output var buff [1024]byte @@ -47335,7 +47715,7 @@ func (m *awsEc2query_deserializeOpEnableSnapshotBlockPublicAccess) HandleDeseria } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentEnableSnapshotBlockPublicAccessOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentEnableReachabilityAnalyzerOrganizationSharingOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -47349,7 +47729,7 @@ func (m *awsEc2query_deserializeOpEnableSnapshotBlockPublicAccess) HandleDeseria return out, metadata, err } -func awsEc2query_deserializeOpErrorEnableSnapshotBlockPublicAccess(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorEnableReachabilityAnalyzerOrganizationSharing(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -47382,14 +47762,14 @@ func awsEc2query_deserializeOpErrorEnableSnapshotBlockPublicAccess(response *smi } } -type awsEc2query_deserializeOpEnableTransitGatewayRouteTablePropagation struct { +type awsEc2query_deserializeOpEnableRouteServerPropagation struct { } -func (*awsEc2query_deserializeOpEnableTransitGatewayRouteTablePropagation) ID() string { +func (*awsEc2query_deserializeOpEnableRouteServerPropagation) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpEnableTransitGatewayRouteTablePropagation) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpEnableRouteServerPropagation) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -47407,9 +47787,9 @@ func (m *awsEc2query_deserializeOpEnableTransitGatewayRouteTablePropagation) Han } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorEnableTransitGatewayRouteTablePropagation(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorEnableRouteServerPropagation(response, &metadata) } - output := &EnableTransitGatewayRouteTablePropagationOutput{} + output := &EnableRouteServerPropagationOutput{} out.Result = output var buff [1024]byte @@ -47430,7 +47810,7 @@ func (m *awsEc2query_deserializeOpEnableTransitGatewayRouteTablePropagation) Han } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentEnableTransitGatewayRouteTablePropagationOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentEnableRouteServerPropagationOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -47444,7 +47824,7 @@ func (m *awsEc2query_deserializeOpEnableTransitGatewayRouteTablePropagation) Han return out, metadata, err } -func awsEc2query_deserializeOpErrorEnableTransitGatewayRouteTablePropagation(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorEnableRouteServerPropagation(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -47477,14 +47857,14 @@ func awsEc2query_deserializeOpErrorEnableTransitGatewayRouteTablePropagation(res } } -type awsEc2query_deserializeOpEnableVgwRoutePropagation struct { +type awsEc2query_deserializeOpEnableSerialConsoleAccess struct { } -func (*awsEc2query_deserializeOpEnableVgwRoutePropagation) ID() string { +func (*awsEc2query_deserializeOpEnableSerialConsoleAccess) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpEnableVgwRoutePropagation) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpEnableSerialConsoleAccess) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -47502,21 +47882,44 @@ func (m *awsEc2query_deserializeOpEnableVgwRoutePropagation) HandleDeserialize(c } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorEnableVgwRoutePropagation(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorEnableSerialConsoleAccess(response, &metadata) } - output := &EnableVgwRoutePropagationOutput{} + output := &EnableSerialConsoleAccessOutput{} 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_deserializeOpDocumentEnableSerialConsoleAccessOutput(&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_deserializeOpErrorEnableVgwRoutePropagation(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorEnableSerialConsoleAccess(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -47549,14 +47952,14 @@ func awsEc2query_deserializeOpErrorEnableVgwRoutePropagation(response *smithyhtt } } -type awsEc2query_deserializeOpEnableVolumeIO struct { +type awsEc2query_deserializeOpEnableSnapshotBlockPublicAccess struct { } -func (*awsEc2query_deserializeOpEnableVolumeIO) ID() string { +func (*awsEc2query_deserializeOpEnableSnapshotBlockPublicAccess) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpEnableVolumeIO) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpEnableSnapshotBlockPublicAccess) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -47574,21 +47977,44 @@ func (m *awsEc2query_deserializeOpEnableVolumeIO) HandleDeserialize(ctx context. } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorEnableVolumeIO(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorEnableSnapshotBlockPublicAccess(response, &metadata) } - output := &EnableVolumeIOOutput{} + output := &EnableSnapshotBlockPublicAccessOutput{} 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_deserializeOpDocumentEnableSnapshotBlockPublicAccessOutput(&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_deserializeOpErrorEnableVolumeIO(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorEnableSnapshotBlockPublicAccess(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -47621,14 +48047,14 @@ func awsEc2query_deserializeOpErrorEnableVolumeIO(response *smithyhttp.Response, } } -type awsEc2query_deserializeOpEnableVpcClassicLink struct { +type awsEc2query_deserializeOpEnableTransitGatewayRouteTablePropagation struct { } -func (*awsEc2query_deserializeOpEnableVpcClassicLink) ID() string { +func (*awsEc2query_deserializeOpEnableTransitGatewayRouteTablePropagation) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpEnableVpcClassicLink) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpEnableTransitGatewayRouteTablePropagation) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -47646,9 +48072,9 @@ func (m *awsEc2query_deserializeOpEnableVpcClassicLink) HandleDeserialize(ctx co } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorEnableVpcClassicLink(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorEnableTransitGatewayRouteTablePropagation(response, &metadata) } - output := &EnableVpcClassicLinkOutput{} + output := &EnableTransitGatewayRouteTablePropagationOutput{} out.Result = output var buff [1024]byte @@ -47669,7 +48095,7 @@ func (m *awsEc2query_deserializeOpEnableVpcClassicLink) HandleDeserialize(ctx co } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentEnableVpcClassicLinkOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentEnableTransitGatewayRouteTablePropagationOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -47683,7 +48109,7 @@ func (m *awsEc2query_deserializeOpEnableVpcClassicLink) HandleDeserialize(ctx co return out, metadata, err } -func awsEc2query_deserializeOpErrorEnableVpcClassicLink(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorEnableTransitGatewayRouteTablePropagation(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -47716,14 +48142,14 @@ func awsEc2query_deserializeOpErrorEnableVpcClassicLink(response *smithyhttp.Res } } -type awsEc2query_deserializeOpEnableVpcClassicLinkDnsSupport struct { +type awsEc2query_deserializeOpEnableVgwRoutePropagation struct { } -func (*awsEc2query_deserializeOpEnableVpcClassicLinkDnsSupport) ID() string { +func (*awsEc2query_deserializeOpEnableVgwRoutePropagation) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpEnableVpcClassicLinkDnsSupport) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpEnableVgwRoutePropagation) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -47741,44 +48167,21 @@ func (m *awsEc2query_deserializeOpEnableVpcClassicLinkDnsSupport) HandleDeserial } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorEnableVpcClassicLinkDnsSupport(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorEnableVgwRoutePropagation(response, &metadata) } - output := &EnableVpcClassicLinkDnsSupportOutput{} + output := &EnableVgwRoutePropagationOutput{} 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_deserializeOpDocumentEnableVpcClassicLinkDnsSupportOutput(&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_deserializeOpErrorEnableVpcClassicLinkDnsSupport(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorEnableVgwRoutePropagation(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -47811,14 +48214,14 @@ func awsEc2query_deserializeOpErrorEnableVpcClassicLinkDnsSupport(response *smit } } -type awsEc2query_deserializeOpExportClientVpnClientCertificateRevocationList struct { +type awsEc2query_deserializeOpEnableVolumeIO struct { } -func (*awsEc2query_deserializeOpExportClientVpnClientCertificateRevocationList) ID() string { +func (*awsEc2query_deserializeOpEnableVolumeIO) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpExportClientVpnClientCertificateRevocationList) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpEnableVolumeIO) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -47836,44 +48239,21 @@ func (m *awsEc2query_deserializeOpExportClientVpnClientCertificateRevocationList } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorExportClientVpnClientCertificateRevocationList(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorEnableVolumeIO(response, &metadata) } - output := &ExportClientVpnClientCertificateRevocationListOutput{} + output := &EnableVolumeIOOutput{} 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_deserializeOpDocumentExportClientVpnClientCertificateRevocationListOutput(&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_deserializeOpErrorExportClientVpnClientCertificateRevocationList(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorEnableVolumeIO(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -47906,14 +48286,14 @@ func awsEc2query_deserializeOpErrorExportClientVpnClientCertificateRevocationLis } } -type awsEc2query_deserializeOpExportClientVpnClientConfiguration struct { +type awsEc2query_deserializeOpEnableVpcClassicLink struct { } -func (*awsEc2query_deserializeOpExportClientVpnClientConfiguration) ID() string { +func (*awsEc2query_deserializeOpEnableVpcClassicLink) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpExportClientVpnClientConfiguration) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpEnableVpcClassicLink) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -47931,9 +48311,9 @@ func (m *awsEc2query_deserializeOpExportClientVpnClientConfiguration) HandleDese } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorExportClientVpnClientConfiguration(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorEnableVpcClassicLink(response, &metadata) } - output := &ExportClientVpnClientConfigurationOutput{} + output := &EnableVpcClassicLinkOutput{} out.Result = output var buff [1024]byte @@ -47954,7 +48334,7 @@ func (m *awsEc2query_deserializeOpExportClientVpnClientConfiguration) HandleDese } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentExportClientVpnClientConfigurationOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentEnableVpcClassicLinkOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -47968,7 +48348,7 @@ func (m *awsEc2query_deserializeOpExportClientVpnClientConfiguration) HandleDese return out, metadata, err } -func awsEc2query_deserializeOpErrorExportClientVpnClientConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorEnableVpcClassicLink(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -48001,14 +48381,14 @@ func awsEc2query_deserializeOpErrorExportClientVpnClientConfiguration(response * } } -type awsEc2query_deserializeOpExportImage struct { +type awsEc2query_deserializeOpEnableVpcClassicLinkDnsSupport struct { } -func (*awsEc2query_deserializeOpExportImage) ID() string { +func (*awsEc2query_deserializeOpEnableVpcClassicLinkDnsSupport) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpExportImage) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpEnableVpcClassicLinkDnsSupport) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -48026,9 +48406,9 @@ func (m *awsEc2query_deserializeOpExportImage) HandleDeserialize(ctx context.Con } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorExportImage(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorEnableVpcClassicLinkDnsSupport(response, &metadata) } - output := &ExportImageOutput{} + output := &EnableVpcClassicLinkDnsSupportOutput{} out.Result = output var buff [1024]byte @@ -48049,7 +48429,7 @@ func (m *awsEc2query_deserializeOpExportImage) HandleDeserialize(ctx context.Con } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentExportImageOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentEnableVpcClassicLinkDnsSupportOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -48063,7 +48443,7 @@ func (m *awsEc2query_deserializeOpExportImage) HandleDeserialize(ctx context.Con return out, metadata, err } -func awsEc2query_deserializeOpErrorExportImage(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorEnableVpcClassicLinkDnsSupport(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -48096,14 +48476,14 @@ func awsEc2query_deserializeOpErrorExportImage(response *smithyhttp.Response, me } } -type awsEc2query_deserializeOpExportTransitGatewayRoutes struct { +type awsEc2query_deserializeOpExportClientVpnClientCertificateRevocationList struct { } -func (*awsEc2query_deserializeOpExportTransitGatewayRoutes) ID() string { +func (*awsEc2query_deserializeOpExportClientVpnClientCertificateRevocationList) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpExportTransitGatewayRoutes) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpExportClientVpnClientCertificateRevocationList) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -48121,9 +48501,9 @@ func (m *awsEc2query_deserializeOpExportTransitGatewayRoutes) HandleDeserialize( } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorExportTransitGatewayRoutes(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorExportClientVpnClientCertificateRevocationList(response, &metadata) } - output := &ExportTransitGatewayRoutesOutput{} + output := &ExportClientVpnClientCertificateRevocationListOutput{} out.Result = output var buff [1024]byte @@ -48144,7 +48524,7 @@ func (m *awsEc2query_deserializeOpExportTransitGatewayRoutes) HandleDeserialize( } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentExportTransitGatewayRoutesOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentExportClientVpnClientCertificateRevocationListOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -48158,7 +48538,7 @@ func (m *awsEc2query_deserializeOpExportTransitGatewayRoutes) HandleDeserialize( return out, metadata, err } -func awsEc2query_deserializeOpErrorExportTransitGatewayRoutes(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorExportClientVpnClientCertificateRevocationList(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -48191,14 +48571,14 @@ func awsEc2query_deserializeOpErrorExportTransitGatewayRoutes(response *smithyht } } -type awsEc2query_deserializeOpExportVerifiedAccessInstanceClientConfiguration struct { +type awsEc2query_deserializeOpExportClientVpnClientConfiguration struct { } -func (*awsEc2query_deserializeOpExportVerifiedAccessInstanceClientConfiguration) ID() string { +func (*awsEc2query_deserializeOpExportClientVpnClientConfiguration) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpExportVerifiedAccessInstanceClientConfiguration) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpExportClientVpnClientConfiguration) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -48216,9 +48596,9 @@ func (m *awsEc2query_deserializeOpExportVerifiedAccessInstanceClientConfiguratio } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorExportVerifiedAccessInstanceClientConfiguration(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorExportClientVpnClientConfiguration(response, &metadata) } - output := &ExportVerifiedAccessInstanceClientConfigurationOutput{} + output := &ExportClientVpnClientConfigurationOutput{} out.Result = output var buff [1024]byte @@ -48239,7 +48619,7 @@ func (m *awsEc2query_deserializeOpExportVerifiedAccessInstanceClientConfiguratio } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentExportVerifiedAccessInstanceClientConfigurationOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentExportClientVpnClientConfigurationOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -48253,7 +48633,7 @@ func (m *awsEc2query_deserializeOpExportVerifiedAccessInstanceClientConfiguratio return out, metadata, err } -func awsEc2query_deserializeOpErrorExportVerifiedAccessInstanceClientConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorExportClientVpnClientConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -48286,14 +48666,14 @@ func awsEc2query_deserializeOpErrorExportVerifiedAccessInstanceClientConfigurati } } -type awsEc2query_deserializeOpGetActiveVpnTunnelStatus struct { +type awsEc2query_deserializeOpExportImage struct { } -func (*awsEc2query_deserializeOpGetActiveVpnTunnelStatus) ID() string { +func (*awsEc2query_deserializeOpExportImage) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpGetActiveVpnTunnelStatus) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpExportImage) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -48311,9 +48691,9 @@ func (m *awsEc2query_deserializeOpGetActiveVpnTunnelStatus) HandleDeserialize(ct } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorGetActiveVpnTunnelStatus(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorExportImage(response, &metadata) } - output := &GetActiveVpnTunnelStatusOutput{} + output := &ExportImageOutput{} out.Result = output var buff [1024]byte @@ -48334,7 +48714,7 @@ func (m *awsEc2query_deserializeOpGetActiveVpnTunnelStatus) HandleDeserialize(ct } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentGetActiveVpnTunnelStatusOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentExportImageOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -48348,7 +48728,7 @@ func (m *awsEc2query_deserializeOpGetActiveVpnTunnelStatus) HandleDeserialize(ct return out, metadata, err } -func awsEc2query_deserializeOpErrorGetActiveVpnTunnelStatus(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorExportImage(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -48381,14 +48761,14 @@ func awsEc2query_deserializeOpErrorGetActiveVpnTunnelStatus(response *smithyhttp } } -type awsEc2query_deserializeOpGetAllowedImagesSettings struct { +type awsEc2query_deserializeOpExportTransitGatewayRoutes struct { } -func (*awsEc2query_deserializeOpGetAllowedImagesSettings) ID() string { +func (*awsEc2query_deserializeOpExportTransitGatewayRoutes) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpGetAllowedImagesSettings) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpExportTransitGatewayRoutes) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -48406,9 +48786,9 @@ func (m *awsEc2query_deserializeOpGetAllowedImagesSettings) HandleDeserialize(ct } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorGetAllowedImagesSettings(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorExportTransitGatewayRoutes(response, &metadata) } - output := &GetAllowedImagesSettingsOutput{} + output := &ExportTransitGatewayRoutesOutput{} out.Result = output var buff [1024]byte @@ -48429,7 +48809,7 @@ func (m *awsEc2query_deserializeOpGetAllowedImagesSettings) HandleDeserialize(ct } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentGetAllowedImagesSettingsOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentExportTransitGatewayRoutesOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -48443,7 +48823,7 @@ func (m *awsEc2query_deserializeOpGetAllowedImagesSettings) HandleDeserialize(ct return out, metadata, err } -func awsEc2query_deserializeOpErrorGetAllowedImagesSettings(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorExportTransitGatewayRoutes(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -48476,14 +48856,14 @@ func awsEc2query_deserializeOpErrorGetAllowedImagesSettings(response *smithyhttp } } -type awsEc2query_deserializeOpGetAssociatedEnclaveCertificateIamRoles struct { +type awsEc2query_deserializeOpExportVerifiedAccessInstanceClientConfiguration struct { } -func (*awsEc2query_deserializeOpGetAssociatedEnclaveCertificateIamRoles) ID() string { +func (*awsEc2query_deserializeOpExportVerifiedAccessInstanceClientConfiguration) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpGetAssociatedEnclaveCertificateIamRoles) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpExportVerifiedAccessInstanceClientConfiguration) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -48501,9 +48881,9 @@ func (m *awsEc2query_deserializeOpGetAssociatedEnclaveCertificateIamRoles) Handl } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorGetAssociatedEnclaveCertificateIamRoles(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorExportVerifiedAccessInstanceClientConfiguration(response, &metadata) } - output := &GetAssociatedEnclaveCertificateIamRolesOutput{} + output := &ExportVerifiedAccessInstanceClientConfigurationOutput{} out.Result = output var buff [1024]byte @@ -48524,7 +48904,7 @@ func (m *awsEc2query_deserializeOpGetAssociatedEnclaveCertificateIamRoles) Handl } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentGetAssociatedEnclaveCertificateIamRolesOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentExportVerifiedAccessInstanceClientConfigurationOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -48538,7 +48918,7 @@ func (m *awsEc2query_deserializeOpGetAssociatedEnclaveCertificateIamRoles) Handl return out, metadata, err } -func awsEc2query_deserializeOpErrorGetAssociatedEnclaveCertificateIamRoles(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorExportVerifiedAccessInstanceClientConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -48571,14 +48951,14 @@ func awsEc2query_deserializeOpErrorGetAssociatedEnclaveCertificateIamRoles(respo } } -type awsEc2query_deserializeOpGetAssociatedIpv6PoolCidrs struct { +type awsEc2query_deserializeOpGetActiveVpnTunnelStatus struct { } -func (*awsEc2query_deserializeOpGetAssociatedIpv6PoolCidrs) ID() string { +func (*awsEc2query_deserializeOpGetActiveVpnTunnelStatus) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpGetAssociatedIpv6PoolCidrs) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpGetActiveVpnTunnelStatus) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -48596,9 +48976,9 @@ func (m *awsEc2query_deserializeOpGetAssociatedIpv6PoolCidrs) HandleDeserialize( } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorGetAssociatedIpv6PoolCidrs(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorGetActiveVpnTunnelStatus(response, &metadata) } - output := &GetAssociatedIpv6PoolCidrsOutput{} + output := &GetActiveVpnTunnelStatusOutput{} out.Result = output var buff [1024]byte @@ -48619,7 +48999,7 @@ func (m *awsEc2query_deserializeOpGetAssociatedIpv6PoolCidrs) HandleDeserialize( } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentGetAssociatedIpv6PoolCidrsOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentGetActiveVpnTunnelStatusOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -48633,7 +49013,7 @@ func (m *awsEc2query_deserializeOpGetAssociatedIpv6PoolCidrs) HandleDeserialize( return out, metadata, err } -func awsEc2query_deserializeOpErrorGetAssociatedIpv6PoolCidrs(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorGetActiveVpnTunnelStatus(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -48666,14 +49046,14 @@ func awsEc2query_deserializeOpErrorGetAssociatedIpv6PoolCidrs(response *smithyht } } -type awsEc2query_deserializeOpGetAwsNetworkPerformanceData struct { +type awsEc2query_deserializeOpGetAllowedImagesSettings struct { } -func (*awsEc2query_deserializeOpGetAwsNetworkPerformanceData) ID() string { +func (*awsEc2query_deserializeOpGetAllowedImagesSettings) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpGetAwsNetworkPerformanceData) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpGetAllowedImagesSettings) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -48691,9 +49071,9 @@ func (m *awsEc2query_deserializeOpGetAwsNetworkPerformanceData) HandleDeserializ } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorGetAwsNetworkPerformanceData(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorGetAllowedImagesSettings(response, &metadata) } - output := &GetAwsNetworkPerformanceDataOutput{} + output := &GetAllowedImagesSettingsOutput{} out.Result = output var buff [1024]byte @@ -48714,7 +49094,7 @@ func (m *awsEc2query_deserializeOpGetAwsNetworkPerformanceData) HandleDeserializ } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentGetAwsNetworkPerformanceDataOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentGetAllowedImagesSettingsOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -48728,7 +49108,7 @@ func (m *awsEc2query_deserializeOpGetAwsNetworkPerformanceData) HandleDeserializ return out, metadata, err } -func awsEc2query_deserializeOpErrorGetAwsNetworkPerformanceData(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorGetAllowedImagesSettings(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -48761,14 +49141,14 @@ func awsEc2query_deserializeOpErrorGetAwsNetworkPerformanceData(response *smithy } } -type awsEc2query_deserializeOpGetCapacityManagerAttributes struct { +type awsEc2query_deserializeOpGetAssociatedEnclaveCertificateIamRoles struct { } -func (*awsEc2query_deserializeOpGetCapacityManagerAttributes) ID() string { +func (*awsEc2query_deserializeOpGetAssociatedEnclaveCertificateIamRoles) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpGetCapacityManagerAttributes) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpGetAssociatedEnclaveCertificateIamRoles) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -48786,9 +49166,9 @@ func (m *awsEc2query_deserializeOpGetCapacityManagerAttributes) HandleDeserializ } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorGetCapacityManagerAttributes(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorGetAssociatedEnclaveCertificateIamRoles(response, &metadata) } - output := &GetCapacityManagerAttributesOutput{} + output := &GetAssociatedEnclaveCertificateIamRolesOutput{} out.Result = output var buff [1024]byte @@ -48809,7 +49189,7 @@ func (m *awsEc2query_deserializeOpGetCapacityManagerAttributes) HandleDeserializ } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentGetCapacityManagerAttributesOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentGetAssociatedEnclaveCertificateIamRolesOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -48823,7 +49203,7 @@ func (m *awsEc2query_deserializeOpGetCapacityManagerAttributes) HandleDeserializ return out, metadata, err } -func awsEc2query_deserializeOpErrorGetCapacityManagerAttributes(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorGetAssociatedEnclaveCertificateIamRoles(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -48856,14 +49236,14 @@ func awsEc2query_deserializeOpErrorGetCapacityManagerAttributes(response *smithy } } -type awsEc2query_deserializeOpGetCapacityManagerMetricData struct { +type awsEc2query_deserializeOpGetAssociatedIpv6PoolCidrs struct { } -func (*awsEc2query_deserializeOpGetCapacityManagerMetricData) ID() string { +func (*awsEc2query_deserializeOpGetAssociatedIpv6PoolCidrs) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpGetCapacityManagerMetricData) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpGetAssociatedIpv6PoolCidrs) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -48881,9 +49261,9 @@ func (m *awsEc2query_deserializeOpGetCapacityManagerMetricData) HandleDeserializ } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorGetCapacityManagerMetricData(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorGetAssociatedIpv6PoolCidrs(response, &metadata) } - output := &GetCapacityManagerMetricDataOutput{} + output := &GetAssociatedIpv6PoolCidrsOutput{} out.Result = output var buff [1024]byte @@ -48904,7 +49284,7 @@ func (m *awsEc2query_deserializeOpGetCapacityManagerMetricData) HandleDeserializ } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentGetCapacityManagerMetricDataOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentGetAssociatedIpv6PoolCidrsOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -48918,7 +49298,7 @@ func (m *awsEc2query_deserializeOpGetCapacityManagerMetricData) HandleDeserializ return out, metadata, err } -func awsEc2query_deserializeOpErrorGetCapacityManagerMetricData(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorGetAssociatedIpv6PoolCidrs(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -48951,14 +49331,14 @@ func awsEc2query_deserializeOpErrorGetCapacityManagerMetricData(response *smithy } } -type awsEc2query_deserializeOpGetCapacityManagerMetricDimensions struct { +type awsEc2query_deserializeOpGetAwsNetworkPerformanceData struct { } -func (*awsEc2query_deserializeOpGetCapacityManagerMetricDimensions) ID() string { +func (*awsEc2query_deserializeOpGetAwsNetworkPerformanceData) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpGetCapacityManagerMetricDimensions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpGetAwsNetworkPerformanceData) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -48976,9 +49356,9 @@ func (m *awsEc2query_deserializeOpGetCapacityManagerMetricDimensions) HandleDese } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorGetCapacityManagerMetricDimensions(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorGetAwsNetworkPerformanceData(response, &metadata) } - output := &GetCapacityManagerMetricDimensionsOutput{} + output := &GetAwsNetworkPerformanceDataOutput{} out.Result = output var buff [1024]byte @@ -48999,7 +49379,7 @@ func (m *awsEc2query_deserializeOpGetCapacityManagerMetricDimensions) HandleDese } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentGetCapacityManagerMetricDimensionsOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentGetAwsNetworkPerformanceDataOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -49013,7 +49393,7 @@ func (m *awsEc2query_deserializeOpGetCapacityManagerMetricDimensions) HandleDese return out, metadata, err } -func awsEc2query_deserializeOpErrorGetCapacityManagerMetricDimensions(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorGetAwsNetworkPerformanceData(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -49046,14 +49426,14 @@ func awsEc2query_deserializeOpErrorGetCapacityManagerMetricDimensions(response * } } -type awsEc2query_deserializeOpGetCapacityReservationUsage struct { +type awsEc2query_deserializeOpGetCapacityManagerAttributes struct { } -func (*awsEc2query_deserializeOpGetCapacityReservationUsage) ID() string { +func (*awsEc2query_deserializeOpGetCapacityManagerAttributes) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpGetCapacityReservationUsage) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpGetCapacityManagerAttributes) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -49071,9 +49451,9 @@ func (m *awsEc2query_deserializeOpGetCapacityReservationUsage) HandleDeserialize } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorGetCapacityReservationUsage(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorGetCapacityManagerAttributes(response, &metadata) } - output := &GetCapacityReservationUsageOutput{} + output := &GetCapacityManagerAttributesOutput{} out.Result = output var buff [1024]byte @@ -49094,7 +49474,7 @@ func (m *awsEc2query_deserializeOpGetCapacityReservationUsage) HandleDeserialize } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentGetCapacityReservationUsageOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentGetCapacityManagerAttributesOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -49108,7 +49488,7 @@ func (m *awsEc2query_deserializeOpGetCapacityReservationUsage) HandleDeserialize return out, metadata, err } -func awsEc2query_deserializeOpErrorGetCapacityReservationUsage(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorGetCapacityManagerAttributes(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -49141,14 +49521,14 @@ func awsEc2query_deserializeOpErrorGetCapacityReservationUsage(response *smithyh } } -type awsEc2query_deserializeOpGetCoipPoolUsage struct { +type awsEc2query_deserializeOpGetCapacityManagerMetricData struct { } -func (*awsEc2query_deserializeOpGetCoipPoolUsage) ID() string { +func (*awsEc2query_deserializeOpGetCapacityManagerMetricData) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpGetCoipPoolUsage) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpGetCapacityManagerMetricData) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -49166,9 +49546,9 @@ func (m *awsEc2query_deserializeOpGetCoipPoolUsage) HandleDeserialize(ctx contex } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorGetCoipPoolUsage(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorGetCapacityManagerMetricData(response, &metadata) } - output := &GetCoipPoolUsageOutput{} + output := &GetCapacityManagerMetricDataOutput{} out.Result = output var buff [1024]byte @@ -49189,7 +49569,7 @@ func (m *awsEc2query_deserializeOpGetCoipPoolUsage) HandleDeserialize(ctx contex } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentGetCoipPoolUsageOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentGetCapacityManagerMetricDataOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -49203,7 +49583,7 @@ func (m *awsEc2query_deserializeOpGetCoipPoolUsage) HandleDeserialize(ctx contex return out, metadata, err } -func awsEc2query_deserializeOpErrorGetCoipPoolUsage(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorGetCapacityManagerMetricData(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -49236,14 +49616,14 @@ func awsEc2query_deserializeOpErrorGetCoipPoolUsage(response *smithyhttp.Respons } } -type awsEc2query_deserializeOpGetConsoleOutput struct { +type awsEc2query_deserializeOpGetCapacityManagerMetricDimensions struct { } -func (*awsEc2query_deserializeOpGetConsoleOutput) ID() string { +func (*awsEc2query_deserializeOpGetCapacityManagerMetricDimensions) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpGetConsoleOutput) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpGetCapacityManagerMetricDimensions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -49261,9 +49641,9 @@ func (m *awsEc2query_deserializeOpGetConsoleOutput) HandleDeserialize(ctx contex } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorGetConsoleOutput(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorGetCapacityManagerMetricDimensions(response, &metadata) } - output := &GetConsoleOutputOutput{} + output := &GetCapacityManagerMetricDimensionsOutput{} out.Result = output var buff [1024]byte @@ -49284,7 +49664,7 @@ func (m *awsEc2query_deserializeOpGetConsoleOutput) HandleDeserialize(ctx contex } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentGetConsoleOutputOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentGetCapacityManagerMetricDimensionsOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -49298,7 +49678,7 @@ func (m *awsEc2query_deserializeOpGetConsoleOutput) HandleDeserialize(ctx contex return out, metadata, err } -func awsEc2query_deserializeOpErrorGetConsoleOutput(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorGetCapacityManagerMetricDimensions(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -49331,14 +49711,14 @@ func awsEc2query_deserializeOpErrorGetConsoleOutput(response *smithyhttp.Respons } } -type awsEc2query_deserializeOpGetConsoleScreenshot struct { +type awsEc2query_deserializeOpGetCapacityReservationUsage struct { } -func (*awsEc2query_deserializeOpGetConsoleScreenshot) ID() string { +func (*awsEc2query_deserializeOpGetCapacityReservationUsage) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpGetConsoleScreenshot) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpGetCapacityReservationUsage) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -49356,9 +49736,9 @@ func (m *awsEc2query_deserializeOpGetConsoleScreenshot) HandleDeserialize(ctx co } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorGetConsoleScreenshot(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorGetCapacityReservationUsage(response, &metadata) } - output := &GetConsoleScreenshotOutput{} + output := &GetCapacityReservationUsageOutput{} out.Result = output var buff [1024]byte @@ -49379,7 +49759,7 @@ func (m *awsEc2query_deserializeOpGetConsoleScreenshot) HandleDeserialize(ctx co } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentGetConsoleScreenshotOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentGetCapacityReservationUsageOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -49393,7 +49773,7 @@ func (m *awsEc2query_deserializeOpGetConsoleScreenshot) HandleDeserialize(ctx co return out, metadata, err } -func awsEc2query_deserializeOpErrorGetConsoleScreenshot(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorGetCapacityReservationUsage(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -49426,14 +49806,14 @@ func awsEc2query_deserializeOpErrorGetConsoleScreenshot(response *smithyhttp.Res } } -type awsEc2query_deserializeOpGetDeclarativePoliciesReportSummary struct { +type awsEc2query_deserializeOpGetCoipPoolUsage struct { } -func (*awsEc2query_deserializeOpGetDeclarativePoliciesReportSummary) ID() string { +func (*awsEc2query_deserializeOpGetCoipPoolUsage) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpGetDeclarativePoliciesReportSummary) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpGetCoipPoolUsage) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -49451,9 +49831,9 @@ func (m *awsEc2query_deserializeOpGetDeclarativePoliciesReportSummary) HandleDes } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorGetDeclarativePoliciesReportSummary(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorGetCoipPoolUsage(response, &metadata) } - output := &GetDeclarativePoliciesReportSummaryOutput{} + output := &GetCoipPoolUsageOutput{} out.Result = output var buff [1024]byte @@ -49474,7 +49854,7 @@ func (m *awsEc2query_deserializeOpGetDeclarativePoliciesReportSummary) HandleDes } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentGetDeclarativePoliciesReportSummaryOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentGetCoipPoolUsageOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -49488,7 +49868,7 @@ func (m *awsEc2query_deserializeOpGetDeclarativePoliciesReportSummary) HandleDes return out, metadata, err } -func awsEc2query_deserializeOpErrorGetDeclarativePoliciesReportSummary(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorGetCoipPoolUsage(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -49521,14 +49901,14 @@ func awsEc2query_deserializeOpErrorGetDeclarativePoliciesReportSummary(response } } -type awsEc2query_deserializeOpGetDefaultCreditSpecification struct { +type awsEc2query_deserializeOpGetConsoleOutput struct { } -func (*awsEc2query_deserializeOpGetDefaultCreditSpecification) ID() string { +func (*awsEc2query_deserializeOpGetConsoleOutput) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpGetDefaultCreditSpecification) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpGetConsoleOutput) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -49546,9 +49926,9 @@ func (m *awsEc2query_deserializeOpGetDefaultCreditSpecification) HandleDeseriali } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorGetDefaultCreditSpecification(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorGetConsoleOutput(response, &metadata) } - output := &GetDefaultCreditSpecificationOutput{} + output := &GetConsoleOutputOutput{} out.Result = output var buff [1024]byte @@ -49569,7 +49949,7 @@ func (m *awsEc2query_deserializeOpGetDefaultCreditSpecification) HandleDeseriali } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentGetDefaultCreditSpecificationOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentGetConsoleOutputOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -49583,7 +49963,7 @@ func (m *awsEc2query_deserializeOpGetDefaultCreditSpecification) HandleDeseriali return out, metadata, err } -func awsEc2query_deserializeOpErrorGetDefaultCreditSpecification(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorGetConsoleOutput(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -49616,14 +49996,14 @@ func awsEc2query_deserializeOpErrorGetDefaultCreditSpecification(response *smith } } -type awsEc2query_deserializeOpGetEbsDefaultKmsKeyId struct { +type awsEc2query_deserializeOpGetConsoleScreenshot struct { } -func (*awsEc2query_deserializeOpGetEbsDefaultKmsKeyId) ID() string { +func (*awsEc2query_deserializeOpGetConsoleScreenshot) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpGetEbsDefaultKmsKeyId) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpGetConsoleScreenshot) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -49641,9 +50021,9 @@ func (m *awsEc2query_deserializeOpGetEbsDefaultKmsKeyId) HandleDeserialize(ctx c } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorGetEbsDefaultKmsKeyId(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorGetConsoleScreenshot(response, &metadata) } - output := &GetEbsDefaultKmsKeyIdOutput{} + output := &GetConsoleScreenshotOutput{} out.Result = output var buff [1024]byte @@ -49664,7 +50044,7 @@ func (m *awsEc2query_deserializeOpGetEbsDefaultKmsKeyId) HandleDeserialize(ctx c } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentGetEbsDefaultKmsKeyIdOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentGetConsoleScreenshotOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -49678,7 +50058,7 @@ func (m *awsEc2query_deserializeOpGetEbsDefaultKmsKeyId) HandleDeserialize(ctx c return out, metadata, err } -func awsEc2query_deserializeOpErrorGetEbsDefaultKmsKeyId(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorGetConsoleScreenshot(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -49711,14 +50091,14 @@ func awsEc2query_deserializeOpErrorGetEbsDefaultKmsKeyId(response *smithyhttp.Re } } -type awsEc2query_deserializeOpGetEbsEncryptionByDefault struct { +type awsEc2query_deserializeOpGetDeclarativePoliciesReportSummary struct { } -func (*awsEc2query_deserializeOpGetEbsEncryptionByDefault) ID() string { +func (*awsEc2query_deserializeOpGetDeclarativePoliciesReportSummary) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpGetEbsEncryptionByDefault) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpGetDeclarativePoliciesReportSummary) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -49736,9 +50116,9 @@ func (m *awsEc2query_deserializeOpGetEbsEncryptionByDefault) HandleDeserialize(c } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorGetEbsEncryptionByDefault(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorGetDeclarativePoliciesReportSummary(response, &metadata) } - output := &GetEbsEncryptionByDefaultOutput{} + output := &GetDeclarativePoliciesReportSummaryOutput{} out.Result = output var buff [1024]byte @@ -49759,7 +50139,7 @@ func (m *awsEc2query_deserializeOpGetEbsEncryptionByDefault) HandleDeserialize(c } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentGetEbsEncryptionByDefaultOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentGetDeclarativePoliciesReportSummaryOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -49773,7 +50153,7 @@ func (m *awsEc2query_deserializeOpGetEbsEncryptionByDefault) HandleDeserialize(c return out, metadata, err } -func awsEc2query_deserializeOpErrorGetEbsEncryptionByDefault(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorGetDeclarativePoliciesReportSummary(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -49806,14 +50186,14 @@ func awsEc2query_deserializeOpErrorGetEbsEncryptionByDefault(response *smithyhtt } } -type awsEc2query_deserializeOpGetEnabledIpamPolicy struct { +type awsEc2query_deserializeOpGetDefaultCreditSpecification struct { } -func (*awsEc2query_deserializeOpGetEnabledIpamPolicy) ID() string { +func (*awsEc2query_deserializeOpGetDefaultCreditSpecification) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpGetEnabledIpamPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpGetDefaultCreditSpecification) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -49831,9 +50211,9 @@ func (m *awsEc2query_deserializeOpGetEnabledIpamPolicy) HandleDeserialize(ctx co } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorGetEnabledIpamPolicy(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorGetDefaultCreditSpecification(response, &metadata) } - output := &GetEnabledIpamPolicyOutput{} + output := &GetDefaultCreditSpecificationOutput{} out.Result = output var buff [1024]byte @@ -49854,7 +50234,7 @@ func (m *awsEc2query_deserializeOpGetEnabledIpamPolicy) HandleDeserialize(ctx co } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentGetEnabledIpamPolicyOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentGetDefaultCreditSpecificationOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -49868,7 +50248,7 @@ func (m *awsEc2query_deserializeOpGetEnabledIpamPolicy) HandleDeserialize(ctx co return out, metadata, err } -func awsEc2query_deserializeOpErrorGetEnabledIpamPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorGetDefaultCreditSpecification(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -49901,14 +50281,14 @@ func awsEc2query_deserializeOpErrorGetEnabledIpamPolicy(response *smithyhttp.Res } } -type awsEc2query_deserializeOpGetFlowLogsIntegrationTemplate struct { +type awsEc2query_deserializeOpGetEbsDefaultKmsKeyId struct { } -func (*awsEc2query_deserializeOpGetFlowLogsIntegrationTemplate) ID() string { +func (*awsEc2query_deserializeOpGetEbsDefaultKmsKeyId) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpGetFlowLogsIntegrationTemplate) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpGetEbsDefaultKmsKeyId) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -49926,9 +50306,9 @@ func (m *awsEc2query_deserializeOpGetFlowLogsIntegrationTemplate) HandleDeserial } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorGetFlowLogsIntegrationTemplate(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorGetEbsDefaultKmsKeyId(response, &metadata) } - output := &GetFlowLogsIntegrationTemplateOutput{} + output := &GetEbsDefaultKmsKeyIdOutput{} out.Result = output var buff [1024]byte @@ -49949,7 +50329,7 @@ func (m *awsEc2query_deserializeOpGetFlowLogsIntegrationTemplate) HandleDeserial } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentGetFlowLogsIntegrationTemplateOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentGetEbsDefaultKmsKeyIdOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -49963,7 +50343,7 @@ func (m *awsEc2query_deserializeOpGetFlowLogsIntegrationTemplate) HandleDeserial return out, metadata, err } -func awsEc2query_deserializeOpErrorGetFlowLogsIntegrationTemplate(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorGetEbsDefaultKmsKeyId(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -49996,14 +50376,14 @@ func awsEc2query_deserializeOpErrorGetFlowLogsIntegrationTemplate(response *smit } } -type awsEc2query_deserializeOpGetGroupsForCapacityReservation struct { +type awsEc2query_deserializeOpGetEbsEncryptionByDefault struct { } -func (*awsEc2query_deserializeOpGetGroupsForCapacityReservation) ID() string { +func (*awsEc2query_deserializeOpGetEbsEncryptionByDefault) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpGetGroupsForCapacityReservation) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpGetEbsEncryptionByDefault) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -50021,9 +50401,9 @@ func (m *awsEc2query_deserializeOpGetGroupsForCapacityReservation) HandleDeseria } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorGetGroupsForCapacityReservation(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorGetEbsEncryptionByDefault(response, &metadata) } - output := &GetGroupsForCapacityReservationOutput{} + output := &GetEbsEncryptionByDefaultOutput{} out.Result = output var buff [1024]byte @@ -50044,7 +50424,7 @@ func (m *awsEc2query_deserializeOpGetGroupsForCapacityReservation) HandleDeseria } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentGetGroupsForCapacityReservationOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentGetEbsEncryptionByDefaultOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -50058,7 +50438,7 @@ func (m *awsEc2query_deserializeOpGetGroupsForCapacityReservation) HandleDeseria return out, metadata, err } -func awsEc2query_deserializeOpErrorGetGroupsForCapacityReservation(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorGetEbsEncryptionByDefault(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -50091,14 +50471,14 @@ func awsEc2query_deserializeOpErrorGetGroupsForCapacityReservation(response *smi } } -type awsEc2query_deserializeOpGetHostReservationPurchasePreview struct { +type awsEc2query_deserializeOpGetEnabledIpamPolicy struct { } -func (*awsEc2query_deserializeOpGetHostReservationPurchasePreview) ID() string { +func (*awsEc2query_deserializeOpGetEnabledIpamPolicy) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpGetHostReservationPurchasePreview) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpGetEnabledIpamPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -50116,9 +50496,9 @@ func (m *awsEc2query_deserializeOpGetHostReservationPurchasePreview) HandleDeser } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorGetHostReservationPurchasePreview(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorGetEnabledIpamPolicy(response, &metadata) } - output := &GetHostReservationPurchasePreviewOutput{} + output := &GetEnabledIpamPolicyOutput{} out.Result = output var buff [1024]byte @@ -50139,7 +50519,7 @@ func (m *awsEc2query_deserializeOpGetHostReservationPurchasePreview) HandleDeser } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentGetHostReservationPurchasePreviewOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentGetEnabledIpamPolicyOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -50153,7 +50533,7 @@ func (m *awsEc2query_deserializeOpGetHostReservationPurchasePreview) HandleDeser return out, metadata, err } -func awsEc2query_deserializeOpErrorGetHostReservationPurchasePreview(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorGetEnabledIpamPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -50186,14 +50566,14 @@ func awsEc2query_deserializeOpErrorGetHostReservationPurchasePreview(response *s } } -type awsEc2query_deserializeOpGetImageAncestry struct { +type awsEc2query_deserializeOpGetFlowLogsIntegrationTemplate struct { } -func (*awsEc2query_deserializeOpGetImageAncestry) ID() string { +func (*awsEc2query_deserializeOpGetFlowLogsIntegrationTemplate) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpGetImageAncestry) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpGetFlowLogsIntegrationTemplate) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -50211,9 +50591,9 @@ func (m *awsEc2query_deserializeOpGetImageAncestry) HandleDeserialize(ctx contex } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorGetImageAncestry(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorGetFlowLogsIntegrationTemplate(response, &metadata) } - output := &GetImageAncestryOutput{} + output := &GetFlowLogsIntegrationTemplateOutput{} out.Result = output var buff [1024]byte @@ -50234,7 +50614,7 @@ func (m *awsEc2query_deserializeOpGetImageAncestry) HandleDeserialize(ctx contex } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentGetImageAncestryOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentGetFlowLogsIntegrationTemplateOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -50248,7 +50628,7 @@ func (m *awsEc2query_deserializeOpGetImageAncestry) HandleDeserialize(ctx contex return out, metadata, err } -func awsEc2query_deserializeOpErrorGetImageAncestry(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorGetFlowLogsIntegrationTemplate(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -50281,14 +50661,14 @@ func awsEc2query_deserializeOpErrorGetImageAncestry(response *smithyhttp.Respons } } -type awsEc2query_deserializeOpGetImageBlockPublicAccessState struct { +type awsEc2query_deserializeOpGetGroupsForCapacityReservation struct { } -func (*awsEc2query_deserializeOpGetImageBlockPublicAccessState) ID() string { +func (*awsEc2query_deserializeOpGetGroupsForCapacityReservation) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpGetImageBlockPublicAccessState) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpGetGroupsForCapacityReservation) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -50306,9 +50686,9 @@ func (m *awsEc2query_deserializeOpGetImageBlockPublicAccessState) HandleDeserial } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorGetImageBlockPublicAccessState(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorGetGroupsForCapacityReservation(response, &metadata) } - output := &GetImageBlockPublicAccessStateOutput{} + output := &GetGroupsForCapacityReservationOutput{} out.Result = output var buff [1024]byte @@ -50329,7 +50709,7 @@ func (m *awsEc2query_deserializeOpGetImageBlockPublicAccessState) HandleDeserial } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentGetImageBlockPublicAccessStateOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentGetGroupsForCapacityReservationOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -50343,7 +50723,7 @@ func (m *awsEc2query_deserializeOpGetImageBlockPublicAccessState) HandleDeserial return out, metadata, err } -func awsEc2query_deserializeOpErrorGetImageBlockPublicAccessState(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorGetGroupsForCapacityReservation(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -50376,14 +50756,14 @@ func awsEc2query_deserializeOpErrorGetImageBlockPublicAccessState(response *smit } } -type awsEc2query_deserializeOpGetInstanceMetadataDefaults struct { +type awsEc2query_deserializeOpGetHostReservationPurchasePreview struct { } -func (*awsEc2query_deserializeOpGetInstanceMetadataDefaults) ID() string { +func (*awsEc2query_deserializeOpGetHostReservationPurchasePreview) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpGetInstanceMetadataDefaults) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpGetHostReservationPurchasePreview) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -50401,9 +50781,9 @@ func (m *awsEc2query_deserializeOpGetInstanceMetadataDefaults) HandleDeserialize } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorGetInstanceMetadataDefaults(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorGetHostReservationPurchasePreview(response, &metadata) } - output := &GetInstanceMetadataDefaultsOutput{} + output := &GetHostReservationPurchasePreviewOutput{} out.Result = output var buff [1024]byte @@ -50424,7 +50804,7 @@ func (m *awsEc2query_deserializeOpGetInstanceMetadataDefaults) HandleDeserialize } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentGetInstanceMetadataDefaultsOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentGetHostReservationPurchasePreviewOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -50438,7 +50818,7 @@ func (m *awsEc2query_deserializeOpGetInstanceMetadataDefaults) HandleDeserialize return out, metadata, err } -func awsEc2query_deserializeOpErrorGetInstanceMetadataDefaults(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorGetHostReservationPurchasePreview(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -50471,14 +50851,14 @@ func awsEc2query_deserializeOpErrorGetInstanceMetadataDefaults(response *smithyh } } -type awsEc2query_deserializeOpGetInstanceTpmEkPub struct { +type awsEc2query_deserializeOpGetImageAncestry struct { } -func (*awsEc2query_deserializeOpGetInstanceTpmEkPub) ID() string { +func (*awsEc2query_deserializeOpGetImageAncestry) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpGetInstanceTpmEkPub) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpGetImageAncestry) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -50496,9 +50876,9 @@ func (m *awsEc2query_deserializeOpGetInstanceTpmEkPub) HandleDeserialize(ctx con } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorGetInstanceTpmEkPub(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorGetImageAncestry(response, &metadata) } - output := &GetInstanceTpmEkPubOutput{} + output := &GetImageAncestryOutput{} out.Result = output var buff [1024]byte @@ -50519,7 +50899,7 @@ func (m *awsEc2query_deserializeOpGetInstanceTpmEkPub) HandleDeserialize(ctx con } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentGetInstanceTpmEkPubOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentGetImageAncestryOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -50533,7 +50913,7 @@ func (m *awsEc2query_deserializeOpGetInstanceTpmEkPub) HandleDeserialize(ctx con return out, metadata, err } -func awsEc2query_deserializeOpErrorGetInstanceTpmEkPub(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorGetImageAncestry(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -50566,14 +50946,14 @@ func awsEc2query_deserializeOpErrorGetInstanceTpmEkPub(response *smithyhttp.Resp } } -type awsEc2query_deserializeOpGetInstanceTypesFromInstanceRequirements struct { +type awsEc2query_deserializeOpGetImageBlockPublicAccessState struct { } -func (*awsEc2query_deserializeOpGetInstanceTypesFromInstanceRequirements) ID() string { +func (*awsEc2query_deserializeOpGetImageBlockPublicAccessState) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpGetInstanceTypesFromInstanceRequirements) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpGetImageBlockPublicAccessState) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -50591,9 +50971,9 @@ func (m *awsEc2query_deserializeOpGetInstanceTypesFromInstanceRequirements) Hand } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorGetInstanceTypesFromInstanceRequirements(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorGetImageBlockPublicAccessState(response, &metadata) } - output := &GetInstanceTypesFromInstanceRequirementsOutput{} + output := &GetImageBlockPublicAccessStateOutput{} out.Result = output var buff [1024]byte @@ -50614,7 +50994,7 @@ func (m *awsEc2query_deserializeOpGetInstanceTypesFromInstanceRequirements) Hand } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentGetInstanceTypesFromInstanceRequirementsOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentGetImageBlockPublicAccessStateOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -50628,7 +51008,7 @@ func (m *awsEc2query_deserializeOpGetInstanceTypesFromInstanceRequirements) Hand return out, metadata, err } -func awsEc2query_deserializeOpErrorGetInstanceTypesFromInstanceRequirements(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorGetImageBlockPublicAccessState(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -50661,14 +51041,14 @@ func awsEc2query_deserializeOpErrorGetInstanceTypesFromInstanceRequirements(resp } } -type awsEc2query_deserializeOpGetInstanceUefiData struct { +type awsEc2query_deserializeOpGetInstanceMetadataDefaults struct { } -func (*awsEc2query_deserializeOpGetInstanceUefiData) ID() string { +func (*awsEc2query_deserializeOpGetInstanceMetadataDefaults) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpGetInstanceUefiData) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpGetInstanceMetadataDefaults) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -50686,9 +51066,9 @@ func (m *awsEc2query_deserializeOpGetInstanceUefiData) HandleDeserialize(ctx con } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorGetInstanceUefiData(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorGetInstanceMetadataDefaults(response, &metadata) } - output := &GetInstanceUefiDataOutput{} + output := &GetInstanceMetadataDefaultsOutput{} out.Result = output var buff [1024]byte @@ -50709,7 +51089,7 @@ func (m *awsEc2query_deserializeOpGetInstanceUefiData) HandleDeserialize(ctx con } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentGetInstanceUefiDataOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentGetInstanceMetadataDefaultsOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -50723,7 +51103,7 @@ func (m *awsEc2query_deserializeOpGetInstanceUefiData) HandleDeserialize(ctx con return out, metadata, err } -func awsEc2query_deserializeOpErrorGetInstanceUefiData(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorGetInstanceMetadataDefaults(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -50756,14 +51136,14 @@ func awsEc2query_deserializeOpErrorGetInstanceUefiData(response *smithyhttp.Resp } } -type awsEc2query_deserializeOpGetIpamAddressHistory struct { +type awsEc2query_deserializeOpGetInstanceTpmEkPub struct { } -func (*awsEc2query_deserializeOpGetIpamAddressHistory) ID() string { +func (*awsEc2query_deserializeOpGetInstanceTpmEkPub) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpGetIpamAddressHistory) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpGetInstanceTpmEkPub) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -50781,9 +51161,9 @@ func (m *awsEc2query_deserializeOpGetIpamAddressHistory) HandleDeserialize(ctx c } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorGetIpamAddressHistory(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorGetInstanceTpmEkPub(response, &metadata) } - output := &GetIpamAddressHistoryOutput{} + output := &GetInstanceTpmEkPubOutput{} out.Result = output var buff [1024]byte @@ -50804,7 +51184,7 @@ func (m *awsEc2query_deserializeOpGetIpamAddressHistory) HandleDeserialize(ctx c } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentGetIpamAddressHistoryOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentGetInstanceTpmEkPubOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -50818,7 +51198,7 @@ func (m *awsEc2query_deserializeOpGetIpamAddressHistory) HandleDeserialize(ctx c return out, metadata, err } -func awsEc2query_deserializeOpErrorGetIpamAddressHistory(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorGetInstanceTpmEkPub(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -50851,14 +51231,14 @@ func awsEc2query_deserializeOpErrorGetIpamAddressHistory(response *smithyhttp.Re } } -type awsEc2query_deserializeOpGetIpamDiscoveredAccounts struct { +type awsEc2query_deserializeOpGetInstanceTypesFromInstanceRequirements struct { } -func (*awsEc2query_deserializeOpGetIpamDiscoveredAccounts) ID() string { +func (*awsEc2query_deserializeOpGetInstanceTypesFromInstanceRequirements) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpGetIpamDiscoveredAccounts) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpGetInstanceTypesFromInstanceRequirements) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -50876,9 +51256,9 @@ func (m *awsEc2query_deserializeOpGetIpamDiscoveredAccounts) HandleDeserialize(c } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorGetIpamDiscoveredAccounts(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorGetInstanceTypesFromInstanceRequirements(response, &metadata) } - output := &GetIpamDiscoveredAccountsOutput{} + output := &GetInstanceTypesFromInstanceRequirementsOutput{} out.Result = output var buff [1024]byte @@ -50899,7 +51279,7 @@ func (m *awsEc2query_deserializeOpGetIpamDiscoveredAccounts) HandleDeserialize(c } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentGetIpamDiscoveredAccountsOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentGetInstanceTypesFromInstanceRequirementsOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -50913,7 +51293,7 @@ func (m *awsEc2query_deserializeOpGetIpamDiscoveredAccounts) HandleDeserialize(c return out, metadata, err } -func awsEc2query_deserializeOpErrorGetIpamDiscoveredAccounts(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorGetInstanceTypesFromInstanceRequirements(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -50946,14 +51326,14 @@ func awsEc2query_deserializeOpErrorGetIpamDiscoveredAccounts(response *smithyhtt } } -type awsEc2query_deserializeOpGetIpamDiscoveredPublicAddresses struct { +type awsEc2query_deserializeOpGetInstanceUefiData struct { } -func (*awsEc2query_deserializeOpGetIpamDiscoveredPublicAddresses) ID() string { +func (*awsEc2query_deserializeOpGetInstanceUefiData) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpGetIpamDiscoveredPublicAddresses) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpGetInstanceUefiData) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -50971,9 +51351,9 @@ func (m *awsEc2query_deserializeOpGetIpamDiscoveredPublicAddresses) HandleDeseri } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorGetIpamDiscoveredPublicAddresses(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorGetInstanceUefiData(response, &metadata) } - output := &GetIpamDiscoveredPublicAddressesOutput{} + output := &GetInstanceUefiDataOutput{} out.Result = output var buff [1024]byte @@ -50994,7 +51374,7 @@ func (m *awsEc2query_deserializeOpGetIpamDiscoveredPublicAddresses) HandleDeseri } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentGetIpamDiscoveredPublicAddressesOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentGetInstanceUefiDataOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -51008,7 +51388,7 @@ func (m *awsEc2query_deserializeOpGetIpamDiscoveredPublicAddresses) HandleDeseri return out, metadata, err } -func awsEc2query_deserializeOpErrorGetIpamDiscoveredPublicAddresses(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorGetInstanceUefiData(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -51041,14 +51421,14 @@ func awsEc2query_deserializeOpErrorGetIpamDiscoveredPublicAddresses(response *sm } } -type awsEc2query_deserializeOpGetIpamDiscoveredResourceCidrs struct { +type awsEc2query_deserializeOpGetIpamAddressHistory struct { } -func (*awsEc2query_deserializeOpGetIpamDiscoveredResourceCidrs) ID() string { +func (*awsEc2query_deserializeOpGetIpamAddressHistory) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpGetIpamDiscoveredResourceCidrs) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpGetIpamAddressHistory) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -51066,9 +51446,9 @@ func (m *awsEc2query_deserializeOpGetIpamDiscoveredResourceCidrs) HandleDeserial } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorGetIpamDiscoveredResourceCidrs(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorGetIpamAddressHistory(response, &metadata) } - output := &GetIpamDiscoveredResourceCidrsOutput{} + output := &GetIpamAddressHistoryOutput{} out.Result = output var buff [1024]byte @@ -51089,7 +51469,7 @@ func (m *awsEc2query_deserializeOpGetIpamDiscoveredResourceCidrs) HandleDeserial } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentGetIpamDiscoveredResourceCidrsOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentGetIpamAddressHistoryOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -51103,7 +51483,7 @@ func (m *awsEc2query_deserializeOpGetIpamDiscoveredResourceCidrs) HandleDeserial return out, metadata, err } -func awsEc2query_deserializeOpErrorGetIpamDiscoveredResourceCidrs(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorGetIpamAddressHistory(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -51136,14 +51516,14 @@ func awsEc2query_deserializeOpErrorGetIpamDiscoveredResourceCidrs(response *smit } } -type awsEc2query_deserializeOpGetIpamPolicyAllocationRules struct { +type awsEc2query_deserializeOpGetIpamDiscoveredAccounts struct { } -func (*awsEc2query_deserializeOpGetIpamPolicyAllocationRules) ID() string { +func (*awsEc2query_deserializeOpGetIpamDiscoveredAccounts) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpGetIpamPolicyAllocationRules) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +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) @@ -51161,9 +51541,9 @@ func (m *awsEc2query_deserializeOpGetIpamPolicyAllocationRules) HandleDeserializ } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorGetIpamPolicyAllocationRules(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorGetIpamDiscoveredAccounts(response, &metadata) } - output := &GetIpamPolicyAllocationRulesOutput{} + output := &GetIpamDiscoveredAccountsOutput{} out.Result = output var buff [1024]byte @@ -51184,7 +51564,7 @@ func (m *awsEc2query_deserializeOpGetIpamPolicyAllocationRules) HandleDeserializ } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentGetIpamPolicyAllocationRulesOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentGetIpamDiscoveredAccountsOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -51198,7 +51578,7 @@ func (m *awsEc2query_deserializeOpGetIpamPolicyAllocationRules) HandleDeserializ return out, metadata, err } -func awsEc2query_deserializeOpErrorGetIpamPolicyAllocationRules(response *smithyhttp.Response, metadata *middleware.Metadata) error { +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)} @@ -51231,14 +51611,14 @@ func awsEc2query_deserializeOpErrorGetIpamPolicyAllocationRules(response *smithy } } -type awsEc2query_deserializeOpGetIpamPolicyOrganizationTargets struct { +type awsEc2query_deserializeOpGetIpamDiscoveredPublicAddresses struct { } -func (*awsEc2query_deserializeOpGetIpamPolicyOrganizationTargets) ID() string { +func (*awsEc2query_deserializeOpGetIpamDiscoveredPublicAddresses) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpGetIpamPolicyOrganizationTargets) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpGetIpamDiscoveredPublicAddresses) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -51256,9 +51636,9 @@ func (m *awsEc2query_deserializeOpGetIpamPolicyOrganizationTargets) HandleDeseri } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorGetIpamPolicyOrganizationTargets(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorGetIpamDiscoveredPublicAddresses(response, &metadata) } - output := &GetIpamPolicyOrganizationTargetsOutput{} + output := &GetIpamDiscoveredPublicAddressesOutput{} out.Result = output var buff [1024]byte @@ -51279,7 +51659,7 @@ func (m *awsEc2query_deserializeOpGetIpamPolicyOrganizationTargets) HandleDeseri } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentGetIpamPolicyOrganizationTargetsOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentGetIpamDiscoveredPublicAddressesOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -51293,7 +51673,7 @@ func (m *awsEc2query_deserializeOpGetIpamPolicyOrganizationTargets) HandleDeseri return out, metadata, err } -func awsEc2query_deserializeOpErrorGetIpamPolicyOrganizationTargets(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorGetIpamDiscoveredPublicAddresses(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -51326,14 +51706,14 @@ func awsEc2query_deserializeOpErrorGetIpamPolicyOrganizationTargets(response *sm } } -type awsEc2query_deserializeOpGetIpamPoolAllocations struct { +type awsEc2query_deserializeOpGetIpamDiscoveredResourceCidrs struct { } -func (*awsEc2query_deserializeOpGetIpamPoolAllocations) ID() string { +func (*awsEc2query_deserializeOpGetIpamDiscoveredResourceCidrs) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpGetIpamPoolAllocations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +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) @@ -51351,9 +51731,9 @@ func (m *awsEc2query_deserializeOpGetIpamPoolAllocations) HandleDeserialize(ctx } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorGetIpamPoolAllocations(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorGetIpamDiscoveredResourceCidrs(response, &metadata) } - output := &GetIpamPoolAllocationsOutput{} + output := &GetIpamDiscoveredResourceCidrsOutput{} out.Result = output var buff [1024]byte @@ -51374,7 +51754,7 @@ func (m *awsEc2query_deserializeOpGetIpamPoolAllocations) HandleDeserialize(ctx } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentGetIpamPoolAllocationsOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentGetIpamDiscoveredResourceCidrsOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -51388,7 +51768,7 @@ func (m *awsEc2query_deserializeOpGetIpamPoolAllocations) HandleDeserialize(ctx return out, metadata, err } -func awsEc2query_deserializeOpErrorGetIpamPoolAllocations(response *smithyhttp.Response, metadata *middleware.Metadata) error { +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)} @@ -51421,14 +51801,14 @@ func awsEc2query_deserializeOpErrorGetIpamPoolAllocations(response *smithyhttp.R } } -type awsEc2query_deserializeOpGetIpamPoolCidrs struct { +type awsEc2query_deserializeOpGetIpamPolicyAllocationRules struct { } -func (*awsEc2query_deserializeOpGetIpamPoolCidrs) ID() string { +func (*awsEc2query_deserializeOpGetIpamPolicyAllocationRules) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpGetIpamPoolCidrs) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpGetIpamPolicyAllocationRules) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -51446,9 +51826,9 @@ func (m *awsEc2query_deserializeOpGetIpamPoolCidrs) HandleDeserialize(ctx contex } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorGetIpamPoolCidrs(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorGetIpamPolicyAllocationRules(response, &metadata) } - output := &GetIpamPoolCidrsOutput{} + output := &GetIpamPolicyAllocationRulesOutput{} out.Result = output var buff [1024]byte @@ -51469,7 +51849,7 @@ func (m *awsEc2query_deserializeOpGetIpamPoolCidrs) HandleDeserialize(ctx contex } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentGetIpamPoolCidrsOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentGetIpamPolicyAllocationRulesOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -51483,7 +51863,7 @@ func (m *awsEc2query_deserializeOpGetIpamPoolCidrs) HandleDeserialize(ctx contex return out, metadata, err } -func awsEc2query_deserializeOpErrorGetIpamPoolCidrs(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorGetIpamPolicyAllocationRules(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -51516,14 +51896,14 @@ func awsEc2query_deserializeOpErrorGetIpamPoolCidrs(response *smithyhttp.Respons } } -type awsEc2query_deserializeOpGetIpamPrefixListResolverRules struct { +type awsEc2query_deserializeOpGetIpamPolicyOrganizationTargets struct { } -func (*awsEc2query_deserializeOpGetIpamPrefixListResolverRules) ID() string { +func (*awsEc2query_deserializeOpGetIpamPolicyOrganizationTargets) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpGetIpamPrefixListResolverRules) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpGetIpamPolicyOrganizationTargets) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -51541,9 +51921,9 @@ func (m *awsEc2query_deserializeOpGetIpamPrefixListResolverRules) HandleDeserial } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorGetIpamPrefixListResolverRules(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorGetIpamPolicyOrganizationTargets(response, &metadata) } - output := &GetIpamPrefixListResolverRulesOutput{} + output := &GetIpamPolicyOrganizationTargetsOutput{} out.Result = output var buff [1024]byte @@ -51564,7 +51944,7 @@ func (m *awsEc2query_deserializeOpGetIpamPrefixListResolverRules) HandleDeserial } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentGetIpamPrefixListResolverRulesOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentGetIpamPolicyOrganizationTargetsOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -51578,7 +51958,7 @@ func (m *awsEc2query_deserializeOpGetIpamPrefixListResolverRules) HandleDeserial return out, metadata, err } -func awsEc2query_deserializeOpErrorGetIpamPrefixListResolverRules(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorGetIpamPolicyOrganizationTargets(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -51611,14 +51991,14 @@ func awsEc2query_deserializeOpErrorGetIpamPrefixListResolverRules(response *smit } } -type awsEc2query_deserializeOpGetIpamPrefixListResolverVersionEntries struct { +type awsEc2query_deserializeOpGetIpamPoolAllocations struct { } -func (*awsEc2query_deserializeOpGetIpamPrefixListResolverVersionEntries) ID() string { +func (*awsEc2query_deserializeOpGetIpamPoolAllocations) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpGetIpamPrefixListResolverVersionEntries) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpGetIpamPoolAllocations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -51636,9 +52016,9 @@ func (m *awsEc2query_deserializeOpGetIpamPrefixListResolverVersionEntries) Handl } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorGetIpamPrefixListResolverVersionEntries(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorGetIpamPoolAllocations(response, &metadata) } - output := &GetIpamPrefixListResolverVersionEntriesOutput{} + output := &GetIpamPoolAllocationsOutput{} out.Result = output var buff [1024]byte @@ -51659,7 +52039,7 @@ func (m *awsEc2query_deserializeOpGetIpamPrefixListResolverVersionEntries) Handl } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentGetIpamPrefixListResolverVersionEntriesOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentGetIpamPoolAllocationsOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -51673,7 +52053,7 @@ func (m *awsEc2query_deserializeOpGetIpamPrefixListResolverVersionEntries) Handl return out, metadata, err } -func awsEc2query_deserializeOpErrorGetIpamPrefixListResolverVersionEntries(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorGetIpamPoolAllocations(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -51706,14 +52086,14 @@ func awsEc2query_deserializeOpErrorGetIpamPrefixListResolverVersionEntries(respo } } -type awsEc2query_deserializeOpGetIpamPrefixListResolverVersions struct { +type awsEc2query_deserializeOpGetIpamPoolCidrs struct { } -func (*awsEc2query_deserializeOpGetIpamPrefixListResolverVersions) ID() string { +func (*awsEc2query_deserializeOpGetIpamPoolCidrs) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpGetIpamPrefixListResolverVersions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpGetIpamPoolCidrs) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -51731,9 +52111,9 @@ func (m *awsEc2query_deserializeOpGetIpamPrefixListResolverVersions) HandleDeser } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorGetIpamPrefixListResolverVersions(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorGetIpamPoolCidrs(response, &metadata) } - output := &GetIpamPrefixListResolverVersionsOutput{} + output := &GetIpamPoolCidrsOutput{} out.Result = output var buff [1024]byte @@ -51754,7 +52134,7 @@ func (m *awsEc2query_deserializeOpGetIpamPrefixListResolverVersions) HandleDeser } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentGetIpamPrefixListResolverVersionsOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentGetIpamPoolCidrsOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -51768,7 +52148,7 @@ func (m *awsEc2query_deserializeOpGetIpamPrefixListResolverVersions) HandleDeser return out, metadata, err } -func awsEc2query_deserializeOpErrorGetIpamPrefixListResolverVersions(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorGetIpamPoolCidrs(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -51801,14 +52181,14 @@ func awsEc2query_deserializeOpErrorGetIpamPrefixListResolverVersions(response *s } } -type awsEc2query_deserializeOpGetIpamResourceCidrs struct { +type awsEc2query_deserializeOpGetIpamPrefixListResolverRules struct { } -func (*awsEc2query_deserializeOpGetIpamResourceCidrs) ID() string { +func (*awsEc2query_deserializeOpGetIpamPrefixListResolverRules) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpGetIpamResourceCidrs) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpGetIpamPrefixListResolverRules) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -51826,9 +52206,9 @@ func (m *awsEc2query_deserializeOpGetIpamResourceCidrs) HandleDeserialize(ctx co } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorGetIpamResourceCidrs(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorGetIpamPrefixListResolverRules(response, &metadata) } - output := &GetIpamResourceCidrsOutput{} + output := &GetIpamPrefixListResolverRulesOutput{} out.Result = output var buff [1024]byte @@ -51849,7 +52229,7 @@ func (m *awsEc2query_deserializeOpGetIpamResourceCidrs) HandleDeserialize(ctx co } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentGetIpamResourceCidrsOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentGetIpamPrefixListResolverRulesOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -51863,7 +52243,7 @@ func (m *awsEc2query_deserializeOpGetIpamResourceCidrs) HandleDeserialize(ctx co return out, metadata, err } -func awsEc2query_deserializeOpErrorGetIpamResourceCidrs(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorGetIpamPrefixListResolverRules(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -51896,14 +52276,14 @@ func awsEc2query_deserializeOpErrorGetIpamResourceCidrs(response *smithyhttp.Res } } -type awsEc2query_deserializeOpGetLaunchTemplateData struct { +type awsEc2query_deserializeOpGetIpamPrefixListResolverVersionEntries struct { } -func (*awsEc2query_deserializeOpGetLaunchTemplateData) ID() string { +func (*awsEc2query_deserializeOpGetIpamPrefixListResolverVersionEntries) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpGetLaunchTemplateData) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpGetIpamPrefixListResolverVersionEntries) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -51921,9 +52301,9 @@ func (m *awsEc2query_deserializeOpGetLaunchTemplateData) HandleDeserialize(ctx c } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorGetLaunchTemplateData(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorGetIpamPrefixListResolverVersionEntries(response, &metadata) } - output := &GetLaunchTemplateDataOutput{} + output := &GetIpamPrefixListResolverVersionEntriesOutput{} out.Result = output var buff [1024]byte @@ -51944,7 +52324,7 @@ func (m *awsEc2query_deserializeOpGetLaunchTemplateData) HandleDeserialize(ctx c } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentGetLaunchTemplateDataOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentGetIpamPrefixListResolverVersionEntriesOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -51958,7 +52338,7 @@ func (m *awsEc2query_deserializeOpGetLaunchTemplateData) HandleDeserialize(ctx c return out, metadata, err } -func awsEc2query_deserializeOpErrorGetLaunchTemplateData(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorGetIpamPrefixListResolverVersionEntries(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -51991,14 +52371,14 @@ func awsEc2query_deserializeOpErrorGetLaunchTemplateData(response *smithyhttp.Re } } -type awsEc2query_deserializeOpGetManagedPrefixListAssociations struct { +type awsEc2query_deserializeOpGetIpamPrefixListResolverVersions struct { } -func (*awsEc2query_deserializeOpGetManagedPrefixListAssociations) ID() string { +func (*awsEc2query_deserializeOpGetIpamPrefixListResolverVersions) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpGetManagedPrefixListAssociations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpGetIpamPrefixListResolverVersions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -52016,9 +52396,9 @@ func (m *awsEc2query_deserializeOpGetManagedPrefixListAssociations) HandleDeseri } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorGetManagedPrefixListAssociations(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorGetIpamPrefixListResolverVersions(response, &metadata) } - output := &GetManagedPrefixListAssociationsOutput{} + output := &GetIpamPrefixListResolverVersionsOutput{} out.Result = output var buff [1024]byte @@ -52039,7 +52419,7 @@ func (m *awsEc2query_deserializeOpGetManagedPrefixListAssociations) HandleDeseri } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentGetManagedPrefixListAssociationsOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentGetIpamPrefixListResolverVersionsOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -52053,7 +52433,7 @@ func (m *awsEc2query_deserializeOpGetManagedPrefixListAssociations) HandleDeseri return out, metadata, err } -func awsEc2query_deserializeOpErrorGetManagedPrefixListAssociations(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorGetIpamPrefixListResolverVersions(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -52086,14 +52466,14 @@ func awsEc2query_deserializeOpErrorGetManagedPrefixListAssociations(response *sm } } -type awsEc2query_deserializeOpGetManagedPrefixListEntries struct { +type awsEc2query_deserializeOpGetIpamResourceCidrs struct { } -func (*awsEc2query_deserializeOpGetManagedPrefixListEntries) ID() string { +func (*awsEc2query_deserializeOpGetIpamResourceCidrs) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpGetManagedPrefixListEntries) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpGetIpamResourceCidrs) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -52111,9 +52491,9 @@ func (m *awsEc2query_deserializeOpGetManagedPrefixListEntries) HandleDeserialize } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorGetManagedPrefixListEntries(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorGetIpamResourceCidrs(response, &metadata) } - output := &GetManagedPrefixListEntriesOutput{} + output := &GetIpamResourceCidrsOutput{} out.Result = output var buff [1024]byte @@ -52134,7 +52514,7 @@ func (m *awsEc2query_deserializeOpGetManagedPrefixListEntries) HandleDeserialize } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentGetManagedPrefixListEntriesOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentGetIpamResourceCidrsOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -52148,7 +52528,7 @@ func (m *awsEc2query_deserializeOpGetManagedPrefixListEntries) HandleDeserialize return out, metadata, err } -func awsEc2query_deserializeOpErrorGetManagedPrefixListEntries(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorGetIpamResourceCidrs(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -52181,14 +52561,14 @@ func awsEc2query_deserializeOpErrorGetManagedPrefixListEntries(response *smithyh } } -type awsEc2query_deserializeOpGetNetworkInsightsAccessScopeAnalysisFindings struct { +type awsEc2query_deserializeOpGetLaunchTemplateData struct { } -func (*awsEc2query_deserializeOpGetNetworkInsightsAccessScopeAnalysisFindings) ID() string { +func (*awsEc2query_deserializeOpGetLaunchTemplateData) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpGetNetworkInsightsAccessScopeAnalysisFindings) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpGetLaunchTemplateData) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -52206,9 +52586,9 @@ func (m *awsEc2query_deserializeOpGetNetworkInsightsAccessScopeAnalysisFindings) } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorGetNetworkInsightsAccessScopeAnalysisFindings(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorGetLaunchTemplateData(response, &metadata) } - output := &GetNetworkInsightsAccessScopeAnalysisFindingsOutput{} + output := &GetLaunchTemplateDataOutput{} out.Result = output var buff [1024]byte @@ -52229,7 +52609,7 @@ func (m *awsEc2query_deserializeOpGetNetworkInsightsAccessScopeAnalysisFindings) } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentGetNetworkInsightsAccessScopeAnalysisFindingsOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentGetLaunchTemplateDataOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -52243,7 +52623,7 @@ func (m *awsEc2query_deserializeOpGetNetworkInsightsAccessScopeAnalysisFindings) return out, metadata, err } -func awsEc2query_deserializeOpErrorGetNetworkInsightsAccessScopeAnalysisFindings(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorGetLaunchTemplateData(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -52276,14 +52656,14 @@ func awsEc2query_deserializeOpErrorGetNetworkInsightsAccessScopeAnalysisFindings } } -type awsEc2query_deserializeOpGetNetworkInsightsAccessScopeContent struct { +type awsEc2query_deserializeOpGetManagedPrefixListAssociations struct { } -func (*awsEc2query_deserializeOpGetNetworkInsightsAccessScopeContent) ID() string { +func (*awsEc2query_deserializeOpGetManagedPrefixListAssociations) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpGetNetworkInsightsAccessScopeContent) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpGetManagedPrefixListAssociations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -52301,9 +52681,9 @@ func (m *awsEc2query_deserializeOpGetNetworkInsightsAccessScopeContent) HandleDe } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorGetNetworkInsightsAccessScopeContent(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorGetManagedPrefixListAssociations(response, &metadata) } - output := &GetNetworkInsightsAccessScopeContentOutput{} + output := &GetManagedPrefixListAssociationsOutput{} out.Result = output var buff [1024]byte @@ -52324,7 +52704,7 @@ func (m *awsEc2query_deserializeOpGetNetworkInsightsAccessScopeContent) HandleDe } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentGetNetworkInsightsAccessScopeContentOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentGetManagedPrefixListAssociationsOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -52338,7 +52718,7 @@ func (m *awsEc2query_deserializeOpGetNetworkInsightsAccessScopeContent) HandleDe return out, metadata, err } -func awsEc2query_deserializeOpErrorGetNetworkInsightsAccessScopeContent(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorGetManagedPrefixListAssociations(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -52371,14 +52751,14 @@ func awsEc2query_deserializeOpErrorGetNetworkInsightsAccessScopeContent(response } } -type awsEc2query_deserializeOpGetPasswordData struct { +type awsEc2query_deserializeOpGetManagedPrefixListEntries struct { } -func (*awsEc2query_deserializeOpGetPasswordData) ID() string { +func (*awsEc2query_deserializeOpGetManagedPrefixListEntries) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpGetPasswordData) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpGetManagedPrefixListEntries) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -52396,9 +52776,9 @@ func (m *awsEc2query_deserializeOpGetPasswordData) HandleDeserialize(ctx context } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorGetPasswordData(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorGetManagedPrefixListEntries(response, &metadata) } - output := &GetPasswordDataOutput{} + output := &GetManagedPrefixListEntriesOutput{} out.Result = output var buff [1024]byte @@ -52419,7 +52799,7 @@ func (m *awsEc2query_deserializeOpGetPasswordData) HandleDeserialize(ctx context } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentGetPasswordDataOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentGetManagedPrefixListEntriesOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -52433,7 +52813,7 @@ func (m *awsEc2query_deserializeOpGetPasswordData) HandleDeserialize(ctx context return out, metadata, err } -func awsEc2query_deserializeOpErrorGetPasswordData(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorGetManagedPrefixListEntries(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -52466,14 +52846,14 @@ func awsEc2query_deserializeOpErrorGetPasswordData(response *smithyhttp.Response } } -type awsEc2query_deserializeOpGetReservedInstancesExchangeQuote struct { +type awsEc2query_deserializeOpGetNetworkInsightsAccessScopeAnalysisFindings struct { } -func (*awsEc2query_deserializeOpGetReservedInstancesExchangeQuote) ID() string { +func (*awsEc2query_deserializeOpGetNetworkInsightsAccessScopeAnalysisFindings) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpGetReservedInstancesExchangeQuote) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpGetNetworkInsightsAccessScopeAnalysisFindings) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -52491,9 +52871,9 @@ func (m *awsEc2query_deserializeOpGetReservedInstancesExchangeQuote) HandleDeser } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorGetReservedInstancesExchangeQuote(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorGetNetworkInsightsAccessScopeAnalysisFindings(response, &metadata) } - output := &GetReservedInstancesExchangeQuoteOutput{} + output := &GetNetworkInsightsAccessScopeAnalysisFindingsOutput{} out.Result = output var buff [1024]byte @@ -52514,7 +52894,7 @@ func (m *awsEc2query_deserializeOpGetReservedInstancesExchangeQuote) HandleDeser } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentGetReservedInstancesExchangeQuoteOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentGetNetworkInsightsAccessScopeAnalysisFindingsOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -52528,7 +52908,7 @@ func (m *awsEc2query_deserializeOpGetReservedInstancesExchangeQuote) HandleDeser return out, metadata, err } -func awsEc2query_deserializeOpErrorGetReservedInstancesExchangeQuote(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorGetNetworkInsightsAccessScopeAnalysisFindings(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -52561,14 +52941,14 @@ func awsEc2query_deserializeOpErrorGetReservedInstancesExchangeQuote(response *s } } -type awsEc2query_deserializeOpGetRouteServerAssociations struct { +type awsEc2query_deserializeOpGetNetworkInsightsAccessScopeContent struct { } -func (*awsEc2query_deserializeOpGetRouteServerAssociations) ID() string { +func (*awsEc2query_deserializeOpGetNetworkInsightsAccessScopeContent) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpGetRouteServerAssociations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpGetNetworkInsightsAccessScopeContent) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -52586,9 +52966,9 @@ func (m *awsEc2query_deserializeOpGetRouteServerAssociations) HandleDeserialize( } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorGetRouteServerAssociations(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorGetNetworkInsightsAccessScopeContent(response, &metadata) } - output := &GetRouteServerAssociationsOutput{} + output := &GetNetworkInsightsAccessScopeContentOutput{} out.Result = output var buff [1024]byte @@ -52609,7 +52989,7 @@ func (m *awsEc2query_deserializeOpGetRouteServerAssociations) HandleDeserialize( } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentGetRouteServerAssociationsOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentGetNetworkInsightsAccessScopeContentOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -52623,7 +53003,7 @@ func (m *awsEc2query_deserializeOpGetRouteServerAssociations) HandleDeserialize( return out, metadata, err } -func awsEc2query_deserializeOpErrorGetRouteServerAssociations(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorGetNetworkInsightsAccessScopeContent(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -52656,14 +53036,14 @@ func awsEc2query_deserializeOpErrorGetRouteServerAssociations(response *smithyht } } -type awsEc2query_deserializeOpGetRouteServerPropagations struct { +type awsEc2query_deserializeOpGetPasswordData struct { } -func (*awsEc2query_deserializeOpGetRouteServerPropagations) ID() string { +func (*awsEc2query_deserializeOpGetPasswordData) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpGetRouteServerPropagations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpGetPasswordData) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -52681,9 +53061,9 @@ func (m *awsEc2query_deserializeOpGetRouteServerPropagations) HandleDeserialize( } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorGetRouteServerPropagations(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorGetPasswordData(response, &metadata) } - output := &GetRouteServerPropagationsOutput{} + output := &GetPasswordDataOutput{} out.Result = output var buff [1024]byte @@ -52704,7 +53084,7 @@ func (m *awsEc2query_deserializeOpGetRouteServerPropagations) HandleDeserialize( } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentGetRouteServerPropagationsOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentGetPasswordDataOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -52718,7 +53098,7 @@ func (m *awsEc2query_deserializeOpGetRouteServerPropagations) HandleDeserialize( return out, metadata, err } -func awsEc2query_deserializeOpErrorGetRouteServerPropagations(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorGetPasswordData(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -52751,14 +53131,14 @@ func awsEc2query_deserializeOpErrorGetRouteServerPropagations(response *smithyht } } -type awsEc2query_deserializeOpGetRouteServerRoutingDatabase struct { +type awsEc2query_deserializeOpGetReservedInstancesExchangeQuote struct { } -func (*awsEc2query_deserializeOpGetRouteServerRoutingDatabase) ID() string { +func (*awsEc2query_deserializeOpGetReservedInstancesExchangeQuote) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpGetRouteServerRoutingDatabase) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpGetReservedInstancesExchangeQuote) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -52776,9 +53156,9 @@ func (m *awsEc2query_deserializeOpGetRouteServerRoutingDatabase) HandleDeseriali } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorGetRouteServerRoutingDatabase(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorGetReservedInstancesExchangeQuote(response, &metadata) } - output := &GetRouteServerRoutingDatabaseOutput{} + output := &GetReservedInstancesExchangeQuoteOutput{} out.Result = output var buff [1024]byte @@ -52799,7 +53179,7 @@ func (m *awsEc2query_deserializeOpGetRouteServerRoutingDatabase) HandleDeseriali } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentGetRouteServerRoutingDatabaseOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentGetReservedInstancesExchangeQuoteOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -52813,7 +53193,7 @@ func (m *awsEc2query_deserializeOpGetRouteServerRoutingDatabase) HandleDeseriali return out, metadata, err } -func awsEc2query_deserializeOpErrorGetRouteServerRoutingDatabase(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorGetReservedInstancesExchangeQuote(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -52846,14 +53226,14 @@ func awsEc2query_deserializeOpErrorGetRouteServerRoutingDatabase(response *smith } } -type awsEc2query_deserializeOpGetSecurityGroupsForVpc struct { +type awsEc2query_deserializeOpGetRouteServerAssociations struct { } -func (*awsEc2query_deserializeOpGetSecurityGroupsForVpc) ID() string { +func (*awsEc2query_deserializeOpGetRouteServerAssociations) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpGetSecurityGroupsForVpc) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpGetRouteServerAssociations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -52871,9 +53251,9 @@ func (m *awsEc2query_deserializeOpGetSecurityGroupsForVpc) HandleDeserialize(ctx } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorGetSecurityGroupsForVpc(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorGetRouteServerAssociations(response, &metadata) } - output := &GetSecurityGroupsForVpcOutput{} + output := &GetRouteServerAssociationsOutput{} out.Result = output var buff [1024]byte @@ -52894,7 +53274,7 @@ func (m *awsEc2query_deserializeOpGetSecurityGroupsForVpc) HandleDeserialize(ctx } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentGetSecurityGroupsForVpcOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentGetRouteServerAssociationsOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -52908,7 +53288,7 @@ func (m *awsEc2query_deserializeOpGetSecurityGroupsForVpc) HandleDeserialize(ctx return out, metadata, err } -func awsEc2query_deserializeOpErrorGetSecurityGroupsForVpc(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorGetRouteServerAssociations(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -52941,14 +53321,14 @@ func awsEc2query_deserializeOpErrorGetSecurityGroupsForVpc(response *smithyhttp. } } -type awsEc2query_deserializeOpGetSerialConsoleAccessStatus struct { +type awsEc2query_deserializeOpGetRouteServerPropagations struct { } -func (*awsEc2query_deserializeOpGetSerialConsoleAccessStatus) ID() string { +func (*awsEc2query_deserializeOpGetRouteServerPropagations) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpGetSerialConsoleAccessStatus) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpGetRouteServerPropagations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -52966,9 +53346,9 @@ func (m *awsEc2query_deserializeOpGetSerialConsoleAccessStatus) HandleDeserializ } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorGetSerialConsoleAccessStatus(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorGetRouteServerPropagations(response, &metadata) } - output := &GetSerialConsoleAccessStatusOutput{} + output := &GetRouteServerPropagationsOutput{} out.Result = output var buff [1024]byte @@ -52989,7 +53369,7 @@ func (m *awsEc2query_deserializeOpGetSerialConsoleAccessStatus) HandleDeserializ } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentGetSerialConsoleAccessStatusOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentGetRouteServerPropagationsOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -53003,7 +53383,7 @@ func (m *awsEc2query_deserializeOpGetSerialConsoleAccessStatus) HandleDeserializ return out, metadata, err } -func awsEc2query_deserializeOpErrorGetSerialConsoleAccessStatus(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorGetRouteServerPropagations(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -53036,14 +53416,14 @@ func awsEc2query_deserializeOpErrorGetSerialConsoleAccessStatus(response *smithy } } -type awsEc2query_deserializeOpGetSnapshotBlockPublicAccessState struct { +type awsEc2query_deserializeOpGetRouteServerRoutingDatabase struct { } -func (*awsEc2query_deserializeOpGetSnapshotBlockPublicAccessState) ID() string { +func (*awsEc2query_deserializeOpGetRouteServerRoutingDatabase) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpGetSnapshotBlockPublicAccessState) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpGetRouteServerRoutingDatabase) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -53061,9 +53441,9 @@ func (m *awsEc2query_deserializeOpGetSnapshotBlockPublicAccessState) HandleDeser } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorGetSnapshotBlockPublicAccessState(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorGetRouteServerRoutingDatabase(response, &metadata) } - output := &GetSnapshotBlockPublicAccessStateOutput{} + output := &GetRouteServerRoutingDatabaseOutput{} out.Result = output var buff [1024]byte @@ -53084,7 +53464,7 @@ func (m *awsEc2query_deserializeOpGetSnapshotBlockPublicAccessState) HandleDeser } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentGetSnapshotBlockPublicAccessStateOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentGetRouteServerRoutingDatabaseOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -53098,7 +53478,7 @@ func (m *awsEc2query_deserializeOpGetSnapshotBlockPublicAccessState) HandleDeser return out, metadata, err } -func awsEc2query_deserializeOpErrorGetSnapshotBlockPublicAccessState(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorGetRouteServerRoutingDatabase(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -53131,14 +53511,14 @@ func awsEc2query_deserializeOpErrorGetSnapshotBlockPublicAccessState(response *s } } -type awsEc2query_deserializeOpGetSpotPlacementScores struct { +type awsEc2query_deserializeOpGetSecurityGroupsForVpc struct { } -func (*awsEc2query_deserializeOpGetSpotPlacementScores) ID() string { +func (*awsEc2query_deserializeOpGetSecurityGroupsForVpc) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpGetSpotPlacementScores) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpGetSecurityGroupsForVpc) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -53156,9 +53536,9 @@ func (m *awsEc2query_deserializeOpGetSpotPlacementScores) HandleDeserialize(ctx } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorGetSpotPlacementScores(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorGetSecurityGroupsForVpc(response, &metadata) } - output := &GetSpotPlacementScoresOutput{} + output := &GetSecurityGroupsForVpcOutput{} out.Result = output var buff [1024]byte @@ -53179,7 +53559,7 @@ func (m *awsEc2query_deserializeOpGetSpotPlacementScores) HandleDeserialize(ctx } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentGetSpotPlacementScoresOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentGetSecurityGroupsForVpcOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -53193,7 +53573,7 @@ func (m *awsEc2query_deserializeOpGetSpotPlacementScores) HandleDeserialize(ctx return out, metadata, err } -func awsEc2query_deserializeOpErrorGetSpotPlacementScores(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorGetSecurityGroupsForVpc(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -53226,14 +53606,14 @@ func awsEc2query_deserializeOpErrorGetSpotPlacementScores(response *smithyhttp.R } } -type awsEc2query_deserializeOpGetSubnetCidrReservations struct { +type awsEc2query_deserializeOpGetSerialConsoleAccessStatus struct { } -func (*awsEc2query_deserializeOpGetSubnetCidrReservations) ID() string { +func (*awsEc2query_deserializeOpGetSerialConsoleAccessStatus) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpGetSubnetCidrReservations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpGetSerialConsoleAccessStatus) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -53251,9 +53631,9 @@ func (m *awsEc2query_deserializeOpGetSubnetCidrReservations) HandleDeserialize(c } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorGetSubnetCidrReservations(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorGetSerialConsoleAccessStatus(response, &metadata) } - output := &GetSubnetCidrReservationsOutput{} + output := &GetSerialConsoleAccessStatusOutput{} out.Result = output var buff [1024]byte @@ -53274,7 +53654,7 @@ func (m *awsEc2query_deserializeOpGetSubnetCidrReservations) HandleDeserialize(c } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentGetSubnetCidrReservationsOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentGetSerialConsoleAccessStatusOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -53288,7 +53668,7 @@ func (m *awsEc2query_deserializeOpGetSubnetCidrReservations) HandleDeserialize(c return out, metadata, err } -func awsEc2query_deserializeOpErrorGetSubnetCidrReservations(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorGetSerialConsoleAccessStatus(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -53321,14 +53701,14 @@ func awsEc2query_deserializeOpErrorGetSubnetCidrReservations(response *smithyhtt } } -type awsEc2query_deserializeOpGetTransitGatewayAttachmentPropagations struct { +type awsEc2query_deserializeOpGetSnapshotBlockPublicAccessState struct { } -func (*awsEc2query_deserializeOpGetTransitGatewayAttachmentPropagations) ID() string { +func (*awsEc2query_deserializeOpGetSnapshotBlockPublicAccessState) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpGetTransitGatewayAttachmentPropagations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpGetSnapshotBlockPublicAccessState) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -53346,9 +53726,9 @@ func (m *awsEc2query_deserializeOpGetTransitGatewayAttachmentPropagations) Handl } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorGetTransitGatewayAttachmentPropagations(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorGetSnapshotBlockPublicAccessState(response, &metadata) } - output := &GetTransitGatewayAttachmentPropagationsOutput{} + output := &GetSnapshotBlockPublicAccessStateOutput{} out.Result = output var buff [1024]byte @@ -53369,7 +53749,7 @@ func (m *awsEc2query_deserializeOpGetTransitGatewayAttachmentPropagations) Handl } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentGetTransitGatewayAttachmentPropagationsOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentGetSnapshotBlockPublicAccessStateOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -53383,7 +53763,7 @@ func (m *awsEc2query_deserializeOpGetTransitGatewayAttachmentPropagations) Handl return out, metadata, err } -func awsEc2query_deserializeOpErrorGetTransitGatewayAttachmentPropagations(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorGetSnapshotBlockPublicAccessState(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -53416,14 +53796,14 @@ func awsEc2query_deserializeOpErrorGetTransitGatewayAttachmentPropagations(respo } } -type awsEc2query_deserializeOpGetTransitGatewayMeteringPolicyEntries struct { +type awsEc2query_deserializeOpGetSpotPlacementScores struct { } -func (*awsEc2query_deserializeOpGetTransitGatewayMeteringPolicyEntries) ID() string { +func (*awsEc2query_deserializeOpGetSpotPlacementScores) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpGetTransitGatewayMeteringPolicyEntries) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpGetSpotPlacementScores) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -53441,9 +53821,9 @@ func (m *awsEc2query_deserializeOpGetTransitGatewayMeteringPolicyEntries) Handle } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorGetTransitGatewayMeteringPolicyEntries(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorGetSpotPlacementScores(response, &metadata) } - output := &GetTransitGatewayMeteringPolicyEntriesOutput{} + output := &GetSpotPlacementScoresOutput{} out.Result = output var buff [1024]byte @@ -53464,7 +53844,7 @@ func (m *awsEc2query_deserializeOpGetTransitGatewayMeteringPolicyEntries) Handle } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentGetTransitGatewayMeteringPolicyEntriesOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentGetSpotPlacementScoresOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -53478,7 +53858,7 @@ func (m *awsEc2query_deserializeOpGetTransitGatewayMeteringPolicyEntries) Handle return out, metadata, err } -func awsEc2query_deserializeOpErrorGetTransitGatewayMeteringPolicyEntries(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorGetSpotPlacementScores(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -53511,14 +53891,14 @@ func awsEc2query_deserializeOpErrorGetTransitGatewayMeteringPolicyEntries(respon } } -type awsEc2query_deserializeOpGetTransitGatewayMulticastDomainAssociations struct { +type awsEc2query_deserializeOpGetSubnetCidrReservations struct { } -func (*awsEc2query_deserializeOpGetTransitGatewayMulticastDomainAssociations) ID() string { +func (*awsEc2query_deserializeOpGetSubnetCidrReservations) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpGetTransitGatewayMulticastDomainAssociations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpGetSubnetCidrReservations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -53536,9 +53916,9 @@ func (m *awsEc2query_deserializeOpGetTransitGatewayMulticastDomainAssociations) } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorGetTransitGatewayMulticastDomainAssociations(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorGetSubnetCidrReservations(response, &metadata) } - output := &GetTransitGatewayMulticastDomainAssociationsOutput{} + output := &GetSubnetCidrReservationsOutput{} out.Result = output var buff [1024]byte @@ -53559,7 +53939,7 @@ func (m *awsEc2query_deserializeOpGetTransitGatewayMulticastDomainAssociations) } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentGetTransitGatewayMulticastDomainAssociationsOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentGetSubnetCidrReservationsOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -53573,7 +53953,7 @@ func (m *awsEc2query_deserializeOpGetTransitGatewayMulticastDomainAssociations) return out, metadata, err } -func awsEc2query_deserializeOpErrorGetTransitGatewayMulticastDomainAssociations(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorGetSubnetCidrReservations(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -53606,14 +53986,14 @@ func awsEc2query_deserializeOpErrorGetTransitGatewayMulticastDomainAssociations( } } -type awsEc2query_deserializeOpGetTransitGatewayPolicyTableAssociations struct { +type awsEc2query_deserializeOpGetTransitGatewayAttachmentPropagations struct { } -func (*awsEc2query_deserializeOpGetTransitGatewayPolicyTableAssociations) ID() string { +func (*awsEc2query_deserializeOpGetTransitGatewayAttachmentPropagations) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpGetTransitGatewayPolicyTableAssociations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpGetTransitGatewayAttachmentPropagations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -53631,9 +54011,9 @@ func (m *awsEc2query_deserializeOpGetTransitGatewayPolicyTableAssociations) Hand } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorGetTransitGatewayPolicyTableAssociations(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorGetTransitGatewayAttachmentPropagations(response, &metadata) } - output := &GetTransitGatewayPolicyTableAssociationsOutput{} + output := &GetTransitGatewayAttachmentPropagationsOutput{} out.Result = output var buff [1024]byte @@ -53654,7 +54034,7 @@ func (m *awsEc2query_deserializeOpGetTransitGatewayPolicyTableAssociations) Hand } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentGetTransitGatewayPolicyTableAssociationsOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentGetTransitGatewayAttachmentPropagationsOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -53668,7 +54048,7 @@ func (m *awsEc2query_deserializeOpGetTransitGatewayPolicyTableAssociations) Hand return out, metadata, err } -func awsEc2query_deserializeOpErrorGetTransitGatewayPolicyTableAssociations(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorGetTransitGatewayAttachmentPropagations(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -53701,14 +54081,14 @@ func awsEc2query_deserializeOpErrorGetTransitGatewayPolicyTableAssociations(resp } } -type awsEc2query_deserializeOpGetTransitGatewayPolicyTableEntries struct { +type awsEc2query_deserializeOpGetTransitGatewayMeteringPolicyEntries struct { } -func (*awsEc2query_deserializeOpGetTransitGatewayPolicyTableEntries) ID() string { +func (*awsEc2query_deserializeOpGetTransitGatewayMeteringPolicyEntries) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpGetTransitGatewayPolicyTableEntries) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpGetTransitGatewayMeteringPolicyEntries) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -53726,9 +54106,9 @@ func (m *awsEc2query_deserializeOpGetTransitGatewayPolicyTableEntries) HandleDes } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorGetTransitGatewayPolicyTableEntries(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorGetTransitGatewayMeteringPolicyEntries(response, &metadata) } - output := &GetTransitGatewayPolicyTableEntriesOutput{} + output := &GetTransitGatewayMeteringPolicyEntriesOutput{} out.Result = output var buff [1024]byte @@ -53749,7 +54129,7 @@ func (m *awsEc2query_deserializeOpGetTransitGatewayPolicyTableEntries) HandleDes } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentGetTransitGatewayPolicyTableEntriesOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentGetTransitGatewayMeteringPolicyEntriesOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -53763,7 +54143,7 @@ func (m *awsEc2query_deserializeOpGetTransitGatewayPolicyTableEntries) HandleDes return out, metadata, err } -func awsEc2query_deserializeOpErrorGetTransitGatewayPolicyTableEntries(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorGetTransitGatewayMeteringPolicyEntries(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -53796,14 +54176,14 @@ func awsEc2query_deserializeOpErrorGetTransitGatewayPolicyTableEntries(response } } -type awsEc2query_deserializeOpGetTransitGatewayPrefixListReferences struct { +type awsEc2query_deserializeOpGetTransitGatewayMulticastDomainAssociations struct { } -func (*awsEc2query_deserializeOpGetTransitGatewayPrefixListReferences) ID() string { +func (*awsEc2query_deserializeOpGetTransitGatewayMulticastDomainAssociations) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpGetTransitGatewayPrefixListReferences) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpGetTransitGatewayMulticastDomainAssociations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -53821,9 +54201,9 @@ func (m *awsEc2query_deserializeOpGetTransitGatewayPrefixListReferences) HandleD } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorGetTransitGatewayPrefixListReferences(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorGetTransitGatewayMulticastDomainAssociations(response, &metadata) } - output := &GetTransitGatewayPrefixListReferencesOutput{} + output := &GetTransitGatewayMulticastDomainAssociationsOutput{} out.Result = output var buff [1024]byte @@ -53844,7 +54224,7 @@ func (m *awsEc2query_deserializeOpGetTransitGatewayPrefixListReferences) HandleD } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentGetTransitGatewayPrefixListReferencesOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentGetTransitGatewayMulticastDomainAssociationsOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -53858,7 +54238,7 @@ func (m *awsEc2query_deserializeOpGetTransitGatewayPrefixListReferences) HandleD return out, metadata, err } -func awsEc2query_deserializeOpErrorGetTransitGatewayPrefixListReferences(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorGetTransitGatewayMulticastDomainAssociations(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -53891,14 +54271,14 @@ func awsEc2query_deserializeOpErrorGetTransitGatewayPrefixListReferences(respons } } -type awsEc2query_deserializeOpGetTransitGatewayRouteTableAssociations struct { +type awsEc2query_deserializeOpGetTransitGatewayPolicyTableAssociations struct { } -func (*awsEc2query_deserializeOpGetTransitGatewayRouteTableAssociations) ID() string { +func (*awsEc2query_deserializeOpGetTransitGatewayPolicyTableAssociations) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpGetTransitGatewayRouteTableAssociations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpGetTransitGatewayPolicyTableAssociations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -53916,9 +54296,9 @@ func (m *awsEc2query_deserializeOpGetTransitGatewayRouteTableAssociations) Handl } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorGetTransitGatewayRouteTableAssociations(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorGetTransitGatewayPolicyTableAssociations(response, &metadata) } - output := &GetTransitGatewayRouteTableAssociationsOutput{} + output := &GetTransitGatewayPolicyTableAssociationsOutput{} out.Result = output var buff [1024]byte @@ -53939,7 +54319,7 @@ func (m *awsEc2query_deserializeOpGetTransitGatewayRouteTableAssociations) Handl } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentGetTransitGatewayRouteTableAssociationsOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentGetTransitGatewayPolicyTableAssociationsOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -53953,7 +54333,7 @@ func (m *awsEc2query_deserializeOpGetTransitGatewayRouteTableAssociations) Handl return out, metadata, err } -func awsEc2query_deserializeOpErrorGetTransitGatewayRouteTableAssociations(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorGetTransitGatewayPolicyTableAssociations(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -53986,14 +54366,14 @@ func awsEc2query_deserializeOpErrorGetTransitGatewayRouteTableAssociations(respo } } -type awsEc2query_deserializeOpGetTransitGatewayRouteTablePropagations struct { +type awsEc2query_deserializeOpGetTransitGatewayPolicyTableEntries struct { } -func (*awsEc2query_deserializeOpGetTransitGatewayRouteTablePropagations) ID() string { +func (*awsEc2query_deserializeOpGetTransitGatewayPolicyTableEntries) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpGetTransitGatewayRouteTablePropagations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpGetTransitGatewayPolicyTableEntries) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -54011,9 +54391,9 @@ func (m *awsEc2query_deserializeOpGetTransitGatewayRouteTablePropagations) Handl } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorGetTransitGatewayRouteTablePropagations(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorGetTransitGatewayPolicyTableEntries(response, &metadata) } - output := &GetTransitGatewayRouteTablePropagationsOutput{} + output := &GetTransitGatewayPolicyTableEntriesOutput{} out.Result = output var buff [1024]byte @@ -54034,7 +54414,7 @@ func (m *awsEc2query_deserializeOpGetTransitGatewayRouteTablePropagations) Handl } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentGetTransitGatewayRouteTablePropagationsOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentGetTransitGatewayPolicyTableEntriesOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -54048,7 +54428,7 @@ func (m *awsEc2query_deserializeOpGetTransitGatewayRouteTablePropagations) Handl return out, metadata, err } -func awsEc2query_deserializeOpErrorGetTransitGatewayRouteTablePropagations(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorGetTransitGatewayPolicyTableEntries(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -54081,14 +54461,14 @@ func awsEc2query_deserializeOpErrorGetTransitGatewayRouteTablePropagations(respo } } -type awsEc2query_deserializeOpGetVerifiedAccessEndpointPolicy struct { +type awsEc2query_deserializeOpGetTransitGatewayPrefixListReferences struct { } -func (*awsEc2query_deserializeOpGetVerifiedAccessEndpointPolicy) ID() string { +func (*awsEc2query_deserializeOpGetTransitGatewayPrefixListReferences) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpGetVerifiedAccessEndpointPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpGetTransitGatewayPrefixListReferences) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -54106,9 +54486,9 @@ func (m *awsEc2query_deserializeOpGetVerifiedAccessEndpointPolicy) HandleDeseria } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorGetVerifiedAccessEndpointPolicy(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorGetTransitGatewayPrefixListReferences(response, &metadata) } - output := &GetVerifiedAccessEndpointPolicyOutput{} + output := &GetTransitGatewayPrefixListReferencesOutput{} out.Result = output var buff [1024]byte @@ -54129,7 +54509,7 @@ func (m *awsEc2query_deserializeOpGetVerifiedAccessEndpointPolicy) HandleDeseria } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentGetVerifiedAccessEndpointPolicyOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentGetTransitGatewayPrefixListReferencesOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -54143,7 +54523,7 @@ func (m *awsEc2query_deserializeOpGetVerifiedAccessEndpointPolicy) HandleDeseria return out, metadata, err } -func awsEc2query_deserializeOpErrorGetVerifiedAccessEndpointPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorGetTransitGatewayPrefixListReferences(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -54176,14 +54556,14 @@ func awsEc2query_deserializeOpErrorGetVerifiedAccessEndpointPolicy(response *smi } } -type awsEc2query_deserializeOpGetVerifiedAccessEndpointTargets struct { +type awsEc2query_deserializeOpGetTransitGatewayRouteTableAssociations struct { } -func (*awsEc2query_deserializeOpGetVerifiedAccessEndpointTargets) ID() string { +func (*awsEc2query_deserializeOpGetTransitGatewayRouteTableAssociations) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpGetVerifiedAccessEndpointTargets) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpGetTransitGatewayRouteTableAssociations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -54201,9 +54581,9 @@ func (m *awsEc2query_deserializeOpGetVerifiedAccessEndpointTargets) HandleDeseri } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorGetVerifiedAccessEndpointTargets(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorGetTransitGatewayRouteTableAssociations(response, &metadata) } - output := &GetVerifiedAccessEndpointTargetsOutput{} + output := &GetTransitGatewayRouteTableAssociationsOutput{} out.Result = output var buff [1024]byte @@ -54224,7 +54604,7 @@ func (m *awsEc2query_deserializeOpGetVerifiedAccessEndpointTargets) HandleDeseri } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentGetVerifiedAccessEndpointTargetsOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentGetTransitGatewayRouteTableAssociationsOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -54238,7 +54618,7 @@ func (m *awsEc2query_deserializeOpGetVerifiedAccessEndpointTargets) HandleDeseri return out, metadata, err } -func awsEc2query_deserializeOpErrorGetVerifiedAccessEndpointTargets(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorGetTransitGatewayRouteTableAssociations(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -54271,14 +54651,14 @@ func awsEc2query_deserializeOpErrorGetVerifiedAccessEndpointTargets(response *sm } } -type awsEc2query_deserializeOpGetVerifiedAccessGroupPolicy struct { +type awsEc2query_deserializeOpGetTransitGatewayRouteTablePropagations struct { } -func (*awsEc2query_deserializeOpGetVerifiedAccessGroupPolicy) ID() string { +func (*awsEc2query_deserializeOpGetTransitGatewayRouteTablePropagations) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpGetVerifiedAccessGroupPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpGetTransitGatewayRouteTablePropagations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -54296,9 +54676,9 @@ func (m *awsEc2query_deserializeOpGetVerifiedAccessGroupPolicy) HandleDeserializ } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorGetVerifiedAccessGroupPolicy(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorGetTransitGatewayRouteTablePropagations(response, &metadata) } - output := &GetVerifiedAccessGroupPolicyOutput{} + output := &GetTransitGatewayRouteTablePropagationsOutput{} out.Result = output var buff [1024]byte @@ -54319,7 +54699,7 @@ func (m *awsEc2query_deserializeOpGetVerifiedAccessGroupPolicy) HandleDeserializ } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentGetVerifiedAccessGroupPolicyOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentGetTransitGatewayRouteTablePropagationsOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -54333,7 +54713,7 @@ func (m *awsEc2query_deserializeOpGetVerifiedAccessGroupPolicy) HandleDeserializ return out, metadata, err } -func awsEc2query_deserializeOpErrorGetVerifiedAccessGroupPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorGetTransitGatewayRouteTablePropagations(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -54366,14 +54746,14 @@ func awsEc2query_deserializeOpErrorGetVerifiedAccessGroupPolicy(response *smithy } } -type awsEc2query_deserializeOpGetVpcResourcesBlockingEncryptionEnforcement struct { +type awsEc2query_deserializeOpGetVerifiedAccessEndpointPolicy struct { } -func (*awsEc2query_deserializeOpGetVpcResourcesBlockingEncryptionEnforcement) ID() string { +func (*awsEc2query_deserializeOpGetVerifiedAccessEndpointPolicy) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpGetVpcResourcesBlockingEncryptionEnforcement) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpGetVerifiedAccessEndpointPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -54391,9 +54771,9 @@ func (m *awsEc2query_deserializeOpGetVpcResourcesBlockingEncryptionEnforcement) } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorGetVpcResourcesBlockingEncryptionEnforcement(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorGetVerifiedAccessEndpointPolicy(response, &metadata) } - output := &GetVpcResourcesBlockingEncryptionEnforcementOutput{} + output := &GetVerifiedAccessEndpointPolicyOutput{} out.Result = output var buff [1024]byte @@ -54414,7 +54794,7 @@ func (m *awsEc2query_deserializeOpGetVpcResourcesBlockingEncryptionEnforcement) } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentGetVpcResourcesBlockingEncryptionEnforcementOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentGetVerifiedAccessEndpointPolicyOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -54428,7 +54808,7 @@ func (m *awsEc2query_deserializeOpGetVpcResourcesBlockingEncryptionEnforcement) return out, metadata, err } -func awsEc2query_deserializeOpErrorGetVpcResourcesBlockingEncryptionEnforcement(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorGetVerifiedAccessEndpointPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -54461,14 +54841,14 @@ func awsEc2query_deserializeOpErrorGetVpcResourcesBlockingEncryptionEnforcement( } } -type awsEc2query_deserializeOpGetVpnConnectionDeviceSampleConfiguration struct { +type awsEc2query_deserializeOpGetVerifiedAccessEndpointTargets struct { } -func (*awsEc2query_deserializeOpGetVpnConnectionDeviceSampleConfiguration) ID() string { +func (*awsEc2query_deserializeOpGetVerifiedAccessEndpointTargets) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpGetVpnConnectionDeviceSampleConfiguration) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpGetVerifiedAccessEndpointTargets) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -54486,9 +54866,9 @@ func (m *awsEc2query_deserializeOpGetVpnConnectionDeviceSampleConfiguration) Han } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorGetVpnConnectionDeviceSampleConfiguration(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorGetVerifiedAccessEndpointTargets(response, &metadata) } - output := &GetVpnConnectionDeviceSampleConfigurationOutput{} + output := &GetVerifiedAccessEndpointTargetsOutput{} out.Result = output var buff [1024]byte @@ -54509,7 +54889,7 @@ func (m *awsEc2query_deserializeOpGetVpnConnectionDeviceSampleConfiguration) Han } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentGetVpnConnectionDeviceSampleConfigurationOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentGetVerifiedAccessEndpointTargetsOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -54523,7 +54903,7 @@ func (m *awsEc2query_deserializeOpGetVpnConnectionDeviceSampleConfiguration) Han return out, metadata, err } -func awsEc2query_deserializeOpErrorGetVpnConnectionDeviceSampleConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorGetVerifiedAccessEndpointTargets(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -54556,14 +54936,14 @@ func awsEc2query_deserializeOpErrorGetVpnConnectionDeviceSampleConfiguration(res } } -type awsEc2query_deserializeOpGetVpnConnectionDeviceTypes struct { +type awsEc2query_deserializeOpGetVerifiedAccessGroupPolicy struct { } -func (*awsEc2query_deserializeOpGetVpnConnectionDeviceTypes) ID() string { +func (*awsEc2query_deserializeOpGetVerifiedAccessGroupPolicy) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpGetVpnConnectionDeviceTypes) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpGetVerifiedAccessGroupPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -54581,9 +54961,9 @@ func (m *awsEc2query_deserializeOpGetVpnConnectionDeviceTypes) HandleDeserialize } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorGetVpnConnectionDeviceTypes(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorGetVerifiedAccessGroupPolicy(response, &metadata) } - output := &GetVpnConnectionDeviceTypesOutput{} + output := &GetVerifiedAccessGroupPolicyOutput{} out.Result = output var buff [1024]byte @@ -54604,7 +54984,7 @@ func (m *awsEc2query_deserializeOpGetVpnConnectionDeviceTypes) HandleDeserialize } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentGetVpnConnectionDeviceTypesOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentGetVerifiedAccessGroupPolicyOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -54618,7 +54998,7 @@ func (m *awsEc2query_deserializeOpGetVpnConnectionDeviceTypes) HandleDeserialize return out, metadata, err } -func awsEc2query_deserializeOpErrorGetVpnConnectionDeviceTypes(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorGetVerifiedAccessGroupPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -54651,14 +55031,14 @@ func awsEc2query_deserializeOpErrorGetVpnConnectionDeviceTypes(response *smithyh } } -type awsEc2query_deserializeOpGetVpnTunnelReplacementStatus struct { +type awsEc2query_deserializeOpGetVpcResourcesBlockingEncryptionEnforcement struct { } -func (*awsEc2query_deserializeOpGetVpnTunnelReplacementStatus) ID() string { +func (*awsEc2query_deserializeOpGetVpcResourcesBlockingEncryptionEnforcement) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpGetVpnTunnelReplacementStatus) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpGetVpcResourcesBlockingEncryptionEnforcement) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -54676,9 +55056,9 @@ func (m *awsEc2query_deserializeOpGetVpnTunnelReplacementStatus) HandleDeseriali } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorGetVpnTunnelReplacementStatus(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorGetVpcResourcesBlockingEncryptionEnforcement(response, &metadata) } - output := &GetVpnTunnelReplacementStatusOutput{} + output := &GetVpcResourcesBlockingEncryptionEnforcementOutput{} out.Result = output var buff [1024]byte @@ -54699,7 +55079,7 @@ func (m *awsEc2query_deserializeOpGetVpnTunnelReplacementStatus) HandleDeseriali } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentGetVpnTunnelReplacementStatusOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentGetVpcResourcesBlockingEncryptionEnforcementOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -54713,7 +55093,7 @@ func (m *awsEc2query_deserializeOpGetVpnTunnelReplacementStatus) HandleDeseriali return out, metadata, err } -func awsEc2query_deserializeOpErrorGetVpnTunnelReplacementStatus(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorGetVpcResourcesBlockingEncryptionEnforcement(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -54746,14 +55126,14 @@ func awsEc2query_deserializeOpErrorGetVpnTunnelReplacementStatus(response *smith } } -type awsEc2query_deserializeOpImportClientVpnClientCertificateRevocationList struct { +type awsEc2query_deserializeOpGetVpnConnectionDeviceSampleConfiguration struct { } -func (*awsEc2query_deserializeOpImportClientVpnClientCertificateRevocationList) ID() string { +func (*awsEc2query_deserializeOpGetVpnConnectionDeviceSampleConfiguration) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpImportClientVpnClientCertificateRevocationList) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpGetVpnConnectionDeviceSampleConfiguration) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -54771,9 +55151,9 @@ func (m *awsEc2query_deserializeOpImportClientVpnClientCertificateRevocationList } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorImportClientVpnClientCertificateRevocationList(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorGetVpnConnectionDeviceSampleConfiguration(response, &metadata) } - output := &ImportClientVpnClientCertificateRevocationListOutput{} + output := &GetVpnConnectionDeviceSampleConfigurationOutput{} out.Result = output var buff [1024]byte @@ -54794,7 +55174,7 @@ func (m *awsEc2query_deserializeOpImportClientVpnClientCertificateRevocationList } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentImportClientVpnClientCertificateRevocationListOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentGetVpnConnectionDeviceSampleConfigurationOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -54808,7 +55188,7 @@ func (m *awsEc2query_deserializeOpImportClientVpnClientCertificateRevocationList return out, metadata, err } -func awsEc2query_deserializeOpErrorImportClientVpnClientCertificateRevocationList(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorGetVpnConnectionDeviceSampleConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -54841,14 +55221,14 @@ func awsEc2query_deserializeOpErrorImportClientVpnClientCertificateRevocationLis } } -type awsEc2query_deserializeOpImportImage struct { +type awsEc2query_deserializeOpGetVpnConnectionDeviceTypes struct { } -func (*awsEc2query_deserializeOpImportImage) ID() string { +func (*awsEc2query_deserializeOpGetVpnConnectionDeviceTypes) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpImportImage) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpGetVpnConnectionDeviceTypes) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -54866,9 +55246,9 @@ func (m *awsEc2query_deserializeOpImportImage) HandleDeserialize(ctx context.Con } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorImportImage(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorGetVpnConnectionDeviceTypes(response, &metadata) } - output := &ImportImageOutput{} + output := &GetVpnConnectionDeviceTypesOutput{} out.Result = output var buff [1024]byte @@ -54889,7 +55269,7 @@ func (m *awsEc2query_deserializeOpImportImage) HandleDeserialize(ctx context.Con } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentImportImageOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentGetVpnConnectionDeviceTypesOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -54903,7 +55283,7 @@ func (m *awsEc2query_deserializeOpImportImage) HandleDeserialize(ctx context.Con return out, metadata, err } -func awsEc2query_deserializeOpErrorImportImage(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorGetVpnConnectionDeviceTypes(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -54936,14 +55316,14 @@ func awsEc2query_deserializeOpErrorImportImage(response *smithyhttp.Response, me } } -type awsEc2query_deserializeOpImportInstance struct { +type awsEc2query_deserializeOpGetVpnTunnelReplacementStatus struct { } -func (*awsEc2query_deserializeOpImportInstance) ID() string { +func (*awsEc2query_deserializeOpGetVpnTunnelReplacementStatus) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpImportInstance) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpGetVpnTunnelReplacementStatus) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -54961,9 +55341,9 @@ func (m *awsEc2query_deserializeOpImportInstance) HandleDeserialize(ctx context. } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorImportInstance(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorGetVpnTunnelReplacementStatus(response, &metadata) } - output := &ImportInstanceOutput{} + output := &GetVpnTunnelReplacementStatusOutput{} out.Result = output var buff [1024]byte @@ -54984,7 +55364,7 @@ func (m *awsEc2query_deserializeOpImportInstance) HandleDeserialize(ctx context. } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentImportInstanceOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentGetVpnTunnelReplacementStatusOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -54998,7 +55378,7 @@ func (m *awsEc2query_deserializeOpImportInstance) HandleDeserialize(ctx context. return out, metadata, err } -func awsEc2query_deserializeOpErrorImportInstance(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorGetVpnTunnelReplacementStatus(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -55031,14 +55411,14 @@ func awsEc2query_deserializeOpErrorImportInstance(response *smithyhttp.Response, } } -type awsEc2query_deserializeOpImportKeyPair struct { +type awsEc2query_deserializeOpImportClientVpnClientCertificateRevocationList struct { } -func (*awsEc2query_deserializeOpImportKeyPair) ID() string { +func (*awsEc2query_deserializeOpImportClientVpnClientCertificateRevocationList) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpImportKeyPair) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpImportClientVpnClientCertificateRevocationList) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -55056,9 +55436,9 @@ func (m *awsEc2query_deserializeOpImportKeyPair) HandleDeserialize(ctx context.C } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorImportKeyPair(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorImportClientVpnClientCertificateRevocationList(response, &metadata) } - output := &ImportKeyPairOutput{} + output := &ImportClientVpnClientCertificateRevocationListOutput{} out.Result = output var buff [1024]byte @@ -55079,7 +55459,7 @@ func (m *awsEc2query_deserializeOpImportKeyPair) HandleDeserialize(ctx context.C } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentImportKeyPairOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentImportClientVpnClientCertificateRevocationListOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -55093,7 +55473,7 @@ func (m *awsEc2query_deserializeOpImportKeyPair) HandleDeserialize(ctx context.C return out, metadata, err } -func awsEc2query_deserializeOpErrorImportKeyPair(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorImportClientVpnClientCertificateRevocationList(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -55126,14 +55506,14 @@ func awsEc2query_deserializeOpErrorImportKeyPair(response *smithyhttp.Response, } } -type awsEc2query_deserializeOpImportSnapshot struct { +type awsEc2query_deserializeOpImportImage struct { } -func (*awsEc2query_deserializeOpImportSnapshot) ID() string { +func (*awsEc2query_deserializeOpImportImage) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpImportSnapshot) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpImportImage) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -55151,9 +55531,9 @@ func (m *awsEc2query_deserializeOpImportSnapshot) HandleDeserialize(ctx context. } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorImportSnapshot(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorImportImage(response, &metadata) } - output := &ImportSnapshotOutput{} + output := &ImportImageOutput{} out.Result = output var buff [1024]byte @@ -55174,7 +55554,7 @@ func (m *awsEc2query_deserializeOpImportSnapshot) HandleDeserialize(ctx context. } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentImportSnapshotOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentImportImageOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -55188,7 +55568,7 @@ func (m *awsEc2query_deserializeOpImportSnapshot) HandleDeserialize(ctx context. return out, metadata, err } -func awsEc2query_deserializeOpErrorImportSnapshot(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorImportImage(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -55221,14 +55601,14 @@ func awsEc2query_deserializeOpErrorImportSnapshot(response *smithyhttp.Response, } } -type awsEc2query_deserializeOpImportVolume struct { +type awsEc2query_deserializeOpImportInstance struct { } -func (*awsEc2query_deserializeOpImportVolume) ID() string { +func (*awsEc2query_deserializeOpImportInstance) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpImportVolume) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpImportInstance) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -55246,9 +55626,9 @@ func (m *awsEc2query_deserializeOpImportVolume) HandleDeserialize(ctx context.Co } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorImportVolume(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorImportInstance(response, &metadata) } - output := &ImportVolumeOutput{} + output := &ImportInstanceOutput{} out.Result = output var buff [1024]byte @@ -55269,7 +55649,7 @@ func (m *awsEc2query_deserializeOpImportVolume) HandleDeserialize(ctx context.Co } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentImportVolumeOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentImportInstanceOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -55283,7 +55663,7 @@ func (m *awsEc2query_deserializeOpImportVolume) HandleDeserialize(ctx context.Co return out, metadata, err } -func awsEc2query_deserializeOpErrorImportVolume(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorImportInstance(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -55316,14 +55696,14 @@ func awsEc2query_deserializeOpErrorImportVolume(response *smithyhttp.Response, m } } -type awsEc2query_deserializeOpListImagesInRecycleBin struct { +type awsEc2query_deserializeOpImportKeyPair struct { } -func (*awsEc2query_deserializeOpListImagesInRecycleBin) ID() string { +func (*awsEc2query_deserializeOpImportKeyPair) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpListImagesInRecycleBin) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpImportKeyPair) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -55341,9 +55721,9 @@ func (m *awsEc2query_deserializeOpListImagesInRecycleBin) HandleDeserialize(ctx } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorListImagesInRecycleBin(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorImportKeyPair(response, &metadata) } - output := &ListImagesInRecycleBinOutput{} + output := &ImportKeyPairOutput{} out.Result = output var buff [1024]byte @@ -55364,7 +55744,7 @@ func (m *awsEc2query_deserializeOpListImagesInRecycleBin) HandleDeserialize(ctx } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentListImagesInRecycleBinOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentImportKeyPairOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -55378,7 +55758,7 @@ func (m *awsEc2query_deserializeOpListImagesInRecycleBin) HandleDeserialize(ctx return out, metadata, err } -func awsEc2query_deserializeOpErrorListImagesInRecycleBin(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorImportKeyPair(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -55411,14 +55791,14 @@ func awsEc2query_deserializeOpErrorListImagesInRecycleBin(response *smithyhttp.R } } -type awsEc2query_deserializeOpListSnapshotsInRecycleBin struct { +type awsEc2query_deserializeOpImportSnapshot struct { } -func (*awsEc2query_deserializeOpListSnapshotsInRecycleBin) ID() string { +func (*awsEc2query_deserializeOpImportSnapshot) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpListSnapshotsInRecycleBin) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpImportSnapshot) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -55436,9 +55816,9 @@ func (m *awsEc2query_deserializeOpListSnapshotsInRecycleBin) HandleDeserialize(c } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorListSnapshotsInRecycleBin(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorImportSnapshot(response, &metadata) } - output := &ListSnapshotsInRecycleBinOutput{} + output := &ImportSnapshotOutput{} out.Result = output var buff [1024]byte @@ -55459,7 +55839,7 @@ func (m *awsEc2query_deserializeOpListSnapshotsInRecycleBin) HandleDeserialize(c } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentListSnapshotsInRecycleBinOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentImportSnapshotOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -55473,7 +55853,7 @@ func (m *awsEc2query_deserializeOpListSnapshotsInRecycleBin) HandleDeserialize(c return out, metadata, err } -func awsEc2query_deserializeOpErrorListSnapshotsInRecycleBin(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorImportSnapshot(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -55506,14 +55886,14 @@ func awsEc2query_deserializeOpErrorListSnapshotsInRecycleBin(response *smithyhtt } } -type awsEc2query_deserializeOpListVolumesInRecycleBin struct { +type awsEc2query_deserializeOpImportVolume struct { } -func (*awsEc2query_deserializeOpListVolumesInRecycleBin) ID() string { +func (*awsEc2query_deserializeOpImportVolume) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpListVolumesInRecycleBin) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpImportVolume) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -55531,9 +55911,9 @@ func (m *awsEc2query_deserializeOpListVolumesInRecycleBin) HandleDeserialize(ctx } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorListVolumesInRecycleBin(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorImportVolume(response, &metadata) } - output := &ListVolumesInRecycleBinOutput{} + output := &ImportVolumeOutput{} out.Result = output var buff [1024]byte @@ -55554,7 +55934,7 @@ func (m *awsEc2query_deserializeOpListVolumesInRecycleBin) HandleDeserialize(ctx } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentListVolumesInRecycleBinOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentImportVolumeOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -55568,7 +55948,7 @@ func (m *awsEc2query_deserializeOpListVolumesInRecycleBin) HandleDeserialize(ctx return out, metadata, err } -func awsEc2query_deserializeOpErrorListVolumesInRecycleBin(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorImportVolume(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -55601,14 +55981,14 @@ func awsEc2query_deserializeOpErrorListVolumesInRecycleBin(response *smithyhttp. } } -type awsEc2query_deserializeOpLockSnapshot struct { +type awsEc2query_deserializeOpListImagesInRecycleBin struct { } -func (*awsEc2query_deserializeOpLockSnapshot) ID() string { +func (*awsEc2query_deserializeOpListImagesInRecycleBin) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpLockSnapshot) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpListImagesInRecycleBin) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -55626,9 +56006,9 @@ func (m *awsEc2query_deserializeOpLockSnapshot) HandleDeserialize(ctx context.Co } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorLockSnapshot(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorListImagesInRecycleBin(response, &metadata) } - output := &LockSnapshotOutput{} + output := &ListImagesInRecycleBinOutput{} out.Result = output var buff [1024]byte @@ -55649,7 +56029,7 @@ func (m *awsEc2query_deserializeOpLockSnapshot) HandleDeserialize(ctx context.Co } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentLockSnapshotOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentListImagesInRecycleBinOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -55663,7 +56043,7 @@ func (m *awsEc2query_deserializeOpLockSnapshot) HandleDeserialize(ctx context.Co return out, metadata, err } -func awsEc2query_deserializeOpErrorLockSnapshot(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorListImagesInRecycleBin(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -55696,14 +56076,14 @@ func awsEc2query_deserializeOpErrorLockSnapshot(response *smithyhttp.Response, m } } -type awsEc2query_deserializeOpModifyAddressAttribute struct { +type awsEc2query_deserializeOpListSnapshotsInRecycleBin struct { } -func (*awsEc2query_deserializeOpModifyAddressAttribute) ID() string { +func (*awsEc2query_deserializeOpListSnapshotsInRecycleBin) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpModifyAddressAttribute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpListSnapshotsInRecycleBin) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -55721,9 +56101,9 @@ func (m *awsEc2query_deserializeOpModifyAddressAttribute) HandleDeserialize(ctx } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorModifyAddressAttribute(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorListSnapshotsInRecycleBin(response, &metadata) } - output := &ModifyAddressAttributeOutput{} + output := &ListSnapshotsInRecycleBinOutput{} out.Result = output var buff [1024]byte @@ -55744,7 +56124,7 @@ func (m *awsEc2query_deserializeOpModifyAddressAttribute) HandleDeserialize(ctx } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentModifyAddressAttributeOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentListSnapshotsInRecycleBinOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -55758,7 +56138,7 @@ func (m *awsEc2query_deserializeOpModifyAddressAttribute) HandleDeserialize(ctx return out, metadata, err } -func awsEc2query_deserializeOpErrorModifyAddressAttribute(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorListSnapshotsInRecycleBin(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -55791,14 +56171,14 @@ func awsEc2query_deserializeOpErrorModifyAddressAttribute(response *smithyhttp.R } } -type awsEc2query_deserializeOpModifyAvailabilityZoneGroup struct { +type awsEc2query_deserializeOpListVolumesInRecycleBin struct { } -func (*awsEc2query_deserializeOpModifyAvailabilityZoneGroup) ID() string { +func (*awsEc2query_deserializeOpListVolumesInRecycleBin) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpModifyAvailabilityZoneGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpListVolumesInRecycleBin) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -55816,9 +56196,9 @@ func (m *awsEc2query_deserializeOpModifyAvailabilityZoneGroup) HandleDeserialize } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorModifyAvailabilityZoneGroup(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorListVolumesInRecycleBin(response, &metadata) } - output := &ModifyAvailabilityZoneGroupOutput{} + output := &ListVolumesInRecycleBinOutput{} out.Result = output var buff [1024]byte @@ -55839,7 +56219,7 @@ func (m *awsEc2query_deserializeOpModifyAvailabilityZoneGroup) HandleDeserialize } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentModifyAvailabilityZoneGroupOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentListVolumesInRecycleBinOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -55853,7 +56233,7 @@ func (m *awsEc2query_deserializeOpModifyAvailabilityZoneGroup) HandleDeserialize return out, metadata, err } -func awsEc2query_deserializeOpErrorModifyAvailabilityZoneGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorListVolumesInRecycleBin(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -55886,14 +56266,14 @@ func awsEc2query_deserializeOpErrorModifyAvailabilityZoneGroup(response *smithyh } } -type awsEc2query_deserializeOpModifyCapacityReservation struct { +type awsEc2query_deserializeOpLockSnapshot struct { } -func (*awsEc2query_deserializeOpModifyCapacityReservation) ID() string { +func (*awsEc2query_deserializeOpLockSnapshot) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpModifyCapacityReservation) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpLockSnapshot) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -55911,9 +56291,9 @@ func (m *awsEc2query_deserializeOpModifyCapacityReservation) HandleDeserialize(c } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorModifyCapacityReservation(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorLockSnapshot(response, &metadata) } - output := &ModifyCapacityReservationOutput{} + output := &LockSnapshotOutput{} out.Result = output var buff [1024]byte @@ -55934,7 +56314,7 @@ func (m *awsEc2query_deserializeOpModifyCapacityReservation) HandleDeserialize(c } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentModifyCapacityReservationOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentLockSnapshotOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -55948,7 +56328,7 @@ func (m *awsEc2query_deserializeOpModifyCapacityReservation) HandleDeserialize(c return out, metadata, err } -func awsEc2query_deserializeOpErrorModifyCapacityReservation(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorLockSnapshot(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -55981,14 +56361,14 @@ func awsEc2query_deserializeOpErrorModifyCapacityReservation(response *smithyhtt } } -type awsEc2query_deserializeOpModifyCapacityReservationFleet struct { +type awsEc2query_deserializeOpModifyAddressAttribute struct { } -func (*awsEc2query_deserializeOpModifyCapacityReservationFleet) ID() string { +func (*awsEc2query_deserializeOpModifyAddressAttribute) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpModifyCapacityReservationFleet) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpModifyAddressAttribute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -56006,9 +56386,9 @@ func (m *awsEc2query_deserializeOpModifyCapacityReservationFleet) HandleDeserial } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorModifyCapacityReservationFleet(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorModifyAddressAttribute(response, &metadata) } - output := &ModifyCapacityReservationFleetOutput{} + output := &ModifyAddressAttributeOutput{} out.Result = output var buff [1024]byte @@ -56029,7 +56409,7 @@ func (m *awsEc2query_deserializeOpModifyCapacityReservationFleet) HandleDeserial } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentModifyCapacityReservationFleetOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentModifyAddressAttributeOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -56043,7 +56423,7 @@ func (m *awsEc2query_deserializeOpModifyCapacityReservationFleet) HandleDeserial return out, metadata, err } -func awsEc2query_deserializeOpErrorModifyCapacityReservationFleet(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorModifyAddressAttribute(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -56076,14 +56456,14 @@ func awsEc2query_deserializeOpErrorModifyCapacityReservationFleet(response *smit } } -type awsEc2query_deserializeOpModifyClientVpnEndpoint struct { +type awsEc2query_deserializeOpModifyAvailabilityZoneGroup struct { } -func (*awsEc2query_deserializeOpModifyClientVpnEndpoint) ID() string { +func (*awsEc2query_deserializeOpModifyAvailabilityZoneGroup) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpModifyClientVpnEndpoint) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpModifyAvailabilityZoneGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -56101,9 +56481,9 @@ func (m *awsEc2query_deserializeOpModifyClientVpnEndpoint) HandleDeserialize(ctx } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorModifyClientVpnEndpoint(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorModifyAvailabilityZoneGroup(response, &metadata) } - output := &ModifyClientVpnEndpointOutput{} + output := &ModifyAvailabilityZoneGroupOutput{} out.Result = output var buff [1024]byte @@ -56124,7 +56504,7 @@ func (m *awsEc2query_deserializeOpModifyClientVpnEndpoint) HandleDeserialize(ctx } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentModifyClientVpnEndpointOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentModifyAvailabilityZoneGroupOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -56138,7 +56518,7 @@ func (m *awsEc2query_deserializeOpModifyClientVpnEndpoint) HandleDeserialize(ctx return out, metadata, err } -func awsEc2query_deserializeOpErrorModifyClientVpnEndpoint(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorModifyAvailabilityZoneGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -56171,14 +56551,14 @@ func awsEc2query_deserializeOpErrorModifyClientVpnEndpoint(response *smithyhttp. } } -type awsEc2query_deserializeOpModifyDefaultCreditSpecification struct { +type awsEc2query_deserializeOpModifyCapacityReservation struct { } -func (*awsEc2query_deserializeOpModifyDefaultCreditSpecification) ID() string { +func (*awsEc2query_deserializeOpModifyCapacityReservation) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpModifyDefaultCreditSpecification) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpModifyCapacityReservation) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -56196,9 +56576,9 @@ func (m *awsEc2query_deserializeOpModifyDefaultCreditSpecification) HandleDeseri } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorModifyDefaultCreditSpecification(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorModifyCapacityReservation(response, &metadata) } - output := &ModifyDefaultCreditSpecificationOutput{} + output := &ModifyCapacityReservationOutput{} out.Result = output var buff [1024]byte @@ -56219,7 +56599,7 @@ func (m *awsEc2query_deserializeOpModifyDefaultCreditSpecification) HandleDeseri } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentModifyDefaultCreditSpecificationOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentModifyCapacityReservationOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -56233,7 +56613,7 @@ func (m *awsEc2query_deserializeOpModifyDefaultCreditSpecification) HandleDeseri return out, metadata, err } -func awsEc2query_deserializeOpErrorModifyDefaultCreditSpecification(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorModifyCapacityReservation(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -56266,14 +56646,14 @@ func awsEc2query_deserializeOpErrorModifyDefaultCreditSpecification(response *sm } } -type awsEc2query_deserializeOpModifyEbsDefaultKmsKeyId struct { +type awsEc2query_deserializeOpModifyCapacityReservationFleet struct { } -func (*awsEc2query_deserializeOpModifyEbsDefaultKmsKeyId) ID() string { +func (*awsEc2query_deserializeOpModifyCapacityReservationFleet) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpModifyEbsDefaultKmsKeyId) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpModifyCapacityReservationFleet) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -56291,9 +56671,9 @@ func (m *awsEc2query_deserializeOpModifyEbsDefaultKmsKeyId) HandleDeserialize(ct } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorModifyEbsDefaultKmsKeyId(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorModifyCapacityReservationFleet(response, &metadata) } - output := &ModifyEbsDefaultKmsKeyIdOutput{} + output := &ModifyCapacityReservationFleetOutput{} out.Result = output var buff [1024]byte @@ -56314,7 +56694,7 @@ func (m *awsEc2query_deserializeOpModifyEbsDefaultKmsKeyId) HandleDeserialize(ct } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentModifyEbsDefaultKmsKeyIdOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentModifyCapacityReservationFleetOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -56328,7 +56708,7 @@ func (m *awsEc2query_deserializeOpModifyEbsDefaultKmsKeyId) HandleDeserialize(ct return out, metadata, err } -func awsEc2query_deserializeOpErrorModifyEbsDefaultKmsKeyId(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorModifyCapacityReservationFleet(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -56361,14 +56741,14 @@ func awsEc2query_deserializeOpErrorModifyEbsDefaultKmsKeyId(response *smithyhttp } } -type awsEc2query_deserializeOpModifyFleet struct { +type awsEc2query_deserializeOpModifyClientVpnEndpoint struct { } -func (*awsEc2query_deserializeOpModifyFleet) ID() string { +func (*awsEc2query_deserializeOpModifyClientVpnEndpoint) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpModifyFleet) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpModifyClientVpnEndpoint) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -56386,9 +56766,9 @@ func (m *awsEc2query_deserializeOpModifyFleet) HandleDeserialize(ctx context.Con } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorModifyFleet(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorModifyClientVpnEndpoint(response, &metadata) } - output := &ModifyFleetOutput{} + output := &ModifyClientVpnEndpointOutput{} out.Result = output var buff [1024]byte @@ -56409,7 +56789,7 @@ func (m *awsEc2query_deserializeOpModifyFleet) HandleDeserialize(ctx context.Con } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentModifyFleetOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentModifyClientVpnEndpointOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -56423,7 +56803,7 @@ func (m *awsEc2query_deserializeOpModifyFleet) HandleDeserialize(ctx context.Con return out, metadata, err } -func awsEc2query_deserializeOpErrorModifyFleet(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorModifyClientVpnEndpoint(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -56456,14 +56836,14 @@ func awsEc2query_deserializeOpErrorModifyFleet(response *smithyhttp.Response, me } } -type awsEc2query_deserializeOpModifyFpgaImageAttribute struct { +type awsEc2query_deserializeOpModifyDefaultCreditSpecification struct { } -func (*awsEc2query_deserializeOpModifyFpgaImageAttribute) ID() string { +func (*awsEc2query_deserializeOpModifyDefaultCreditSpecification) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpModifyFpgaImageAttribute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpModifyDefaultCreditSpecification) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -56481,9 +56861,9 @@ func (m *awsEc2query_deserializeOpModifyFpgaImageAttribute) HandleDeserialize(ct } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorModifyFpgaImageAttribute(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorModifyDefaultCreditSpecification(response, &metadata) } - output := &ModifyFpgaImageAttributeOutput{} + output := &ModifyDefaultCreditSpecificationOutput{} out.Result = output var buff [1024]byte @@ -56504,7 +56884,7 @@ func (m *awsEc2query_deserializeOpModifyFpgaImageAttribute) HandleDeserialize(ct } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentModifyFpgaImageAttributeOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentModifyDefaultCreditSpecificationOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -56518,7 +56898,7 @@ func (m *awsEc2query_deserializeOpModifyFpgaImageAttribute) HandleDeserialize(ct return out, metadata, err } -func awsEc2query_deserializeOpErrorModifyFpgaImageAttribute(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorModifyDefaultCreditSpecification(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -56551,14 +56931,14 @@ func awsEc2query_deserializeOpErrorModifyFpgaImageAttribute(response *smithyhttp } } -type awsEc2query_deserializeOpModifyHosts struct { +type awsEc2query_deserializeOpModifyEbsDefaultKmsKeyId struct { } -func (*awsEc2query_deserializeOpModifyHosts) ID() string { +func (*awsEc2query_deserializeOpModifyEbsDefaultKmsKeyId) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpModifyHosts) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpModifyEbsDefaultKmsKeyId) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -56576,9 +56956,9 @@ func (m *awsEc2query_deserializeOpModifyHosts) HandleDeserialize(ctx context.Con } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorModifyHosts(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorModifyEbsDefaultKmsKeyId(response, &metadata) } - output := &ModifyHostsOutput{} + output := &ModifyEbsDefaultKmsKeyIdOutput{} out.Result = output var buff [1024]byte @@ -56599,7 +56979,7 @@ func (m *awsEc2query_deserializeOpModifyHosts) HandleDeserialize(ctx context.Con } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentModifyHostsOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentModifyEbsDefaultKmsKeyIdOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -56613,7 +56993,7 @@ func (m *awsEc2query_deserializeOpModifyHosts) HandleDeserialize(ctx context.Con return out, metadata, err } -func awsEc2query_deserializeOpErrorModifyHosts(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorModifyEbsDefaultKmsKeyId(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -56646,14 +57026,14 @@ func awsEc2query_deserializeOpErrorModifyHosts(response *smithyhttp.Response, me } } -type awsEc2query_deserializeOpModifyIdentityIdFormat struct { +type awsEc2query_deserializeOpModifyFleet struct { } -func (*awsEc2query_deserializeOpModifyIdentityIdFormat) ID() string { +func (*awsEc2query_deserializeOpModifyFleet) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpModifyIdentityIdFormat) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpModifyFleet) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -56671,93 +57051,44 @@ func (m *awsEc2query_deserializeOpModifyIdentityIdFormat) HandleDeserialize(ctx } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorModifyIdentityIdFormat(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorModifyFleet(response, &metadata) } - output := &ModifyIdentityIdFormatOutput{} + output := &ModifyFleetOutput{} 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_deserializeOpErrorModifyIdentityIdFormat(response *smithyhttp.Response, metadata *middleware.Metadata) error { - var errorBuffer bytes.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_deserializeOpModifyIdFormat struct { -} - -func (*awsEc2query_deserializeOpModifyIdFormat) ID() string { - return "OperationDeserializer" -} -func (m *awsEc2query_deserializeOpModifyIdFormat) HandleDeserialize(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_deserializeOpDocumentModifyFleetOutput(&output, decoder) if err != nil { - return out, metadata, err - } - - _, span := tracing.StartSpan(ctx, "OperationDeserializer") - endTimer := startMetricTimer(ctx, "client.call.deserialization_duration") - defer endTimer() - defer span.End() - response, ok := out.RawResponse.(*smithyhttp.Response) - if !ok { - return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} - } - - if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorModifyIdFormat(response, &metadata) - } - output := &ModifyIdFormatOutput{} - 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_deserializeOpErrorModifyIdFormat(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorModifyFleet(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -56790,14 +57121,14 @@ func awsEc2query_deserializeOpErrorModifyIdFormat(response *smithyhttp.Response, } } -type awsEc2query_deserializeOpModifyImageAttribute struct { +type awsEc2query_deserializeOpModifyFpgaImageAttribute struct { } -func (*awsEc2query_deserializeOpModifyImageAttribute) ID() string { +func (*awsEc2query_deserializeOpModifyFpgaImageAttribute) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpModifyImageAttribute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpModifyFpgaImageAttribute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -56815,93 +57146,44 @@ func (m *awsEc2query_deserializeOpModifyImageAttribute) HandleDeserialize(ctx co } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorModifyImageAttribute(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorModifyFpgaImageAttribute(response, &metadata) } - output := &ModifyImageAttributeOutput{} + output := &ModifyFpgaImageAttributeOutput{} 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_deserializeOpErrorModifyImageAttribute(response *smithyhttp.Response, metadata *middleware.Metadata) error { - var errorBuffer bytes.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_deserializeOpModifyInstanceAttribute struct { -} - -func (*awsEc2query_deserializeOpModifyInstanceAttribute) ID() string { - return "OperationDeserializer" -} - -func (m *awsEc2query_deserializeOpModifyInstanceAttribute) HandleDeserialize(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_deserializeOpDocumentModifyFpgaImageAttributeOutput(&output, decoder) if err != nil { - return out, metadata, err - } - - _, span := tracing.StartSpan(ctx, "OperationDeserializer") - endTimer := startMetricTimer(ctx, "client.call.deserialization_duration") - defer endTimer() - defer span.End() - response, ok := out.RawResponse.(*smithyhttp.Response) - if !ok { - return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} - } - - if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorModifyInstanceAttribute(response, &metadata) - } - output := &ModifyInstanceAttributeOutput{} - 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_deserializeOpErrorModifyInstanceAttribute(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorModifyFpgaImageAttribute(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -56934,14 +57216,14 @@ func awsEc2query_deserializeOpErrorModifyInstanceAttribute(response *smithyhttp. } } -type awsEc2query_deserializeOpModifyInstanceCapacityReservationAttributes struct { +type awsEc2query_deserializeOpModifyHosts struct { } -func (*awsEc2query_deserializeOpModifyInstanceCapacityReservationAttributes) ID() string { +func (*awsEc2query_deserializeOpModifyHosts) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpModifyInstanceCapacityReservationAttributes) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpModifyHosts) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -56959,9 +57241,9 @@ func (m *awsEc2query_deserializeOpModifyInstanceCapacityReservationAttributes) H } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorModifyInstanceCapacityReservationAttributes(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorModifyHosts(response, &metadata) } - output := &ModifyInstanceCapacityReservationAttributesOutput{} + output := &ModifyHostsOutput{} out.Result = output var buff [1024]byte @@ -56982,7 +57264,7 @@ func (m *awsEc2query_deserializeOpModifyInstanceCapacityReservationAttributes) H } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentModifyInstanceCapacityReservationAttributesOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentModifyHostsOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -56996,7 +57278,7 @@ func (m *awsEc2query_deserializeOpModifyInstanceCapacityReservationAttributes) H return out, metadata, err } -func awsEc2query_deserializeOpErrorModifyInstanceCapacityReservationAttributes(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorModifyHosts(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -57029,14 +57311,14 @@ func awsEc2query_deserializeOpErrorModifyInstanceCapacityReservationAttributes(r } } -type awsEc2query_deserializeOpModifyInstanceConnectEndpoint struct { +type awsEc2query_deserializeOpModifyIdentityIdFormat struct { } -func (*awsEc2query_deserializeOpModifyInstanceConnectEndpoint) ID() string { +func (*awsEc2query_deserializeOpModifyIdentityIdFormat) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpModifyInstanceConnectEndpoint) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpModifyIdentityIdFormat) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -57054,44 +57336,93 @@ func (m *awsEc2query_deserializeOpModifyInstanceConnectEndpoint) HandleDeseriali } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorModifyInstanceConnectEndpoint(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorModifyIdentityIdFormat(response, &metadata) } - output := &ModifyInstanceConnectEndpointOutput{} + output := &ModifyIdentityIdFormatOutput{} 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_deserializeOpDocumentModifyInstanceConnectEndpointOutput(&output, decoder) + return out, metadata, err +} + +func awsEc2query_deserializeOpErrorModifyIdentityIdFormat(response *smithyhttp.Response, metadata *middleware.Metadata) error { + var errorBuffer bytes.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 { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), + return err + } + 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_deserializeOpModifyIdFormat struct { +} + +func (*awsEc2query_deserializeOpModifyIdFormat) ID() string { + return "OperationDeserializer" +} + +func (m *awsEc2query_deserializeOpModifyIdFormat) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( + out middleware.DeserializeOutput, metadata middleware.Metadata, err error, +) { + out, metadata, err = next.HandleDeserialize(ctx, in) + if err != nil { return out, metadata, err } + _, span := tracing.StartSpan(ctx, "OperationDeserializer") + endTimer := startMetricTimer(ctx, "client.call.deserialization_duration") + defer endTimer() + defer span.End() + response, ok := out.RawResponse.(*smithyhttp.Response) + if !ok { + return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} + } + + if response.StatusCode < 200 || response.StatusCode >= 300 { + return out, metadata, awsEc2query_deserializeOpErrorModifyIdFormat(response, &metadata) + } + output := &ModifyIdFormatOutput{} + 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_deserializeOpErrorModifyInstanceConnectEndpoint(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorModifyIdFormat(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -57124,14 +57455,14 @@ func awsEc2query_deserializeOpErrorModifyInstanceConnectEndpoint(response *smith } } -type awsEc2query_deserializeOpModifyInstanceCpuOptions struct { +type awsEc2query_deserializeOpModifyImageAttribute struct { } -func (*awsEc2query_deserializeOpModifyInstanceCpuOptions) ID() string { +func (*awsEc2query_deserializeOpModifyImageAttribute) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpModifyInstanceCpuOptions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpModifyImageAttribute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -57149,44 +57480,93 @@ func (m *awsEc2query_deserializeOpModifyInstanceCpuOptions) HandleDeserialize(ct } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorModifyInstanceCpuOptions(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorModifyImageAttribute(response, &metadata) } - output := &ModifyInstanceCpuOptionsOutput{} + output := &ModifyImageAttributeOutput{} 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_deserializeOpDocumentModifyInstanceCpuOptionsOutput(&output, decoder) + return out, metadata, err +} + +func awsEc2query_deserializeOpErrorModifyImageAttribute(response *smithyhttp.Response, metadata *middleware.Metadata) error { + var errorBuffer bytes.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 { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), + return err + } + 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_deserializeOpModifyInstanceAttribute struct { +} + +func (*awsEc2query_deserializeOpModifyInstanceAttribute) ID() string { + return "OperationDeserializer" +} + +func (m *awsEc2query_deserializeOpModifyInstanceAttribute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( + out middleware.DeserializeOutput, metadata middleware.Metadata, err error, +) { + out, metadata, err = next.HandleDeserialize(ctx, in) + if err != nil { return out, metadata, err } + _, span := tracing.StartSpan(ctx, "OperationDeserializer") + endTimer := startMetricTimer(ctx, "client.call.deserialization_duration") + defer endTimer() + defer span.End() + response, ok := out.RawResponse.(*smithyhttp.Response) + if !ok { + return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} + } + + if response.StatusCode < 200 || response.StatusCode >= 300 { + return out, metadata, awsEc2query_deserializeOpErrorModifyInstanceAttribute(response, &metadata) + } + output := &ModifyInstanceAttributeOutput{} + 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_deserializeOpErrorModifyInstanceCpuOptions(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorModifyInstanceAttribute(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -57219,14 +57599,14 @@ func awsEc2query_deserializeOpErrorModifyInstanceCpuOptions(response *smithyhttp } } -type awsEc2query_deserializeOpModifyInstanceCreditSpecification struct { +type awsEc2query_deserializeOpModifyInstanceCapacityReservationAttributes struct { } -func (*awsEc2query_deserializeOpModifyInstanceCreditSpecification) ID() string { +func (*awsEc2query_deserializeOpModifyInstanceCapacityReservationAttributes) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpModifyInstanceCreditSpecification) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpModifyInstanceCapacityReservationAttributes) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -57244,9 +57624,9 @@ func (m *awsEc2query_deserializeOpModifyInstanceCreditSpecification) HandleDeser } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorModifyInstanceCreditSpecification(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorModifyInstanceCapacityReservationAttributes(response, &metadata) } - output := &ModifyInstanceCreditSpecificationOutput{} + output := &ModifyInstanceCapacityReservationAttributesOutput{} out.Result = output var buff [1024]byte @@ -57267,7 +57647,7 @@ func (m *awsEc2query_deserializeOpModifyInstanceCreditSpecification) HandleDeser } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentModifyInstanceCreditSpecificationOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentModifyInstanceCapacityReservationAttributesOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -57281,7 +57661,7 @@ func (m *awsEc2query_deserializeOpModifyInstanceCreditSpecification) HandleDeser return out, metadata, err } -func awsEc2query_deserializeOpErrorModifyInstanceCreditSpecification(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorModifyInstanceCapacityReservationAttributes(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -57314,14 +57694,14 @@ func awsEc2query_deserializeOpErrorModifyInstanceCreditSpecification(response *s } } -type awsEc2query_deserializeOpModifyInstanceEventStartTime struct { +type awsEc2query_deserializeOpModifyInstanceConnectEndpoint struct { } -func (*awsEc2query_deserializeOpModifyInstanceEventStartTime) ID() string { +func (*awsEc2query_deserializeOpModifyInstanceConnectEndpoint) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpModifyInstanceEventStartTime) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpModifyInstanceConnectEndpoint) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -57339,9 +57719,9 @@ func (m *awsEc2query_deserializeOpModifyInstanceEventStartTime) HandleDeserializ } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorModifyInstanceEventStartTime(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorModifyInstanceConnectEndpoint(response, &metadata) } - output := &ModifyInstanceEventStartTimeOutput{} + output := &ModifyInstanceConnectEndpointOutput{} out.Result = output var buff [1024]byte @@ -57362,7 +57742,7 @@ func (m *awsEc2query_deserializeOpModifyInstanceEventStartTime) HandleDeserializ } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentModifyInstanceEventStartTimeOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentModifyInstanceConnectEndpointOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -57376,7 +57756,7 @@ func (m *awsEc2query_deserializeOpModifyInstanceEventStartTime) HandleDeserializ return out, metadata, err } -func awsEc2query_deserializeOpErrorModifyInstanceEventStartTime(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorModifyInstanceConnectEndpoint(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -57409,14 +57789,14 @@ func awsEc2query_deserializeOpErrorModifyInstanceEventStartTime(response *smithy } } -type awsEc2query_deserializeOpModifyInstanceEventWindow struct { +type awsEc2query_deserializeOpModifyInstanceCpuOptions struct { } -func (*awsEc2query_deserializeOpModifyInstanceEventWindow) ID() string { +func (*awsEc2query_deserializeOpModifyInstanceCpuOptions) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpModifyInstanceEventWindow) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpModifyInstanceCpuOptions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -57434,9 +57814,9 @@ func (m *awsEc2query_deserializeOpModifyInstanceEventWindow) HandleDeserialize(c } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorModifyInstanceEventWindow(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorModifyInstanceCpuOptions(response, &metadata) } - output := &ModifyInstanceEventWindowOutput{} + output := &ModifyInstanceCpuOptionsOutput{} out.Result = output var buff [1024]byte @@ -57457,7 +57837,7 @@ func (m *awsEc2query_deserializeOpModifyInstanceEventWindow) HandleDeserialize(c } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentModifyInstanceEventWindowOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentModifyInstanceCpuOptionsOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -57471,7 +57851,7 @@ func (m *awsEc2query_deserializeOpModifyInstanceEventWindow) HandleDeserialize(c return out, metadata, err } -func awsEc2query_deserializeOpErrorModifyInstanceEventWindow(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorModifyInstanceCpuOptions(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -57504,14 +57884,14 @@ func awsEc2query_deserializeOpErrorModifyInstanceEventWindow(response *smithyhtt } } -type awsEc2query_deserializeOpModifyInstanceMaintenanceOptions struct { +type awsEc2query_deserializeOpModifyInstanceCreditSpecification struct { } -func (*awsEc2query_deserializeOpModifyInstanceMaintenanceOptions) ID() string { +func (*awsEc2query_deserializeOpModifyInstanceCreditSpecification) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpModifyInstanceMaintenanceOptions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpModifyInstanceCreditSpecification) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -57529,9 +57909,9 @@ func (m *awsEc2query_deserializeOpModifyInstanceMaintenanceOptions) HandleDeseri } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorModifyInstanceMaintenanceOptions(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorModifyInstanceCreditSpecification(response, &metadata) } - output := &ModifyInstanceMaintenanceOptionsOutput{} + output := &ModifyInstanceCreditSpecificationOutput{} out.Result = output var buff [1024]byte @@ -57552,7 +57932,7 @@ func (m *awsEc2query_deserializeOpModifyInstanceMaintenanceOptions) HandleDeseri } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentModifyInstanceMaintenanceOptionsOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentModifyInstanceCreditSpecificationOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -57566,7 +57946,7 @@ func (m *awsEc2query_deserializeOpModifyInstanceMaintenanceOptions) HandleDeseri return out, metadata, err } -func awsEc2query_deserializeOpErrorModifyInstanceMaintenanceOptions(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorModifyInstanceCreditSpecification(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -57599,14 +57979,14 @@ func awsEc2query_deserializeOpErrorModifyInstanceMaintenanceOptions(response *sm } } -type awsEc2query_deserializeOpModifyInstanceMetadataDefaults struct { +type awsEc2query_deserializeOpModifyInstanceEventStartTime struct { } -func (*awsEc2query_deserializeOpModifyInstanceMetadataDefaults) ID() string { +func (*awsEc2query_deserializeOpModifyInstanceEventStartTime) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpModifyInstanceMetadataDefaults) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpModifyInstanceEventStartTime) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -57624,9 +58004,9 @@ func (m *awsEc2query_deserializeOpModifyInstanceMetadataDefaults) HandleDeserial } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorModifyInstanceMetadataDefaults(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorModifyInstanceEventStartTime(response, &metadata) } - output := &ModifyInstanceMetadataDefaultsOutput{} + output := &ModifyInstanceEventStartTimeOutput{} out.Result = output var buff [1024]byte @@ -57647,7 +58027,7 @@ func (m *awsEc2query_deserializeOpModifyInstanceMetadataDefaults) HandleDeserial } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentModifyInstanceMetadataDefaultsOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentModifyInstanceEventStartTimeOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -57661,7 +58041,7 @@ func (m *awsEc2query_deserializeOpModifyInstanceMetadataDefaults) HandleDeserial return out, metadata, err } -func awsEc2query_deserializeOpErrorModifyInstanceMetadataDefaults(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorModifyInstanceEventStartTime(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -57694,14 +58074,14 @@ func awsEc2query_deserializeOpErrorModifyInstanceMetadataDefaults(response *smit } } -type awsEc2query_deserializeOpModifyInstanceMetadataOptions struct { +type awsEc2query_deserializeOpModifyInstanceEventWindow struct { } -func (*awsEc2query_deserializeOpModifyInstanceMetadataOptions) ID() string { +func (*awsEc2query_deserializeOpModifyInstanceEventWindow) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpModifyInstanceMetadataOptions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpModifyInstanceEventWindow) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -57719,9 +58099,9 @@ func (m *awsEc2query_deserializeOpModifyInstanceMetadataOptions) HandleDeseriali } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorModifyInstanceMetadataOptions(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorModifyInstanceEventWindow(response, &metadata) } - output := &ModifyInstanceMetadataOptionsOutput{} + output := &ModifyInstanceEventWindowOutput{} out.Result = output var buff [1024]byte @@ -57742,7 +58122,7 @@ func (m *awsEc2query_deserializeOpModifyInstanceMetadataOptions) HandleDeseriali } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentModifyInstanceMetadataOptionsOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentModifyInstanceEventWindowOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -57756,7 +58136,7 @@ func (m *awsEc2query_deserializeOpModifyInstanceMetadataOptions) HandleDeseriali return out, metadata, err } -func awsEc2query_deserializeOpErrorModifyInstanceMetadataOptions(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorModifyInstanceEventWindow(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -57789,14 +58169,14 @@ func awsEc2query_deserializeOpErrorModifyInstanceMetadataOptions(response *smith } } -type awsEc2query_deserializeOpModifyInstanceNetworkPerformanceOptions struct { +type awsEc2query_deserializeOpModifyInstanceMaintenanceOptions struct { } -func (*awsEc2query_deserializeOpModifyInstanceNetworkPerformanceOptions) ID() string { +func (*awsEc2query_deserializeOpModifyInstanceMaintenanceOptions) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpModifyInstanceNetworkPerformanceOptions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpModifyInstanceMaintenanceOptions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -57814,9 +58194,9 @@ func (m *awsEc2query_deserializeOpModifyInstanceNetworkPerformanceOptions) Handl } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorModifyInstanceNetworkPerformanceOptions(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorModifyInstanceMaintenanceOptions(response, &metadata) } - output := &ModifyInstanceNetworkPerformanceOptionsOutput{} + output := &ModifyInstanceMaintenanceOptionsOutput{} out.Result = output var buff [1024]byte @@ -57837,7 +58217,7 @@ func (m *awsEc2query_deserializeOpModifyInstanceNetworkPerformanceOptions) Handl } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentModifyInstanceNetworkPerformanceOptionsOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentModifyInstanceMaintenanceOptionsOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -57851,7 +58231,7 @@ func (m *awsEc2query_deserializeOpModifyInstanceNetworkPerformanceOptions) Handl return out, metadata, err } -func awsEc2query_deserializeOpErrorModifyInstanceNetworkPerformanceOptions(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorModifyInstanceMaintenanceOptions(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -57884,14 +58264,14 @@ func awsEc2query_deserializeOpErrorModifyInstanceNetworkPerformanceOptions(respo } } -type awsEc2query_deserializeOpModifyInstancePlacement struct { +type awsEc2query_deserializeOpModifyInstanceMetadataDefaults struct { } -func (*awsEc2query_deserializeOpModifyInstancePlacement) ID() string { +func (*awsEc2query_deserializeOpModifyInstanceMetadataDefaults) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpModifyInstancePlacement) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpModifyInstanceMetadataDefaults) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -57909,9 +58289,9 @@ func (m *awsEc2query_deserializeOpModifyInstancePlacement) HandleDeserialize(ctx } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorModifyInstancePlacement(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorModifyInstanceMetadataDefaults(response, &metadata) } - output := &ModifyInstancePlacementOutput{} + output := &ModifyInstanceMetadataDefaultsOutput{} out.Result = output var buff [1024]byte @@ -57932,7 +58312,7 @@ func (m *awsEc2query_deserializeOpModifyInstancePlacement) HandleDeserialize(ctx } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentModifyInstancePlacementOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentModifyInstanceMetadataDefaultsOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -57946,7 +58326,7 @@ func (m *awsEc2query_deserializeOpModifyInstancePlacement) HandleDeserialize(ctx return out, metadata, err } -func awsEc2query_deserializeOpErrorModifyInstancePlacement(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorModifyInstanceMetadataDefaults(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -57979,14 +58359,14 @@ func awsEc2query_deserializeOpErrorModifyInstancePlacement(response *smithyhttp. } } -type awsEc2query_deserializeOpModifyIpam struct { +type awsEc2query_deserializeOpModifyInstanceMetadataOptions struct { } -func (*awsEc2query_deserializeOpModifyIpam) ID() string { +func (*awsEc2query_deserializeOpModifyInstanceMetadataOptions) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpModifyIpam) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpModifyInstanceMetadataOptions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -58004,9 +58384,9 @@ func (m *awsEc2query_deserializeOpModifyIpam) HandleDeserialize(ctx context.Cont } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorModifyIpam(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorModifyInstanceMetadataOptions(response, &metadata) } - output := &ModifyIpamOutput{} + output := &ModifyInstanceMetadataOptionsOutput{} out.Result = output var buff [1024]byte @@ -58027,7 +58407,7 @@ func (m *awsEc2query_deserializeOpModifyIpam) HandleDeserialize(ctx context.Cont } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentModifyIpamOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentModifyInstanceMetadataOptionsOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -58041,7 +58421,7 @@ func (m *awsEc2query_deserializeOpModifyIpam) HandleDeserialize(ctx context.Cont return out, metadata, err } -func awsEc2query_deserializeOpErrorModifyIpam(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorModifyInstanceMetadataOptions(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -58074,14 +58454,14 @@ func awsEc2query_deserializeOpErrorModifyIpam(response *smithyhttp.Response, met } } -type awsEc2query_deserializeOpModifyIpamPolicyAllocationRules struct { +type awsEc2query_deserializeOpModifyInstanceNetworkPerformanceOptions struct { } -func (*awsEc2query_deserializeOpModifyIpamPolicyAllocationRules) ID() string { +func (*awsEc2query_deserializeOpModifyInstanceNetworkPerformanceOptions) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpModifyIpamPolicyAllocationRules) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpModifyInstanceNetworkPerformanceOptions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -58099,9 +58479,9 @@ func (m *awsEc2query_deserializeOpModifyIpamPolicyAllocationRules) HandleDeseria } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorModifyIpamPolicyAllocationRules(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorModifyInstanceNetworkPerformanceOptions(response, &metadata) } - output := &ModifyIpamPolicyAllocationRulesOutput{} + output := &ModifyInstanceNetworkPerformanceOptionsOutput{} out.Result = output var buff [1024]byte @@ -58122,7 +58502,7 @@ func (m *awsEc2query_deserializeOpModifyIpamPolicyAllocationRules) HandleDeseria } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentModifyIpamPolicyAllocationRulesOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentModifyInstanceNetworkPerformanceOptionsOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -58136,7 +58516,7 @@ func (m *awsEc2query_deserializeOpModifyIpamPolicyAllocationRules) HandleDeseria return out, metadata, err } -func awsEc2query_deserializeOpErrorModifyIpamPolicyAllocationRules(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorModifyInstanceNetworkPerformanceOptions(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -58169,14 +58549,14 @@ func awsEc2query_deserializeOpErrorModifyIpamPolicyAllocationRules(response *smi } } -type awsEc2query_deserializeOpModifyIpamPool struct { +type awsEc2query_deserializeOpModifyInstancePlacement struct { } -func (*awsEc2query_deserializeOpModifyIpamPool) ID() string { +func (*awsEc2query_deserializeOpModifyInstancePlacement) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpModifyIpamPool) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpModifyInstancePlacement) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -58194,9 +58574,9 @@ func (m *awsEc2query_deserializeOpModifyIpamPool) HandleDeserialize(ctx context. } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorModifyIpamPool(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorModifyInstancePlacement(response, &metadata) } - output := &ModifyIpamPoolOutput{} + output := &ModifyInstancePlacementOutput{} out.Result = output var buff [1024]byte @@ -58217,7 +58597,7 @@ func (m *awsEc2query_deserializeOpModifyIpamPool) HandleDeserialize(ctx context. } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentModifyIpamPoolOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentModifyInstancePlacementOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -58231,7 +58611,7 @@ func (m *awsEc2query_deserializeOpModifyIpamPool) HandleDeserialize(ctx context. return out, metadata, err } -func awsEc2query_deserializeOpErrorModifyIpamPool(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorModifyInstancePlacement(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -58264,14 +58644,14 @@ func awsEc2query_deserializeOpErrorModifyIpamPool(response *smithyhttp.Response, } } -type awsEc2query_deserializeOpModifyIpamPrefixListResolver struct { +type awsEc2query_deserializeOpModifyIpam struct { } -func (*awsEc2query_deserializeOpModifyIpamPrefixListResolver) ID() string { +func (*awsEc2query_deserializeOpModifyIpam) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpModifyIpamPrefixListResolver) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpModifyIpam) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -58289,9 +58669,9 @@ func (m *awsEc2query_deserializeOpModifyIpamPrefixListResolver) HandleDeserializ } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorModifyIpamPrefixListResolver(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorModifyIpam(response, &metadata) } - output := &ModifyIpamPrefixListResolverOutput{} + output := &ModifyIpamOutput{} out.Result = output var buff [1024]byte @@ -58312,7 +58692,7 @@ func (m *awsEc2query_deserializeOpModifyIpamPrefixListResolver) HandleDeserializ } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentModifyIpamPrefixListResolverOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentModifyIpamOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -58326,7 +58706,7 @@ func (m *awsEc2query_deserializeOpModifyIpamPrefixListResolver) HandleDeserializ return out, metadata, err } -func awsEc2query_deserializeOpErrorModifyIpamPrefixListResolver(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorModifyIpam(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -58359,14 +58739,14 @@ func awsEc2query_deserializeOpErrorModifyIpamPrefixListResolver(response *smithy } } -type awsEc2query_deserializeOpModifyIpamPrefixListResolverTarget struct { +type awsEc2query_deserializeOpModifyIpamPolicyAllocationRules struct { } -func (*awsEc2query_deserializeOpModifyIpamPrefixListResolverTarget) ID() string { +func (*awsEc2query_deserializeOpModifyIpamPolicyAllocationRules) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpModifyIpamPrefixListResolverTarget) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpModifyIpamPolicyAllocationRules) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -58384,9 +58764,9 @@ func (m *awsEc2query_deserializeOpModifyIpamPrefixListResolverTarget) HandleDese } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorModifyIpamPrefixListResolverTarget(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorModifyIpamPolicyAllocationRules(response, &metadata) } - output := &ModifyIpamPrefixListResolverTargetOutput{} + output := &ModifyIpamPolicyAllocationRulesOutput{} out.Result = output var buff [1024]byte @@ -58407,7 +58787,7 @@ func (m *awsEc2query_deserializeOpModifyIpamPrefixListResolverTarget) HandleDese } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentModifyIpamPrefixListResolverTargetOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentModifyIpamPolicyAllocationRulesOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -58421,7 +58801,7 @@ func (m *awsEc2query_deserializeOpModifyIpamPrefixListResolverTarget) HandleDese return out, metadata, err } -func awsEc2query_deserializeOpErrorModifyIpamPrefixListResolverTarget(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorModifyIpamPolicyAllocationRules(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -58454,14 +58834,14 @@ func awsEc2query_deserializeOpErrorModifyIpamPrefixListResolverTarget(response * } } -type awsEc2query_deserializeOpModifyIpamResourceCidr struct { +type awsEc2query_deserializeOpModifyIpamPool struct { } -func (*awsEc2query_deserializeOpModifyIpamResourceCidr) ID() string { +func (*awsEc2query_deserializeOpModifyIpamPool) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpModifyIpamResourceCidr) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpModifyIpamPool) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -58479,9 +58859,9 @@ func (m *awsEc2query_deserializeOpModifyIpamResourceCidr) HandleDeserialize(ctx } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorModifyIpamResourceCidr(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorModifyIpamPool(response, &metadata) } - output := &ModifyIpamResourceCidrOutput{} + output := &ModifyIpamPoolOutput{} out.Result = output var buff [1024]byte @@ -58502,7 +58882,7 @@ func (m *awsEc2query_deserializeOpModifyIpamResourceCidr) HandleDeserialize(ctx } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentModifyIpamResourceCidrOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentModifyIpamPoolOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -58516,7 +58896,7 @@ func (m *awsEc2query_deserializeOpModifyIpamResourceCidr) HandleDeserialize(ctx return out, metadata, err } -func awsEc2query_deserializeOpErrorModifyIpamResourceCidr(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorModifyIpamPool(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -58549,14 +58929,14 @@ func awsEc2query_deserializeOpErrorModifyIpamResourceCidr(response *smithyhttp.R } } -type awsEc2query_deserializeOpModifyIpamResourceDiscovery struct { +type awsEc2query_deserializeOpModifyIpamPrefixListResolver struct { } -func (*awsEc2query_deserializeOpModifyIpamResourceDiscovery) ID() string { +func (*awsEc2query_deserializeOpModifyIpamPrefixListResolver) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpModifyIpamResourceDiscovery) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpModifyIpamPrefixListResolver) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -58574,9 +58954,9 @@ func (m *awsEc2query_deserializeOpModifyIpamResourceDiscovery) HandleDeserialize } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorModifyIpamResourceDiscovery(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorModifyIpamPrefixListResolver(response, &metadata) } - output := &ModifyIpamResourceDiscoveryOutput{} + output := &ModifyIpamPrefixListResolverOutput{} out.Result = output var buff [1024]byte @@ -58597,7 +58977,7 @@ func (m *awsEc2query_deserializeOpModifyIpamResourceDiscovery) HandleDeserialize } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentModifyIpamResourceDiscoveryOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentModifyIpamPrefixListResolverOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -58611,7 +58991,7 @@ func (m *awsEc2query_deserializeOpModifyIpamResourceDiscovery) HandleDeserialize return out, metadata, err } -func awsEc2query_deserializeOpErrorModifyIpamResourceDiscovery(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorModifyIpamPrefixListResolver(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -58644,14 +59024,14 @@ func awsEc2query_deserializeOpErrorModifyIpamResourceDiscovery(response *smithyh } } -type awsEc2query_deserializeOpModifyIpamScope struct { +type awsEc2query_deserializeOpModifyIpamPrefixListResolverTarget struct { } -func (*awsEc2query_deserializeOpModifyIpamScope) ID() string { +func (*awsEc2query_deserializeOpModifyIpamPrefixListResolverTarget) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpModifyIpamScope) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpModifyIpamPrefixListResolverTarget) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -58669,9 +59049,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_deserializeOpErrorModifyIpamPrefixListResolverTarget(response, &metadata) } - output := &ModifyIpamScopeOutput{} + output := &ModifyIpamPrefixListResolverTargetOutput{} out.Result = output var buff [1024]byte @@ -58692,7 +59072,7 @@ func (m *awsEc2query_deserializeOpModifyIpamScope) HandleDeserialize(ctx context } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentModifyIpamScopeOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentModifyIpamPrefixListResolverTargetOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -58706,7 +59086,7 @@ func (m *awsEc2query_deserializeOpModifyIpamScope) HandleDeserialize(ctx context return out, metadata, err } -func awsEc2query_deserializeOpErrorModifyIpamScope(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorModifyIpamPrefixListResolverTarget(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -58739,14 +59119,14 @@ func awsEc2query_deserializeOpErrorModifyIpamScope(response *smithyhttp.Response } } -type awsEc2query_deserializeOpModifyLaunchTemplate struct { +type awsEc2query_deserializeOpModifyIpamResourceCidr struct { } -func (*awsEc2query_deserializeOpModifyLaunchTemplate) ID() string { +func (*awsEc2query_deserializeOpModifyIpamResourceCidr) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpModifyLaunchTemplate) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsEc2query_deserializeOpModifyIpamResourceCidr) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -58764,9 +59144,9 @@ func (m *awsEc2query_deserializeOpModifyLaunchTemplate) HandleDeserialize(ctx co } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorModifyLaunchTemplate(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorModifyIpamResourceCidr(response, &metadata) } - output := &ModifyLaunchTemplateOutput{} + output := &ModifyIpamResourceCidrOutput{} out.Result = output var buff [1024]byte @@ -58787,7 +59167,7 @@ func (m *awsEc2query_deserializeOpModifyLaunchTemplate) HandleDeserialize(ctx co } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentModifyLaunchTemplateOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentModifyIpamResourceCidrOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -58801,7 +59181,7 @@ func (m *awsEc2query_deserializeOpModifyLaunchTemplate) HandleDeserialize(ctx co return out, metadata, err } -func awsEc2query_deserializeOpErrorModifyLaunchTemplate(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsEc2query_deserializeOpErrorModifyIpamResourceCidr(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -58834,14 +59214,14 @@ func awsEc2query_deserializeOpErrorModifyLaunchTemplate(response *smithyhttp.Res } } -type awsEc2query_deserializeOpModifyLocalGatewayRoute struct { +type awsEc2query_deserializeOpModifyIpamResourceDiscovery struct { } -func (*awsEc2query_deserializeOpModifyLocalGatewayRoute) ID() string { +func (*awsEc2query_deserializeOpModifyIpamResourceDiscovery) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpModifyLocalGatewayRoute) 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) @@ -58859,9 +59239,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_deserializeOpErrorModifyIpamResourceDiscovery(response, &metadata) } - output := &ModifyLocalGatewayRouteOutput{} + output := &ModifyIpamResourceDiscoveryOutput{} out.Result = output var buff [1024]byte @@ -58882,7 +59262,7 @@ func (m *awsEc2query_deserializeOpModifyLocalGatewayRoute) HandleDeserialize(ctx } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentModifyLocalGatewayRouteOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentModifyIpamResourceDiscoveryOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -58896,7 +59276,7 @@ func (m *awsEc2query_deserializeOpModifyLocalGatewayRoute) HandleDeserialize(ctx return out, metadata, err } -func awsEc2query_deserializeOpErrorModifyLocalGatewayRoute(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)} @@ -58929,14 +59309,14 @@ func awsEc2query_deserializeOpErrorModifyLocalGatewayRoute(response *smithyhttp. } } -type awsEc2query_deserializeOpModifyManagedPrefixList struct { +type awsEc2query_deserializeOpModifyIpamScope struct { } -func (*awsEc2query_deserializeOpModifyManagedPrefixList) ID() string { +func (*awsEc2query_deserializeOpModifyIpamScope) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpModifyManagedPrefixList) 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) @@ -58954,9 +59334,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_deserializeOpErrorModifyIpamScope(response, &metadata) } - output := &ModifyManagedPrefixListOutput{} + output := &ModifyIpamScopeOutput{} out.Result = output var buff [1024]byte @@ -58977,7 +59357,7 @@ func (m *awsEc2query_deserializeOpModifyManagedPrefixList) HandleDeserialize(ctx } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentModifyManagedPrefixListOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentModifyIpamScopeOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -58991,7 +59371,7 @@ func (m *awsEc2query_deserializeOpModifyManagedPrefixList) HandleDeserialize(ctx return out, metadata, err } -func awsEc2query_deserializeOpErrorModifyManagedPrefixList(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)} @@ -59024,14 +59404,14 @@ func awsEc2query_deserializeOpErrorModifyManagedPrefixList(response *smithyhttp. } } -type awsEc2query_deserializeOpModifyNetworkInterfaceAttribute struct { +type awsEc2query_deserializeOpModifyLaunchTemplate struct { } -func (*awsEc2query_deserializeOpModifyNetworkInterfaceAttribute) ID() string { +func (*awsEc2query_deserializeOpModifyLaunchTemplate) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpModifyNetworkInterfaceAttribute) 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) @@ -59049,21 +59429,44 @@ func (m *awsEc2query_deserializeOpModifyNetworkInterfaceAttribute) HandleDeseria } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorModifyNetworkInterfaceAttribute(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorModifyLaunchTemplate(response, &metadata) } - output := &ModifyNetworkInterfaceAttributeOutput{} + output := &ModifyLaunchTemplateOutput{} 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_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_deserializeOpErrorModifyNetworkInterfaceAttribute(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)} @@ -59096,14 +59499,14 @@ func awsEc2query_deserializeOpErrorModifyNetworkInterfaceAttribute(response *smi } } -type awsEc2query_deserializeOpModifyPrivateDnsNameOptions struct { +type awsEc2query_deserializeOpModifyLocalGatewayRoute struct { } -func (*awsEc2query_deserializeOpModifyPrivateDnsNameOptions) ID() string { +func (*awsEc2query_deserializeOpModifyLocalGatewayRoute) ID() string { return "OperationDeserializer" } -func (m *awsEc2query_deserializeOpModifyPrivateDnsNameOptions) 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) @@ -59121,9 +59524,9 @@ func (m *awsEc2query_deserializeOpModifyPrivateDnsNameOptions) HandleDeserialize } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsEc2query_deserializeOpErrorModifyPrivateDnsNameOptions(response, &metadata) + return out, metadata, awsEc2query_deserializeOpErrorModifyLocalGatewayRoute(response, &metadata) } - output := &ModifyPrivateDnsNameOptionsOutput{} + output := &ModifyLocalGatewayRouteOutput{} out.Result = output var buff [1024]byte @@ -59144,7 +59547,7 @@ func (m *awsEc2query_deserializeOpModifyPrivateDnsNameOptions) HandleDeserialize } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - err = awsEc2query_deserializeOpDocumentModifyPrivateDnsNameOptionsOutput(&output, decoder) + err = awsEc2query_deserializeOpDocumentModifyLocalGatewayRouteOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -59158,7 +59561,269 @@ func (m *awsEc2query_deserializeOpModifyPrivateDnsNameOptions) HandleDeserialize return out, metadata, err } -func awsEc2query_deserializeOpErrorModifyPrivateDnsNameOptions(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)} + } + 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_deserializeOpModifyManagedPrefixList struct { +} + +func (*awsEc2query_deserializeOpModifyManagedPrefixList) ID() string { + return "OperationDeserializer" +} + +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) + if err != nil { + return out, metadata, err + } + + _, span := tracing.StartSpan(ctx, "OperationDeserializer") + endTimer := startMetricTimer(ctx, "client.call.deserialization_duration") + defer endTimer() + defer span.End() + response, ok := out.RawResponse.(*smithyhttp.Response) + if !ok { + return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} + } + + if response.StatusCode < 200 || response.StatusCode >= 300 { + return out, metadata, awsEc2query_deserializeOpErrorModifyManagedPrefixList(response, &metadata) + } + output := &ModifyManagedPrefixListOutput{} + 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_deserializeOpDocumentModifyManagedPrefixListOutput(&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_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)} + } + 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_deserializeOpModifyNetworkInterfaceAttribute struct { +} + +func (*awsEc2query_deserializeOpModifyNetworkInterfaceAttribute) ID() string { + return "OperationDeserializer" +} + +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) + if err != nil { + return out, metadata, err + } + + _, span := tracing.StartSpan(ctx, "OperationDeserializer") + endTimer := startMetricTimer(ctx, "client.call.deserialization_duration") + defer endTimer() + defer span.End() + response, ok := out.RawResponse.(*smithyhttp.Response) + if !ok { + return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} + } + + if response.StatusCode < 200 || response.StatusCode >= 300 { + return out, metadata, awsEc2query_deserializeOpErrorModifyNetworkInterfaceAttribute(response, &metadata) + } + output := &ModifyNetworkInterfaceAttributeOutput{} + 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_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)} + } + 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_deserializeOpModifyPrivateDnsNameOptions struct { +} + +func (*awsEc2query_deserializeOpModifyPrivateDnsNameOptions) ID() string { + return "OperationDeserializer" +} + +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) + if err != nil { + return out, metadata, err + } + + _, span := tracing.StartSpan(ctx, "OperationDeserializer") + endTimer := startMetricTimer(ctx, "client.call.deserialization_duration") + defer endTimer() + defer span.End() + response, ok := out.RawResponse.(*smithyhttp.Response) + if !ok { + return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} + } + + if response.StatusCode < 200 || response.StatusCode >= 300 { + return out, metadata, awsEc2query_deserializeOpErrorModifyPrivateDnsNameOptions(response, &metadata) + } + output := &ModifyPrivateDnsNameOptionsOutput{} + 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_deserializeOpDocumentModifyPrivateDnsNameOptionsOutput(&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_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)} @@ -74852,6 +75517,12 @@ func awsEc2query_deserializeDocumentAvailabilityZone(v **types.AvailabilityZone, originalDecoder := decoder decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) switch { + case strings.EqualFold("geographySet", t.Name.Local): + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + if err := awsEc2query_deserializeDocumentAvailabilityZoneGeographyList(&sv.Geography, nodeDecoder); err != nil { + return err + } + case strings.EqualFold("groupLongName", t.Name.Local): val, err := decoder.Value() if err != nil { @@ -74962,6 +75633,12 @@ func awsEc2query_deserializeDocumentAvailabilityZone(v **types.AvailabilityZone, sv.State = types.AvailabilityZoneState(xtv) } + case strings.EqualFold("subGeographySet", t.Name.Local): + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + if err := awsEc2query_deserializeDocumentAvailabilityZoneSubGeographyList(&sv.SubGeography, nodeDecoder); err != nil { + return err + } + case strings.EqualFold("zoneId", t.Name.Local): val, err := decoder.Value() if err != nil { @@ -75015,6 +75692,123 @@ func awsEc2query_deserializeDocumentAvailabilityZone(v **types.AvailabilityZone, return nil } +func awsEc2query_deserializeDocumentAvailabilityZoneGeography(v **types.AvailabilityZoneGeography, decoder smithyxml.NodeDecoder) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + var sv *types.AvailabilityZoneGeography + if *v == nil { + sv = &types.AvailabilityZoneGeography{} + } else { + sv = *v + } + + for { + t, done, err := decoder.Token() + if err != nil { + return err + } + if done { + break + } + originalDecoder := decoder + decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) + switch { + case strings.EqualFold("name", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.Name = ptr.String(xtv) + } + + default: + // Do nothing and ignore the unexpected tag element + err = decoder.Decoder.Skip() + if err != nil { + return err + } + + } + decoder = originalDecoder + } + *v = sv + return nil +} + +func awsEc2query_deserializeDocumentAvailabilityZoneGeographyList(v *[]types.AvailabilityZoneGeography, decoder smithyxml.NodeDecoder) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + var sv []types.AvailabilityZoneGeography + if *v == nil { + sv = make([]types.AvailabilityZoneGeography, 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.AvailabilityZoneGeography + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + destAddr := &col + if err := awsEc2query_deserializeDocumentAvailabilityZoneGeography(&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_deserializeDocumentAvailabilityZoneGeographyListUnwrapped(v *[]types.AvailabilityZoneGeography, decoder smithyxml.NodeDecoder) error { + var sv []types.AvailabilityZoneGeography + if *v == nil { + sv = make([]types.AvailabilityZoneGeography, 0) + } else { + sv = *v + } + + switch { + default: + var mv types.AvailabilityZoneGeography + t := decoder.StartEl + _ = t + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + destAddr := &mv + if err := awsEc2query_deserializeDocumentAvailabilityZoneGeography(&destAddr, nodeDecoder); err != nil { + return err + } + mv = *destAddr + sv = append(sv, mv) + } + *v = sv + return nil +} func awsEc2query_deserializeDocumentAvailabilityZoneList(v *[]types.AvailabilityZone, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) @@ -75200,6 +75994,123 @@ func awsEc2query_deserializeDocumentAvailabilityZoneMessageListUnwrapped(v *[]ty *v = sv return nil } +func awsEc2query_deserializeDocumentAvailabilityZoneSubGeography(v **types.AvailabilityZoneSubGeography, decoder smithyxml.NodeDecoder) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + var sv *types.AvailabilityZoneSubGeography + if *v == nil { + sv = &types.AvailabilityZoneSubGeography{} + } else { + sv = *v + } + + for { + t, done, err := decoder.Token() + if err != nil { + return err + } + if done { + break + } + originalDecoder := decoder + decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) + switch { + case strings.EqualFold("name", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.Name = ptr.String(xtv) + } + + default: + // Do nothing and ignore the unexpected tag element + err = decoder.Decoder.Skip() + if err != nil { + return err + } + + } + decoder = originalDecoder + } + *v = sv + return nil +} + +func awsEc2query_deserializeDocumentAvailabilityZoneSubGeographyList(v *[]types.AvailabilityZoneSubGeography, decoder smithyxml.NodeDecoder) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + var sv []types.AvailabilityZoneSubGeography + if *v == nil { + sv = make([]types.AvailabilityZoneSubGeography, 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.AvailabilityZoneSubGeography + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + destAddr := &col + if err := awsEc2query_deserializeDocumentAvailabilityZoneSubGeography(&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_deserializeDocumentAvailabilityZoneSubGeographyListUnwrapped(v *[]types.AvailabilityZoneSubGeography, decoder smithyxml.NodeDecoder) error { + var sv []types.AvailabilityZoneSubGeography + if *v == nil { + sv = make([]types.AvailabilityZoneSubGeography, 0) + } else { + sv = *v + } + + switch { + default: + var mv types.AvailabilityZoneSubGeography + t := decoder.StartEl + _ = t + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + destAddr := &mv + if err := awsEc2query_deserializeDocumentAvailabilityZoneSubGeography(&destAddr, nodeDecoder); err != nil { + return err + } + mv = *destAddr + sv = append(sv, mv) + } + *v = sv + return nil +} func awsEc2query_deserializeDocumentAvailableCapacity(v **types.AvailableCapacity, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) @@ -77096,6 +78007,12 @@ func awsEc2query_deserializeDocumentCapacityAllocation(v **types.CapacityAllocat originalDecoder := decoder decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) switch { + case strings.EqualFold("allocationMetadataList", t.Name.Local): + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + if err := awsEc2query_deserializeDocumentCapacityAllocationMetadataList(&sv.AllocationMetadata, nodeDecoder); err != nil { + return err + } + case strings.EqualFold("allocationType", t.Name.Local): val, err := decoder.Value() if err != nil { @@ -77140,6 +78057,136 @@ func awsEc2query_deserializeDocumentCapacityAllocation(v **types.CapacityAllocat return nil } +func awsEc2query_deserializeDocumentCapacityAllocationMetadataEntry(v **types.CapacityAllocationMetadataEntry, decoder smithyxml.NodeDecoder) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + var sv *types.CapacityAllocationMetadataEntry + if *v == nil { + sv = &types.CapacityAllocationMetadataEntry{} + } else { + sv = *v + } + + for { + t, done, err := decoder.Token() + if err != nil { + return err + } + if done { + break + } + originalDecoder := decoder + decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) + switch { + case strings.EqualFold("key", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.Key = ptr.String(xtv) + } + + case strings.EqualFold("value", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.Value = ptr.String(xtv) + } + + default: + // Do nothing and ignore the unexpected tag element + err = decoder.Decoder.Skip() + if err != nil { + return err + } + + } + decoder = originalDecoder + } + *v = sv + return nil +} + +func awsEc2query_deserializeDocumentCapacityAllocationMetadataList(v *[]types.CapacityAllocationMetadataEntry, decoder smithyxml.NodeDecoder) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + var sv []types.CapacityAllocationMetadataEntry + if *v == nil { + sv = make([]types.CapacityAllocationMetadataEntry, 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.CapacityAllocationMetadataEntry + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + destAddr := &col + if err := awsEc2query_deserializeDocumentCapacityAllocationMetadataEntry(&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_deserializeDocumentCapacityAllocationMetadataListUnwrapped(v *[]types.CapacityAllocationMetadataEntry, decoder smithyxml.NodeDecoder) error { + var sv []types.CapacityAllocationMetadataEntry + if *v == nil { + sv = make([]types.CapacityAllocationMetadataEntry, 0) + } else { + sv = *v + } + + switch { + default: + var mv types.CapacityAllocationMetadataEntry + t := decoder.StartEl + _ = t + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + destAddr := &mv + if err := awsEc2query_deserializeDocumentCapacityAllocationMetadataEntry(&destAddr, nodeDecoder); err != nil { + return err + } + mv = *destAddr + sv = append(sv, mv) + } + *v = sv + return nil +} func awsEc2query_deserializeDocumentCapacityAllocations(v *[]types.CapacityAllocation, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) @@ -77583,6 +78630,19 @@ func awsEc2query_deserializeDocumentCapacityBlockExtension(v **types.CapacityBlo sv.UpfrontFee = ptr.String(xtv) } + case strings.EqualFold("zoneType", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.ZoneType = ptr.String(xtv) + } + default: // Do nothing and ignore the unexpected tag element err = decoder.Decoder.Skip() @@ -77795,6 +78855,19 @@ func awsEc2query_deserializeDocumentCapacityBlockExtensionOffering(v **types.Cap sv.UpfrontFee = ptr.String(xtv) } + case strings.EqualFold("zoneType", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.ZoneType = ptr.String(xtv) + } + default: // Do nothing and ignore the unexpected tag element err = decoder.Decoder.Skip() @@ -78160,6 +79233,19 @@ func awsEc2query_deserializeDocumentCapacityBlockOffering(v **types.CapacityBloc sv.UpfrontFee = ptr.String(xtv) } + case strings.EqualFold("zoneType", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.ZoneType = ptr.String(xtv) + } + default: // Do nothing and ignore the unexpected tag element err = decoder.Decoder.Skip() @@ -84815,6 +85901,19 @@ func awsEc2query_deserializeDocumentCpuOptions(v **types.CpuOptions, decoder smi sv.CoreCount = ptr.Int32(int32(i64)) } + case strings.EqualFold("nestedVirtualization", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.NestedVirtualization = types.NestedVirtualizationSpecification(xtv) + } + case strings.EqualFold("threadsPerCore", t.Name.Local): val, err := decoder.Value() if err != nil { @@ -103797,6 +104896,12 @@ func awsEc2query_deserializeDocumentInstance(v **types.Instance, decoder smithyx sv.RootDeviceType = types.DeviceType(xtv) } + case strings.EqualFold("secondaryInterfaceSet", t.Name.Local): + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + if err := awsEc2query_deserializeDocumentInstanceSecondaryInterfaceList(&sv.SecondaryInterfaces, nodeDecoder); err != nil { + return err + } + case strings.EqualFold("groupSet", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsEc2query_deserializeDocumentGroupIdentifierList(&sv.SecurityGroups, nodeDecoder); err != nil { @@ -106400,6 +107505,19 @@ func awsEc2query_deserializeDocumentInstanceMetadataDefaultsResponse(v **types.I sv.HttpTokens = types.HttpTokensState(xtv) } + case strings.EqualFold("httpTokensEnforced", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.HttpTokensEnforced = types.HttpTokensEnforcedState(xtv) + } + case strings.EqualFold("instanceMetadataTags", t.Name.Local): val, err := decoder.Value() if err != nil { @@ -108112,18 +109230,17 @@ func awsEc2query_deserializeDocumentInstanceRequirements(v **types.InstanceRequi return nil } -func awsEc2query_deserializeDocumentInstanceSet(v *[]types.InstanceTopology, decoder smithyxml.NodeDecoder) error { +func awsEc2query_deserializeDocumentInstanceSecondaryInterface(v **types.InstanceSecondaryInterface, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } - var sv []types.InstanceTopology + var sv *types.InstanceSecondaryInterface if *v == nil { - sv = make([]types.InstanceTopology, 0) + sv = &types.InstanceSecondaryInterface{} } else { sv = *v } - originalDecoder := decoder for { t, done, err := decoder.Token() if err != nil { @@ -108132,77 +109249,61 @@ func awsEc2query_deserializeDocumentInstanceSet(v *[]types.InstanceTopology, dec if done { break } + originalDecoder := decoder + decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) switch { - case strings.EqualFold("item", t.Name.Local): - var col types.InstanceTopology + case strings.EqualFold("attachment", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) - destAddr := &col - if err := awsEc2query_deserializeDocumentInstanceTopology(&destAddr, nodeDecoder); err != nil { + if err := awsEc2query_deserializeDocumentInstanceSecondaryInterfaceAttachment(&sv.Attachment, nodeDecoder); err != nil { return err } - col = *destAddr - sv = append(sv, col) - default: - err = decoder.Decoder.Skip() + case strings.EqualFold("interfaceType", t.Name.Local): + val, err := decoder.Value() if err != nil { return err } + if val == nil { + break + } + { + xtv := string(val) + sv.InterfaceType = types.SecondaryInterfaceType(xtv) + } - } - decoder = originalDecoder - } - *v = sv - return nil -} + case strings.EqualFold("macAddress", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.MacAddress = ptr.String(xtv) + } -func awsEc2query_deserializeDocumentInstanceSetUnwrapped(v *[]types.InstanceTopology, decoder smithyxml.NodeDecoder) error { - var sv []types.InstanceTopology - if *v == nil { - sv = make([]types.InstanceTopology, 0) - } else { - sv = *v - } + 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) + } - switch { - default: - var mv types.InstanceTopology - t := decoder.StartEl - _ = t - nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) - destAddr := &mv - if err := awsEc2query_deserializeDocumentInstanceTopology(&destAddr, nodeDecoder); err != nil { - return err - } - mv = *destAddr - sv = append(sv, mv) - } - *v = sv - return nil -} -func awsEc2query_deserializeDocumentInstanceState(v **types.InstanceState, decoder smithyxml.NodeDecoder) error { - if v == nil { - return fmt.Errorf("unexpected nil of type %T", v) - } - var sv *types.InstanceState - if *v == nil { - sv = &types.InstanceState{} - } else { - sv = *v - } + case strings.EqualFold("privateIpAddressSet", t.Name.Local): + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + if err := awsEc2query_deserializeDocumentInstanceSecondaryInterfacePrivateIpAddressList(&sv.PrivateIpAddresses, nodeDecoder); err != nil { + return err + } - for { - t, 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): + case strings.EqualFold("secondaryInterfaceId", t.Name.Local): val, err := decoder.Value() if err != nil { return err @@ -108212,14 +109313,52 @@ func awsEc2query_deserializeDocumentInstanceState(v **types.InstanceState, decod } { xtv := string(val) - i64, err := strconv.ParseInt(xtv, 10, 64) + sv.SecondaryInterfaceId = ptr.String(xtv) + } + + case strings.EqualFold("secondaryNetworkId", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.SecondaryNetworkId = ptr.String(xtv) + } + + case strings.EqualFold("secondarySubnetId", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.SecondarySubnetId = ptr.String(xtv) + } + + case strings.EqualFold("sourceDestCheck", 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 err + return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", val) } - sv.Code = ptr.Int32(int32(i64)) + sv.SourceDestCheck = ptr.Bool(xtv) } - case strings.EqualFold("name", t.Name.Local): + case strings.EqualFold("status", t.Name.Local): val, err := decoder.Value() if err != nil { return err @@ -108229,7 +109368,7 @@ func awsEc2query_deserializeDocumentInstanceState(v **types.InstanceState, decod } { xtv := string(val) - sv.Name = types.InstanceStateName(xtv) + sv.Status = types.SecondaryInterfaceStatus(xtv) } default: @@ -108246,13 +109385,13 @@ func awsEc2query_deserializeDocumentInstanceState(v **types.InstanceState, decod return nil } -func awsEc2query_deserializeDocumentInstanceStateChange(v **types.InstanceStateChange, decoder smithyxml.NodeDecoder) error { +func awsEc2query_deserializeDocumentInstanceSecondaryInterfaceAttachment(v **types.InstanceSecondaryInterfaceAttachment, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } - var sv *types.InstanceStateChange + var sv *types.InstanceSecondaryInterfaceAttachment if *v == nil { - sv = &types.InstanceStateChange{} + sv = &types.InstanceSecondaryInterfaceAttachment{} } else { sv = *v } @@ -108268,13 +109407,20 @@ func awsEc2query_deserializeDocumentInstanceStateChange(v **types.InstanceStateC originalDecoder := decoder decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) switch { - case strings.EqualFold("currentState", t.Name.Local): - nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) - if err := awsEc2query_deserializeDocumentInstanceState(&sv.CurrentState, nodeDecoder); err != nil { + case strings.EqualFold("attachmentId", t.Name.Local): + val, err := decoder.Value() + if err != nil { return err } + if val == nil { + break + } + { + xtv := string(val) + sv.AttachmentId = ptr.String(xtv) + } - case strings.EqualFold("instanceId", t.Name.Local): + case strings.EqualFold("attachTime", t.Name.Local): val, err := decoder.Value() if err != nil { return err @@ -108284,14 +109430,75 @@ func awsEc2query_deserializeDocumentInstanceStateChange(v **types.InstanceStateC } { xtv := string(val) - sv.InstanceId = ptr.String(xtv) + t, err := smithytime.ParseDateTime(xtv) + if err != nil { + return err + } + sv.AttachTime = ptr.Time(t) } - case strings.EqualFold("previousState", t.Name.Local): - nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) - if err := awsEc2query_deserializeDocumentInstanceState(&sv.PreviousState, nodeDecoder); err != nil { + case strings.EqualFold("deleteOnTermination", 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.DeleteOnTermination = ptr.Bool(xtv) + } + + case strings.EqualFold("deviceIndex", 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.DeviceIndex = ptr.Int32(int32(i64)) + } + + case strings.EqualFold("networkCardIndex", 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.NetworkCardIndex = ptr.Int32(int32(i64)) + } + + case strings.EqualFold("status", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.Status = types.AttachmentStatus(xtv) + } default: // Do nothing and ignore the unexpected tag element @@ -108307,13 +109514,13 @@ func awsEc2query_deserializeDocumentInstanceStateChange(v **types.InstanceStateC return nil } -func awsEc2query_deserializeDocumentInstanceStateChangeList(v *[]types.InstanceStateChange, decoder smithyxml.NodeDecoder) error { +func awsEc2query_deserializeDocumentInstanceSecondaryInterfaceList(v *[]types.InstanceSecondaryInterface, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } - var sv []types.InstanceStateChange + var sv []types.InstanceSecondaryInterface if *v == nil { - sv = make([]types.InstanceStateChange, 0) + sv = make([]types.InstanceSecondaryInterface, 0) } else { sv = *v } @@ -108329,10 +109536,10 @@ func awsEc2query_deserializeDocumentInstanceStateChangeList(v *[]types.InstanceS } switch { case strings.EqualFold("item", t.Name.Local): - var col types.InstanceStateChange + var col types.InstanceSecondaryInterface nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) destAddr := &col - if err := awsEc2query_deserializeDocumentInstanceStateChange(&destAddr, nodeDecoder); err != nil { + if err := awsEc2query_deserializeDocumentInstanceSecondaryInterface(&destAddr, nodeDecoder); err != nil { return err } col = *destAddr @@ -108351,22 +109558,22 @@ func awsEc2query_deserializeDocumentInstanceStateChangeList(v *[]types.InstanceS return nil } -func awsEc2query_deserializeDocumentInstanceStateChangeListUnwrapped(v *[]types.InstanceStateChange, decoder smithyxml.NodeDecoder) error { - var sv []types.InstanceStateChange +func awsEc2query_deserializeDocumentInstanceSecondaryInterfaceListUnwrapped(v *[]types.InstanceSecondaryInterface, decoder smithyxml.NodeDecoder) error { + var sv []types.InstanceSecondaryInterface if *v == nil { - sv = make([]types.InstanceStateChange, 0) + sv = make([]types.InstanceSecondaryInterface, 0) } else { sv = *v } switch { default: - var mv types.InstanceStateChange + var mv types.InstanceSecondaryInterface t := decoder.StartEl _ = t nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) destAddr := &mv - if err := awsEc2query_deserializeDocumentInstanceStateChange(&destAddr, nodeDecoder); err != nil { + if err := awsEc2query_deserializeDocumentInstanceSecondaryInterface(&destAddr, nodeDecoder); err != nil { return err } mv = *destAddr @@ -108375,13 +109582,13 @@ func awsEc2query_deserializeDocumentInstanceStateChangeListUnwrapped(v *[]types. *v = sv return nil } -func awsEc2query_deserializeDocumentInstanceStatus(v **types.InstanceStatus, decoder smithyxml.NodeDecoder) error { +func awsEc2query_deserializeDocumentInstanceSecondaryInterfacePrivateIpAddress(v **types.InstanceSecondaryInterfacePrivateIpAddress, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } - var sv *types.InstanceStatus + var sv *types.InstanceSecondaryInterfacePrivateIpAddress if *v == nil { - sv = &types.InstanceStatus{} + sv = &types.InstanceSecondaryInterfacePrivateIpAddress{} } else { sv = *v } @@ -108397,76 +109604,7 @@ func awsEc2query_deserializeDocumentInstanceStatus(v **types.InstanceStatus, dec originalDecoder := decoder decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) switch { - case strings.EqualFold("attachedEbsStatus", t.Name.Local): - nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) - if err := awsEc2query_deserializeDocumentEbsStatusSummary(&sv.AttachedEbsStatus, nodeDecoder); err != nil { - return err - } - - case strings.EqualFold("availabilityZone", t.Name.Local): - val, err := decoder.Value() - if err != nil { - return err - } - if val == nil { - break - } - { - xtv := string(val) - sv.AvailabilityZone = ptr.String(xtv) - } - - case strings.EqualFold("availabilityZoneId", t.Name.Local): - val, err := decoder.Value() - if err != nil { - return err - } - if val == nil { - break - } - { - xtv := string(val) - sv.AvailabilityZoneId = ptr.String(xtv) - } - - case strings.EqualFold("eventsSet", t.Name.Local): - nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) - if err := awsEc2query_deserializeDocumentInstanceStatusEventList(&sv.Events, nodeDecoder); err != nil { - return err - } - - case strings.EqualFold("instanceId", t.Name.Local): - val, err := decoder.Value() - if err != nil { - return err - } - if val == nil { - break - } - { - xtv := string(val) - sv.InstanceId = ptr.String(xtv) - } - - case strings.EqualFold("instanceState", t.Name.Local): - nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) - if err := awsEc2query_deserializeDocumentInstanceState(&sv.InstanceState, nodeDecoder); err != nil { - return err - } - - case strings.EqualFold("instanceStatus", t.Name.Local): - nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) - if err := awsEc2query_deserializeDocumentInstanceStatusSummary(&sv.InstanceStatus, nodeDecoder); err != nil { - return err - } - - case strings.EqualFold("operator", t.Name.Local): - nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) - if err := awsEc2query_deserializeDocumentOperatorResponse(&sv.Operator, nodeDecoder); err != nil { - return err - } - - case strings.EqualFold("outpostArn", t.Name.Local): + case strings.EqualFold("privateIpAddress", t.Name.Local): val, err := decoder.Value() if err != nil { return err @@ -108476,13 +109614,7 @@ func awsEc2query_deserializeDocumentInstanceStatus(v **types.InstanceStatus, dec } { xtv := string(val) - sv.OutpostArn = ptr.String(xtv) - } - - case strings.EqualFold("systemStatus", t.Name.Local): - nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) - if err := awsEc2query_deserializeDocumentInstanceStatusSummary(&sv.SystemStatus, nodeDecoder); err != nil { - return err + sv.PrivateIpAddress = ptr.String(xtv) } default: @@ -108499,17 +109631,18 @@ func awsEc2query_deserializeDocumentInstanceStatus(v **types.InstanceStatus, dec return nil } -func awsEc2query_deserializeDocumentInstanceStatusDetails(v **types.InstanceStatusDetails, decoder smithyxml.NodeDecoder) error { +func awsEc2query_deserializeDocumentInstanceSecondaryInterfacePrivateIpAddressList(v *[]types.InstanceSecondaryInterfacePrivateIpAddress, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } - var sv *types.InstanceStatusDetails + var sv []types.InstanceSecondaryInterfacePrivateIpAddress if *v == nil { - sv = &types.InstanceStatusDetails{} + sv = make([]types.InstanceSecondaryInterfacePrivateIpAddress, 0) } else { sv = *v } + originalDecoder := decoder for { t, done, err := decoder.Token() if err != nil { @@ -108518,54 +109651,18 @@ func awsEc2query_deserializeDocumentInstanceStatusDetails(v **types.InstanceStat if done { break } - originalDecoder := decoder - decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) switch { - case strings.EqualFold("impairedSince", 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.ImpairedSince = ptr.Time(t) - } - - case strings.EqualFold("name", t.Name.Local): - val, err := decoder.Value() - if err != nil { - return err - } - if val == nil { - break - } - { - xtv := string(val) - sv.Name = types.StatusName(xtv) - } - - case strings.EqualFold("status", t.Name.Local): - val, err := decoder.Value() - if err != nil { + case strings.EqualFold("item", t.Name.Local): + var col types.InstanceSecondaryInterfacePrivateIpAddress + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + destAddr := &col + if err := awsEc2query_deserializeDocumentInstanceSecondaryInterfacePrivateIpAddress(&destAddr, nodeDecoder); err != nil { return err } - if val == nil { - break - } - { - xtv := string(val) - sv.Status = types.StatusType(xtv) - } + col = *destAddr + sv = append(sv, col) default: - // Do nothing and ignore the unexpected tag element err = decoder.Decoder.Skip() if err != nil { return err @@ -108578,13 +109675,37 @@ func awsEc2query_deserializeDocumentInstanceStatusDetails(v **types.InstanceStat return nil } -func awsEc2query_deserializeDocumentInstanceStatusDetailsList(v *[]types.InstanceStatusDetails, decoder smithyxml.NodeDecoder) error { +func awsEc2query_deserializeDocumentInstanceSecondaryInterfacePrivateIpAddressListUnwrapped(v *[]types.InstanceSecondaryInterfacePrivateIpAddress, decoder smithyxml.NodeDecoder) error { + var sv []types.InstanceSecondaryInterfacePrivateIpAddress + if *v == nil { + sv = make([]types.InstanceSecondaryInterfacePrivateIpAddress, 0) + } else { + sv = *v + } + + switch { + default: + var mv types.InstanceSecondaryInterfacePrivateIpAddress + t := decoder.StartEl + _ = t + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + destAddr := &mv + if err := awsEc2query_deserializeDocumentInstanceSecondaryInterfacePrivateIpAddress(&destAddr, nodeDecoder); err != nil { + return err + } + mv = *destAddr + sv = append(sv, mv) + } + *v = sv + return nil +} +func awsEc2query_deserializeDocumentInstanceSet(v *[]types.InstanceTopology, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } - var sv []types.InstanceStatusDetails + var sv []types.InstanceTopology if *v == nil { - sv = make([]types.InstanceStatusDetails, 0) + sv = make([]types.InstanceTopology, 0) } else { sv = *v } @@ -108600,10 +109721,10 @@ func awsEc2query_deserializeDocumentInstanceStatusDetailsList(v *[]types.Instanc } switch { case strings.EqualFold("item", t.Name.Local): - var col types.InstanceStatusDetails + var col types.InstanceTopology nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) destAddr := &col - if err := awsEc2query_deserializeDocumentInstanceStatusDetails(&destAddr, nodeDecoder); err != nil { + if err := awsEc2query_deserializeDocumentInstanceTopology(&destAddr, nodeDecoder); err != nil { return err } col = *destAddr @@ -108622,22 +109743,22 @@ func awsEc2query_deserializeDocumentInstanceStatusDetailsList(v *[]types.Instanc return nil } -func awsEc2query_deserializeDocumentInstanceStatusDetailsListUnwrapped(v *[]types.InstanceStatusDetails, decoder smithyxml.NodeDecoder) error { - var sv []types.InstanceStatusDetails +func awsEc2query_deserializeDocumentInstanceSetUnwrapped(v *[]types.InstanceTopology, decoder smithyxml.NodeDecoder) error { + var sv []types.InstanceTopology if *v == nil { - sv = make([]types.InstanceStatusDetails, 0) + sv = make([]types.InstanceTopology, 0) } else { sv = *v } switch { default: - var mv types.InstanceStatusDetails + var mv types.InstanceTopology t := decoder.StartEl _ = t nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) destAddr := &mv - if err := awsEc2query_deserializeDocumentInstanceStatusDetails(&destAddr, nodeDecoder); err != nil { + if err := awsEc2query_deserializeDocumentInstanceTopology(&destAddr, nodeDecoder); err != nil { return err } mv = *destAddr @@ -108646,13 +109767,479 @@ func awsEc2query_deserializeDocumentInstanceStatusDetailsListUnwrapped(v *[]type *v = sv return nil } -func awsEc2query_deserializeDocumentInstanceStatusEvent(v **types.InstanceStatusEvent, decoder smithyxml.NodeDecoder) error { +func awsEc2query_deserializeDocumentInstanceState(v **types.InstanceState, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } - var sv *types.InstanceStatusEvent + var sv *types.InstanceState if *v == nil { - sv = &types.InstanceStatusEvent{} + sv = &types.InstanceState{} + } else { + sv = *v + } + + for { + t, 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) + i64, err := strconv.ParseInt(xtv, 10, 64) + if err != nil { + return err + } + sv.Code = ptr.Int32(int32(i64)) + } + + case strings.EqualFold("name", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.Name = types.InstanceStateName(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_deserializeDocumentInstanceStateChange(v **types.InstanceStateChange, decoder smithyxml.NodeDecoder) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + var sv *types.InstanceStateChange + if *v == nil { + sv = &types.InstanceStateChange{} + } else { + sv = *v + } + + for { + t, done, err := decoder.Token() + if err != nil { + return err + } + if done { + break + } + originalDecoder := decoder + decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) + switch { + case strings.EqualFold("currentState", t.Name.Local): + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + if err := awsEc2query_deserializeDocumentInstanceState(&sv.CurrentState, nodeDecoder); err != nil { + return err + } + + case strings.EqualFold("instanceId", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.InstanceId = ptr.String(xtv) + } + + case strings.EqualFold("previousState", t.Name.Local): + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + if err := awsEc2query_deserializeDocumentInstanceState(&sv.PreviousState, 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_deserializeDocumentInstanceStateChangeList(v *[]types.InstanceStateChange, decoder smithyxml.NodeDecoder) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + var sv []types.InstanceStateChange + if *v == nil { + sv = make([]types.InstanceStateChange, 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.InstanceStateChange + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + destAddr := &col + if err := awsEc2query_deserializeDocumentInstanceStateChange(&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_deserializeDocumentInstanceStateChangeListUnwrapped(v *[]types.InstanceStateChange, decoder smithyxml.NodeDecoder) error { + var sv []types.InstanceStateChange + if *v == nil { + sv = make([]types.InstanceStateChange, 0) + } else { + sv = *v + } + + switch { + default: + var mv types.InstanceStateChange + t := decoder.StartEl + _ = t + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + destAddr := &mv + if err := awsEc2query_deserializeDocumentInstanceStateChange(&destAddr, nodeDecoder); err != nil { + return err + } + mv = *destAddr + sv = append(sv, mv) + } + *v = sv + return nil +} +func awsEc2query_deserializeDocumentInstanceStatus(v **types.InstanceStatus, decoder smithyxml.NodeDecoder) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + var sv *types.InstanceStatus + if *v == nil { + sv = &types.InstanceStatus{} + } else { + sv = *v + } + + for { + t, done, err := decoder.Token() + if err != nil { + return err + } + if done { + break + } + originalDecoder := decoder + decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) + switch { + case strings.EqualFold("attachedEbsStatus", t.Name.Local): + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + if err := awsEc2query_deserializeDocumentEbsStatusSummary(&sv.AttachedEbsStatus, nodeDecoder); err != nil { + return err + } + + case strings.EqualFold("availabilityZone", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.AvailabilityZone = ptr.String(xtv) + } + + case strings.EqualFold("availabilityZoneId", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.AvailabilityZoneId = ptr.String(xtv) + } + + case strings.EqualFold("eventsSet", t.Name.Local): + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + if err := awsEc2query_deserializeDocumentInstanceStatusEventList(&sv.Events, nodeDecoder); err != nil { + return err + } + + case strings.EqualFold("instanceId", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.InstanceId = ptr.String(xtv) + } + + case strings.EqualFold("instanceState", t.Name.Local): + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + if err := awsEc2query_deserializeDocumentInstanceState(&sv.InstanceState, nodeDecoder); err != nil { + return err + } + + case strings.EqualFold("instanceStatus", t.Name.Local): + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + if err := awsEc2query_deserializeDocumentInstanceStatusSummary(&sv.InstanceStatus, nodeDecoder); err != nil { + return err + } + + case strings.EqualFold("operator", t.Name.Local): + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + if err := awsEc2query_deserializeDocumentOperatorResponse(&sv.Operator, nodeDecoder); err != nil { + return err + } + + case strings.EqualFold("outpostArn", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.OutpostArn = ptr.String(xtv) + } + + case strings.EqualFold("systemStatus", t.Name.Local): + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + if err := awsEc2query_deserializeDocumentInstanceStatusSummary(&sv.SystemStatus, 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_deserializeDocumentInstanceStatusDetails(v **types.InstanceStatusDetails, decoder smithyxml.NodeDecoder) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + var sv *types.InstanceStatusDetails + if *v == nil { + sv = &types.InstanceStatusDetails{} + } else { + sv = *v + } + + for { + t, done, err := decoder.Token() + if err != nil { + return err + } + if done { + break + } + originalDecoder := decoder + decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) + switch { + case strings.EqualFold("impairedSince", 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.ImpairedSince = ptr.Time(t) + } + + case strings.EqualFold("name", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.Name = types.StatusName(xtv) + } + + case strings.EqualFold("status", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.Status = types.StatusType(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_deserializeDocumentInstanceStatusDetailsList(v *[]types.InstanceStatusDetails, decoder smithyxml.NodeDecoder) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + var sv []types.InstanceStatusDetails + if *v == nil { + sv = make([]types.InstanceStatusDetails, 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.InstanceStatusDetails + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + destAddr := &col + if err := awsEc2query_deserializeDocumentInstanceStatusDetails(&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_deserializeDocumentInstanceStatusDetailsListUnwrapped(v *[]types.InstanceStatusDetails, decoder smithyxml.NodeDecoder) error { + var sv []types.InstanceStatusDetails + if *v == nil { + sv = make([]types.InstanceStatusDetails, 0) + } else { + sv = *v + } + + switch { + default: + var mv types.InstanceStatusDetails + t := decoder.StartEl + _ = t + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + destAddr := &mv + if err := awsEc2query_deserializeDocumentInstanceStatusDetails(&destAddr, nodeDecoder); err != nil { + return err + } + mv = *destAddr + sv = append(sv, mv) + } + *v = sv + return nil +} +func awsEc2query_deserializeDocumentInstanceStatusEvent(v **types.InstanceStatusEvent, decoder smithyxml.NodeDecoder) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + var sv *types.InstanceStatusEvent + if *v == nil { + sv = &types.InstanceStatusEvent{} } else { sv = *v } @@ -119769,6 +121356,19 @@ func awsEc2query_deserializeDocumentLaunchTemplateCpuOptions(v **types.LaunchTem sv.CoreCount = ptr.Int32(int32(i64)) } + case strings.EqualFold("nestedVirtualization", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.NestedVirtualization = types.NestedVirtualizationSpecification(xtv) + } + case strings.EqualFold("threadsPerCore", t.Name.Local): val, err := decoder.Value() if err != nil { @@ -121018,13 +122618,13 @@ func awsEc2query_deserializeDocumentLaunchTemplateInstanceNetworkInterfaceSpecif *v = sv return nil } -func awsEc2query_deserializeDocumentLaunchTemplateLicenseConfiguration(v **types.LaunchTemplateLicenseConfiguration, decoder smithyxml.NodeDecoder) error { +func awsEc2query_deserializeDocumentLaunchTemplateInstanceSecondaryInterfaceSpecification(v **types.LaunchTemplateInstanceSecondaryInterfaceSpecification, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } - var sv *types.LaunchTemplateLicenseConfiguration + var sv *types.LaunchTemplateInstanceSecondaryInterfaceSpecification if *v == nil { - sv = &types.LaunchTemplateLicenseConfiguration{} + sv = &types.LaunchTemplateInstanceSecondaryInterfaceSpecification{} } else { sv = *v } @@ -121040,7 +122640,23 @@ func awsEc2query_deserializeDocumentLaunchTemplateLicenseConfiguration(v **types originalDecoder := decoder decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) switch { - case strings.EqualFold("licenseConfigurationArn", t.Name.Local): + case strings.EqualFold("deleteOnTermination", 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.DeleteOnTermination = ptr.Bool(xtv) + } + + case strings.EqualFold("deviceIndex", t.Name.Local): val, err := decoder.Value() if err != nil { return err @@ -121050,7 +122666,77 @@ func awsEc2query_deserializeDocumentLaunchTemplateLicenseConfiguration(v **types } { xtv := string(val) - sv.LicenseConfigurationArn = ptr.String(xtv) + i64, err := strconv.ParseInt(xtv, 10, 64) + if err != nil { + return err + } + sv.DeviceIndex = ptr.Int32(int32(i64)) + } + + case strings.EqualFold("interfaceType", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.InterfaceType = types.SecondaryInterfaceType(xtv) + } + + case strings.EqualFold("networkCardIndex", 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.NetworkCardIndex = ptr.Int32(int32(i64)) + } + + case strings.EqualFold("privateIpAddressCount", 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.PrivateIpAddressCount = ptr.Int32(int32(i64)) + } + + case strings.EqualFold("privateIpAddressesSet", t.Name.Local): + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + if err := awsEc2query_deserializeDocumentSecondaryInterfacePrivateIpAddressSpecificationList(&sv.PrivateIpAddresses, nodeDecoder); err != nil { + return err + } + + case strings.EqualFold("secondarySubnetId", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.SecondarySubnetId = ptr.String(xtv) } default: @@ -121067,13 +122753,13 @@ func awsEc2query_deserializeDocumentLaunchTemplateLicenseConfiguration(v **types return nil } -func awsEc2query_deserializeDocumentLaunchTemplateLicenseList(v *[]types.LaunchTemplateLicenseConfiguration, decoder smithyxml.NodeDecoder) error { +func awsEc2query_deserializeDocumentLaunchTemplateInstanceSecondaryInterfaceSpecificationList(v *[]types.LaunchTemplateInstanceSecondaryInterfaceSpecification, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } - var sv []types.LaunchTemplateLicenseConfiguration + var sv []types.LaunchTemplateInstanceSecondaryInterfaceSpecification if *v == nil { - sv = make([]types.LaunchTemplateLicenseConfiguration, 0) + sv = make([]types.LaunchTemplateInstanceSecondaryInterfaceSpecification, 0) } else { sv = *v } @@ -121089,10 +122775,10 @@ func awsEc2query_deserializeDocumentLaunchTemplateLicenseList(v *[]types.LaunchT } switch { case strings.EqualFold("item", t.Name.Local): - var col types.LaunchTemplateLicenseConfiguration + var col types.LaunchTemplateInstanceSecondaryInterfaceSpecification nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) destAddr := &col - if err := awsEc2query_deserializeDocumentLaunchTemplateLicenseConfiguration(&destAddr, nodeDecoder); err != nil { + if err := awsEc2query_deserializeDocumentLaunchTemplateInstanceSecondaryInterfaceSpecification(&destAddr, nodeDecoder); err != nil { return err } col = *destAddr @@ -121111,22 +122797,22 @@ func awsEc2query_deserializeDocumentLaunchTemplateLicenseList(v *[]types.LaunchT return nil } -func awsEc2query_deserializeDocumentLaunchTemplateLicenseListUnwrapped(v *[]types.LaunchTemplateLicenseConfiguration, decoder smithyxml.NodeDecoder) error { - var sv []types.LaunchTemplateLicenseConfiguration +func awsEc2query_deserializeDocumentLaunchTemplateInstanceSecondaryInterfaceSpecificationListUnwrapped(v *[]types.LaunchTemplateInstanceSecondaryInterfaceSpecification, decoder smithyxml.NodeDecoder) error { + var sv []types.LaunchTemplateInstanceSecondaryInterfaceSpecification if *v == nil { - sv = make([]types.LaunchTemplateLicenseConfiguration, 0) + sv = make([]types.LaunchTemplateInstanceSecondaryInterfaceSpecification, 0) } else { sv = *v } switch { default: - var mv types.LaunchTemplateLicenseConfiguration + var mv types.LaunchTemplateInstanceSecondaryInterfaceSpecification t := decoder.StartEl _ = t nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) destAddr := &mv - if err := awsEc2query_deserializeDocumentLaunchTemplateLicenseConfiguration(&destAddr, nodeDecoder); err != nil { + if err := awsEc2query_deserializeDocumentLaunchTemplateInstanceSecondaryInterfaceSpecification(&destAddr, nodeDecoder); err != nil { return err } mv = *destAddr @@ -121135,62 +122821,13 @@ func awsEc2query_deserializeDocumentLaunchTemplateLicenseListUnwrapped(v *[]type *v = sv return nil } -func awsEc2query_deserializeDocumentLaunchTemplateNetworkPerformanceOptions(v **types.LaunchTemplateNetworkPerformanceOptions, decoder smithyxml.NodeDecoder) error { - if v == nil { - return fmt.Errorf("unexpected nil of type %T", v) - } - var sv *types.LaunchTemplateNetworkPerformanceOptions - if *v == nil { - sv = &types.LaunchTemplateNetworkPerformanceOptions{} - } else { - sv = *v - } - - for { - t, done, err := decoder.Token() - if err != nil { - return err - } - if done { - break - } - originalDecoder := decoder - decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) - switch { - case strings.EqualFold("bandwidthWeighting", t.Name.Local): - val, err := decoder.Value() - if err != nil { - return err - } - if val == nil { - break - } - { - xtv := string(val) - sv.BandwidthWeighting = types.InstanceBandwidthWeighting(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_deserializeDocumentLaunchTemplateOverrides(v **types.LaunchTemplateOverrides, decoder smithyxml.NodeDecoder) error { +func awsEc2query_deserializeDocumentLaunchTemplateLicenseConfiguration(v **types.LaunchTemplateLicenseConfiguration, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } - var sv *types.LaunchTemplateOverrides + var sv *types.LaunchTemplateLicenseConfiguration if *v == nil { - sv = &types.LaunchTemplateOverrides{} + sv = &types.LaunchTemplateLicenseConfiguration{} } else { sv = *v } @@ -121206,95 +122843,7 @@ func awsEc2query_deserializeDocumentLaunchTemplateOverrides(v **types.LaunchTemp originalDecoder := decoder decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) switch { - case strings.EqualFold("availabilityZone", t.Name.Local): - val, err := decoder.Value() - if err != nil { - return err - } - if val == nil { - break - } - { - xtv := string(val) - sv.AvailabilityZone = ptr.String(xtv) - } - - case strings.EqualFold("availabilityZoneId", t.Name.Local): - val, err := decoder.Value() - if err != nil { - return err - } - if val == nil { - break - } - { - xtv := string(val) - sv.AvailabilityZoneId = ptr.String(xtv) - } - - case strings.EqualFold("instanceRequirements", t.Name.Local): - nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) - if err := awsEc2query_deserializeDocumentInstanceRequirements(&sv.InstanceRequirements, nodeDecoder); err != nil { - return err - } - - case strings.EqualFold("instanceType", t.Name.Local): - val, err := decoder.Value() - if err != nil { - return err - } - if val == nil { - break - } - { - xtv := string(val) - sv.InstanceType = types.InstanceType(xtv) - } - - case strings.EqualFold("priority", 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.Priority = ptr.Float64(f64) - } - - case strings.EqualFold("spotPrice", t.Name.Local): - val, err := decoder.Value() - if err != nil { - return err - } - if val == nil { - break - } - { - xtv := string(val) - sv.SpotPrice = ptr.String(xtv) - } - - case strings.EqualFold("subnetId", t.Name.Local): - val, err := decoder.Value() - if err != nil { - return err - } - if val == nil { - break - } - { - xtv := string(val) - sv.SubnetId = ptr.String(xtv) - } - - case strings.EqualFold("weightedCapacity", t.Name.Local): + case strings.EqualFold("licenseConfigurationArn", t.Name.Local): val, err := decoder.Value() if err != nil { return err @@ -121304,11 +122853,7 @@ func awsEc2query_deserializeDocumentLaunchTemplateOverrides(v **types.LaunchTemp } { xtv := string(val) - f64, err := strconv.ParseFloat(xtv, 64) - if err != nil { - return err - } - sv.WeightedCapacity = ptr.Float64(f64) + sv.LicenseConfigurationArn = ptr.String(xtv) } default: @@ -121325,13 +122870,13 @@ func awsEc2query_deserializeDocumentLaunchTemplateOverrides(v **types.LaunchTemp return nil } -func awsEc2query_deserializeDocumentLaunchTemplateOverridesList(v *[]types.LaunchTemplateOverrides, decoder smithyxml.NodeDecoder) error { +func awsEc2query_deserializeDocumentLaunchTemplateLicenseList(v *[]types.LaunchTemplateLicenseConfiguration, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } - var sv []types.LaunchTemplateOverrides + var sv []types.LaunchTemplateLicenseConfiguration if *v == nil { - sv = make([]types.LaunchTemplateOverrides, 0) + sv = make([]types.LaunchTemplateLicenseConfiguration, 0) } else { sv = *v } @@ -121347,10 +122892,10 @@ func awsEc2query_deserializeDocumentLaunchTemplateOverridesList(v *[]types.Launc } switch { case strings.EqualFold("item", t.Name.Local): - var col types.LaunchTemplateOverrides + var col types.LaunchTemplateLicenseConfiguration nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) destAddr := &col - if err := awsEc2query_deserializeDocumentLaunchTemplateOverrides(&destAddr, nodeDecoder); err != nil { + if err := awsEc2query_deserializeDocumentLaunchTemplateLicenseConfiguration(&destAddr, nodeDecoder); err != nil { return err } col = *destAddr @@ -121369,22 +122914,22 @@ func awsEc2query_deserializeDocumentLaunchTemplateOverridesList(v *[]types.Launc return nil } -func awsEc2query_deserializeDocumentLaunchTemplateOverridesListUnwrapped(v *[]types.LaunchTemplateOverrides, decoder smithyxml.NodeDecoder) error { - var sv []types.LaunchTemplateOverrides +func awsEc2query_deserializeDocumentLaunchTemplateLicenseListUnwrapped(v *[]types.LaunchTemplateLicenseConfiguration, decoder smithyxml.NodeDecoder) error { + var sv []types.LaunchTemplateLicenseConfiguration if *v == nil { - sv = make([]types.LaunchTemplateOverrides, 0) + sv = make([]types.LaunchTemplateLicenseConfiguration, 0) } else { sv = *v } switch { default: - var mv types.LaunchTemplateOverrides + var mv types.LaunchTemplateLicenseConfiguration t := decoder.StartEl _ = t nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) destAddr := &mv - if err := awsEc2query_deserializeDocumentLaunchTemplateOverrides(&destAddr, nodeDecoder); err != nil { + if err := awsEc2query_deserializeDocumentLaunchTemplateLicenseConfiguration(&destAddr, nodeDecoder); err != nil { return err } mv = *destAddr @@ -121393,13 +122938,13 @@ func awsEc2query_deserializeDocumentLaunchTemplateOverridesListUnwrapped(v *[]ty *v = sv return nil } -func awsEc2query_deserializeDocumentLaunchTemplatePlacement(v **types.LaunchTemplatePlacement, decoder smithyxml.NodeDecoder) error { +func awsEc2query_deserializeDocumentLaunchTemplateNetworkPerformanceOptions(v **types.LaunchTemplateNetworkPerformanceOptions, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } - var sv *types.LaunchTemplatePlacement + var sv *types.LaunchTemplateNetworkPerformanceOptions if *v == nil { - sv = &types.LaunchTemplatePlacement{} + sv = &types.LaunchTemplateNetworkPerformanceOptions{} } else { sv = *v } @@ -121415,7 +122960,7 @@ func awsEc2query_deserializeDocumentLaunchTemplatePlacement(v **types.LaunchTemp originalDecoder := decoder decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) switch { - case strings.EqualFold("affinity", t.Name.Local): + case strings.EqualFold("bandwidthWeighting", t.Name.Local): val, err := decoder.Value() if err != nil { return err @@ -121425,7 +122970,265 @@ func awsEc2query_deserializeDocumentLaunchTemplatePlacement(v **types.LaunchTemp } { xtv := string(val) - sv.Affinity = ptr.String(xtv) + sv.BandwidthWeighting = types.InstanceBandwidthWeighting(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_deserializeDocumentLaunchTemplateOverrides(v **types.LaunchTemplateOverrides, decoder smithyxml.NodeDecoder) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + var sv *types.LaunchTemplateOverrides + if *v == nil { + sv = &types.LaunchTemplateOverrides{} + } else { + sv = *v + } + + for { + t, done, err := decoder.Token() + if err != nil { + return err + } + if done { + break + } + originalDecoder := decoder + decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) + switch { + case strings.EqualFold("availabilityZone", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.AvailabilityZone = ptr.String(xtv) + } + + case strings.EqualFold("availabilityZoneId", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.AvailabilityZoneId = ptr.String(xtv) + } + + case strings.EqualFold("instanceRequirements", t.Name.Local): + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + if err := awsEc2query_deserializeDocumentInstanceRequirements(&sv.InstanceRequirements, nodeDecoder); err != nil { + return err + } + + case strings.EqualFold("instanceType", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.InstanceType = types.InstanceType(xtv) + } + + case strings.EqualFold("priority", 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.Priority = ptr.Float64(f64) + } + + case strings.EqualFold("spotPrice", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.SpotPrice = ptr.String(xtv) + } + + case strings.EqualFold("subnetId", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.SubnetId = ptr.String(xtv) + } + + case strings.EqualFold("weightedCapacity", 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.WeightedCapacity = ptr.Float64(f64) + } + + default: + // Do nothing and ignore the unexpected tag element + err = decoder.Decoder.Skip() + if err != nil { + return err + } + + } + decoder = originalDecoder + } + *v = sv + return nil +} + +func awsEc2query_deserializeDocumentLaunchTemplateOverridesList(v *[]types.LaunchTemplateOverrides, decoder smithyxml.NodeDecoder) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + var sv []types.LaunchTemplateOverrides + if *v == nil { + sv = make([]types.LaunchTemplateOverrides, 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.LaunchTemplateOverrides + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + destAddr := &col + if err := awsEc2query_deserializeDocumentLaunchTemplateOverrides(&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_deserializeDocumentLaunchTemplateOverridesListUnwrapped(v *[]types.LaunchTemplateOverrides, decoder smithyxml.NodeDecoder) error { + var sv []types.LaunchTemplateOverrides + if *v == nil { + sv = make([]types.LaunchTemplateOverrides, 0) + } else { + sv = *v + } + + switch { + default: + var mv types.LaunchTemplateOverrides + t := decoder.StartEl + _ = t + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + destAddr := &mv + if err := awsEc2query_deserializeDocumentLaunchTemplateOverrides(&destAddr, nodeDecoder); err != nil { + return err + } + mv = *destAddr + sv = append(sv, mv) + } + *v = sv + return nil +} +func awsEc2query_deserializeDocumentLaunchTemplatePlacement(v **types.LaunchTemplatePlacement, decoder smithyxml.NodeDecoder) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + var sv *types.LaunchTemplatePlacement + if *v == nil { + sv = &types.LaunchTemplatePlacement{} + } else { + sv = *v + } + + for { + t, done, err := decoder.Token() + if err != nil { + return err + } + if done { + break + } + originalDecoder := decoder + decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) + switch { + case strings.EqualFold("affinity", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.Affinity = ptr.String(xtv) } case strings.EqualFold("availabilityZone", t.Name.Local): @@ -128387,6 +130190,23 @@ func awsEc2query_deserializeDocumentNetworkInfo(v **types.NetworkInfo, decoder s sv.Ipv4AddressesPerInterface = ptr.Int32(int32(i64)) } + case strings.EqualFold("ipv4AddressesPerSecondaryInterface", 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.Ipv4AddressesPerSecondaryInterface = ptr.Int32(int32(i64)) + } + case strings.EqualFold("ipv6AddressesPerInterface", t.Name.Local): val, err := decoder.Value() if err != nil { @@ -128454,6 +130274,23 @@ func awsEc2query_deserializeDocumentNetworkInfo(v **types.NetworkInfo, decoder s sv.MaximumNetworkInterfaces = ptr.Int32(int32(i64)) } + case strings.EqualFold("maximumSecondaryNetworkInterfaces", 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.MaximumSecondaryNetworkInterfaces = ptr.Int32(int32(i64)) + } + case strings.EqualFold("networkCards", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsEc2query_deserializeDocumentNetworkCardInfoList(&sv.NetworkCards, nodeDecoder); err != nil { @@ -128473,6 +130310,22 @@ func awsEc2query_deserializeDocumentNetworkInfo(v **types.NetworkInfo, decoder s sv.NetworkPerformance = ptr.String(xtv) } + case strings.EqualFold("secondaryNetworkSupported", 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 SecondaryNetworkSupportedFlag to be of type *bool, got %T instead", val) + } + sv.SecondaryNetworkSupported = ptr.Bool(xtv) + } + default: // Do nothing and ignore the unexpected tag element err = decoder.Decoder.Skip() @@ -133966,6 +135819,12 @@ func awsEc2query_deserializeDocumentPlacementGroup(v **types.PlacementGroup, dec sv.LinkedGroupId = ptr.String(xtv) } + case strings.EqualFold("operator", t.Name.Local): + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + if err := awsEc2query_deserializeDocumentOperatorResponse(&sv.Operator, nodeDecoder); err != nil { + return err + } + case strings.EqualFold("partitionCount", t.Name.Local): val, err := decoder.Value() if err != nil { @@ -137811,6 +139670,12 @@ func awsEc2query_deserializeDocumentRegion(v **types.Region, decoder smithyxml.N sv.Endpoint = ptr.String(xtv) } + case strings.EqualFold("geographySet", t.Name.Local): + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + if err := awsEc2query_deserializeDocumentRegionGeographyList(&sv.Geography, nodeDecoder); err != nil { + return err + } + case strings.EqualFold("optInStatus", t.Name.Local): val, err := decoder.Value() if err != nil { @@ -138002,6 +139867,123 @@ func awsEc2query_deserializeDocumentRegionalSummaryListUnwrapped(v *[]types.Regi *v = sv return nil } +func awsEc2query_deserializeDocumentRegionGeography(v **types.RegionGeography, decoder smithyxml.NodeDecoder) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + var sv *types.RegionGeography + if *v == nil { + sv = &types.RegionGeography{} + } else { + sv = *v + } + + for { + t, done, err := decoder.Token() + if err != nil { + return err + } + if done { + break + } + originalDecoder := decoder + decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) + switch { + case strings.EqualFold("name", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.Name = ptr.String(xtv) + } + + default: + // Do nothing and ignore the unexpected tag element + err = decoder.Decoder.Skip() + if err != nil { + return err + } + + } + decoder = originalDecoder + } + *v = sv + return nil +} + +func awsEc2query_deserializeDocumentRegionGeographyList(v *[]types.RegionGeography, decoder smithyxml.NodeDecoder) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + var sv []types.RegionGeography + if *v == nil { + sv = make([]types.RegionGeography, 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.RegionGeography + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + destAddr := &col + if err := awsEc2query_deserializeDocumentRegionGeography(&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_deserializeDocumentRegionGeographyListUnwrapped(v *[]types.RegionGeography, decoder smithyxml.NodeDecoder) error { + var sv []types.RegionGeography + if *v == nil { + sv = make([]types.RegionGeography, 0) + } else { + sv = *v + } + + switch { + default: + var mv types.RegionGeography + t := decoder.StartEl + _ = t + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + destAddr := &mv + if err := awsEc2query_deserializeDocumentRegionGeography(&destAddr, nodeDecoder); err != nil { + return err + } + mv = *destAddr + sv = append(sv, mv) + } + *v = sv + return nil +} func awsEc2query_deserializeDocumentRegionList(v *[]types.Region, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) @@ -140842,6 +142824,12 @@ func awsEc2query_deserializeDocumentResponseLaunchTemplateData(v **types.Respons sv.RamDiskId = ptr.String(xtv) } + case strings.EqualFold("secondaryInterfaceSet", t.Name.Local): + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + if err := awsEc2query_deserializeDocumentLaunchTemplateInstanceSecondaryInterfaceSpecificationList(&sv.SecondaryInterfaces, nodeDecoder); err != nil { + return err + } + case strings.EqualFold("securityGroupIdSet", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsEc2query_deserializeDocumentValueStringList(&sv.SecurityGroupIds, nodeDecoder); err != nil { @@ -144283,7 +146271,1486 @@ func awsEc2query_deserializeDocumentScheduledInstanceAvailability(v **types.Sche sv.AvailabilityZone = ptr.String(xtv) } - case strings.EqualFold("availableInstanceCount", t.Name.Local): + case strings.EqualFold("availableInstanceCount", 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.AvailableInstanceCount = ptr.Int32(int32(i64)) + } + + case strings.EqualFold("firstSlotStartTime", 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.FirstSlotStartTime = ptr.Time(t) + } + + case strings.EqualFold("hourlyPrice", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.HourlyPrice = ptr.String(xtv) + } + + case strings.EqualFold("instanceType", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.InstanceType = ptr.String(xtv) + } + + case strings.EqualFold("maxTermDurationInDays", 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.MaxTermDurationInDays = ptr.Int32(int32(i64)) + } + + case strings.EqualFold("minTermDurationInDays", 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.MinTermDurationInDays = ptr.Int32(int32(i64)) + } + + case strings.EqualFold("networkPlatform", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.NetworkPlatform = ptr.String(xtv) + } + + case strings.EqualFold("platform", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.Platform = ptr.String(xtv) + } + + case strings.EqualFold("purchaseToken", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.PurchaseToken = ptr.String(xtv) + } + + case strings.EqualFold("recurrence", t.Name.Local): + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + if err := awsEc2query_deserializeDocumentScheduledInstanceRecurrence(&sv.Recurrence, nodeDecoder); err != nil { + return err + } + + case strings.EqualFold("slotDurationInHours", 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.SlotDurationInHours = ptr.Int32(int32(i64)) + } + + case strings.EqualFold("totalScheduledInstanceHours", 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.TotalScheduledInstanceHours = ptr.Int32(int32(i64)) + } + + default: + // Do nothing and ignore the unexpected tag element + err = decoder.Decoder.Skip() + if err != nil { + return err + } + + } + decoder = originalDecoder + } + *v = sv + return nil +} + +func awsEc2query_deserializeDocumentScheduledInstanceAvailabilitySet(v *[]types.ScheduledInstanceAvailability, decoder smithyxml.NodeDecoder) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + var sv []types.ScheduledInstanceAvailability + if *v == nil { + sv = make([]types.ScheduledInstanceAvailability, 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.ScheduledInstanceAvailability + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + destAddr := &col + if err := awsEc2query_deserializeDocumentScheduledInstanceAvailability(&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_deserializeDocumentScheduledInstanceAvailabilitySetUnwrapped(v *[]types.ScheduledInstanceAvailability, decoder smithyxml.NodeDecoder) error { + var sv []types.ScheduledInstanceAvailability + if *v == nil { + sv = make([]types.ScheduledInstanceAvailability, 0) + } else { + sv = *v + } + + switch { + default: + var mv types.ScheduledInstanceAvailability + t := decoder.StartEl + _ = t + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + destAddr := &mv + if err := awsEc2query_deserializeDocumentScheduledInstanceAvailability(&destAddr, nodeDecoder); err != nil { + return err + } + mv = *destAddr + sv = append(sv, mv) + } + *v = sv + return nil +} +func awsEc2query_deserializeDocumentScheduledInstanceRecurrence(v **types.ScheduledInstanceRecurrence, decoder smithyxml.NodeDecoder) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + var sv *types.ScheduledInstanceRecurrence + if *v == nil { + sv = &types.ScheduledInstanceRecurrence{} + } else { + sv = *v + } + + for { + t, done, err := decoder.Token() + if err != nil { + return err + } + if done { + break + } + originalDecoder := decoder + decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) + switch { + case strings.EqualFold("frequency", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.Frequency = ptr.String(xtv) + } + + case strings.EqualFold("interval", 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.Interval = ptr.Int32(int32(i64)) + } + + case strings.EqualFold("occurrenceDaySet", t.Name.Local): + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + if err := awsEc2query_deserializeDocumentOccurrenceDaySet(&sv.OccurrenceDaySet, nodeDecoder); err != nil { + return err + } + + case strings.EqualFold("occurrenceRelativeToEnd", 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.OccurrenceRelativeToEnd = ptr.Bool(xtv) + } + + case strings.EqualFold("occurrenceUnit", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.OccurrenceUnit = 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_deserializeDocumentScheduledInstanceSet(v *[]types.ScheduledInstance, decoder smithyxml.NodeDecoder) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + var sv []types.ScheduledInstance + if *v == nil { + sv = make([]types.ScheduledInstance, 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.ScheduledInstance + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + destAddr := &col + if err := awsEc2query_deserializeDocumentScheduledInstance(&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_deserializeDocumentScheduledInstanceSetUnwrapped(v *[]types.ScheduledInstance, decoder smithyxml.NodeDecoder) error { + var sv []types.ScheduledInstance + if *v == nil { + sv = make([]types.ScheduledInstance, 0) + } else { + sv = *v + } + + switch { + default: + var mv types.ScheduledInstance + t := decoder.StartEl + _ = t + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + destAddr := &mv + if err := awsEc2query_deserializeDocumentScheduledInstance(&destAddr, nodeDecoder); err != nil { + return err + } + mv = *destAddr + sv = append(sv, mv) + } + *v = sv + return nil +} +func awsEc2query_deserializeDocumentSecondaryInterface(v **types.SecondaryInterface, decoder smithyxml.NodeDecoder) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + var sv *types.SecondaryInterface + if *v == nil { + sv = &types.SecondaryInterface{} + } else { + sv = *v + } + + for { + t, done, err := decoder.Token() + if err != nil { + return err + } + if done { + break + } + originalDecoder := decoder + decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) + switch { + case strings.EqualFold("attachment", t.Name.Local): + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + if err := awsEc2query_deserializeDocumentSecondaryInterfaceAttachment(&sv.Attachment, nodeDecoder); err != nil { + return err + } + + case strings.EqualFold("availabilityZone", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.AvailabilityZone = ptr.String(xtv) + } + + case strings.EqualFold("availabilityZoneId", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.AvailabilityZoneId = ptr.String(xtv) + } + + case strings.EqualFold("macAddress", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.MacAddress = ptr.String(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("privateIpv4AddressSet", t.Name.Local): + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + if err := awsEc2query_deserializeDocumentSecondaryInterfaceIpv4AddressList(&sv.PrivateIpv4Addresses, nodeDecoder); err != nil { + return err + } + + case strings.EqualFold("secondaryInterfaceArn", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.SecondaryInterfaceArn = ptr.String(xtv) + } + + case strings.EqualFold("secondaryInterfaceId", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.SecondaryInterfaceId = ptr.String(xtv) + } + + case strings.EqualFold("secondaryInterfaceType", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.SecondaryInterfaceType = types.SecondaryInterfaceType(xtv) + } + + case strings.EqualFold("secondaryNetworkId", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.SecondaryNetworkId = ptr.String(xtv) + } + + case strings.EqualFold("secondaryNetworkType", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.SecondaryNetworkType = types.SecondaryNetworkType(xtv) + } + + case strings.EqualFold("secondarySubnetId", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.SecondarySubnetId = ptr.String(xtv) + } + + case strings.EqualFold("sourceDestCheck", 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.SourceDestCheck = ptr.Bool(xtv) + } + + case strings.EqualFold("status", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.Status = types.SecondaryInterfaceStatus(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_deserializeDocumentSecondaryInterfaceAttachment(v **types.SecondaryInterfaceAttachment, decoder smithyxml.NodeDecoder) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + var sv *types.SecondaryInterfaceAttachment + if *v == nil { + sv = &types.SecondaryInterfaceAttachment{} + } else { + sv = *v + } + + for { + t, done, err := decoder.Token() + if err != nil { + return err + } + if done { + break + } + originalDecoder := decoder + decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) + switch { + case strings.EqualFold("attachmentId", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.AttachmentId = ptr.String(xtv) + } + + case strings.EqualFold("attachTime", 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.AttachTime = ptr.Time(t) + } + + case strings.EqualFold("deleteOnTermination", 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.DeleteOnTermination = ptr.Bool(xtv) + } + + case strings.EqualFold("deviceIndex", 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.DeviceIndex = ptr.Int32(int32(i64)) + } + + case strings.EqualFold("instanceId", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.InstanceId = ptr.String(xtv) + } + + case strings.EqualFold("instanceOwnerId", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.InstanceOwnerId = ptr.String(xtv) + } + + case strings.EqualFold("networkCardIndex", 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.NetworkCardIndex = ptr.Int32(int32(i64)) + } + + case strings.EqualFold("status", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.Status = types.AttachmentStatus(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_deserializeDocumentSecondaryInterfaceIpv4Address(v **types.SecondaryInterfaceIpv4Address, decoder smithyxml.NodeDecoder) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + var sv *types.SecondaryInterfaceIpv4Address + if *v == nil { + sv = &types.SecondaryInterfaceIpv4Address{} + } else { + sv = *v + } + + for { + t, done, err := decoder.Token() + if err != nil { + return err + } + if done { + break + } + originalDecoder := decoder + decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) + switch { + case strings.EqualFold("privateIpAddress", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.PrivateIpAddress = 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_deserializeDocumentSecondaryInterfaceIpv4AddressList(v *[]types.SecondaryInterfaceIpv4Address, decoder smithyxml.NodeDecoder) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + var sv []types.SecondaryInterfaceIpv4Address + if *v == nil { + sv = make([]types.SecondaryInterfaceIpv4Address, 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.SecondaryInterfaceIpv4Address + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + destAddr := &col + if err := awsEc2query_deserializeDocumentSecondaryInterfaceIpv4Address(&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_deserializeDocumentSecondaryInterfaceIpv4AddressListUnwrapped(v *[]types.SecondaryInterfaceIpv4Address, decoder smithyxml.NodeDecoder) error { + var sv []types.SecondaryInterfaceIpv4Address + if *v == nil { + sv = make([]types.SecondaryInterfaceIpv4Address, 0) + } else { + sv = *v + } + + switch { + default: + var mv types.SecondaryInterfaceIpv4Address + t := decoder.StartEl + _ = t + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + destAddr := &mv + if err := awsEc2query_deserializeDocumentSecondaryInterfaceIpv4Address(&destAddr, nodeDecoder); err != nil { + return err + } + mv = *destAddr + sv = append(sv, mv) + } + *v = sv + return nil +} +func awsEc2query_deserializeDocumentSecondaryInterfaceList(v *[]types.SecondaryInterface, decoder smithyxml.NodeDecoder) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + var sv []types.SecondaryInterface + if *v == nil { + sv = make([]types.SecondaryInterface, 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.SecondaryInterface + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + destAddr := &col + if err := awsEc2query_deserializeDocumentSecondaryInterface(&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_deserializeDocumentSecondaryInterfaceListUnwrapped(v *[]types.SecondaryInterface, decoder smithyxml.NodeDecoder) error { + var sv []types.SecondaryInterface + if *v == nil { + sv = make([]types.SecondaryInterface, 0) + } else { + sv = *v + } + + switch { + default: + var mv types.SecondaryInterface + t := decoder.StartEl + _ = t + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + destAddr := &mv + if err := awsEc2query_deserializeDocumentSecondaryInterface(&destAddr, nodeDecoder); err != nil { + return err + } + mv = *destAddr + sv = append(sv, mv) + } + *v = sv + return nil +} +func awsEc2query_deserializeDocumentSecondaryInterfacePrivateIpAddressSpecification(v **types.SecondaryInterfacePrivateIpAddressSpecification, decoder smithyxml.NodeDecoder) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + var sv *types.SecondaryInterfacePrivateIpAddressSpecification + if *v == nil { + sv = &types.SecondaryInterfacePrivateIpAddressSpecification{} + } else { + sv = *v + } + + for { + t, done, err := decoder.Token() + if err != nil { + return err + } + if done { + break + } + originalDecoder := decoder + decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) + switch { + case strings.EqualFold("privateIpAddress", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.PrivateIpAddress = 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_deserializeDocumentSecondaryInterfacePrivateIpAddressSpecificationList(v *[]types.SecondaryInterfacePrivateIpAddressSpecification, decoder smithyxml.NodeDecoder) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + var sv []types.SecondaryInterfacePrivateIpAddressSpecification + if *v == nil { + sv = make([]types.SecondaryInterfacePrivateIpAddressSpecification, 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.SecondaryInterfacePrivateIpAddressSpecification + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + destAddr := &col + if err := awsEc2query_deserializeDocumentSecondaryInterfacePrivateIpAddressSpecification(&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_deserializeDocumentSecondaryInterfacePrivateIpAddressSpecificationListUnwrapped(v *[]types.SecondaryInterfacePrivateIpAddressSpecification, decoder smithyxml.NodeDecoder) error { + var sv []types.SecondaryInterfacePrivateIpAddressSpecification + if *v == nil { + sv = make([]types.SecondaryInterfacePrivateIpAddressSpecification, 0) + } else { + sv = *v + } + + switch { + default: + var mv types.SecondaryInterfacePrivateIpAddressSpecification + t := decoder.StartEl + _ = t + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + destAddr := &mv + if err := awsEc2query_deserializeDocumentSecondaryInterfacePrivateIpAddressSpecification(&destAddr, nodeDecoder); err != nil { + return err + } + mv = *destAddr + sv = append(sv, mv) + } + *v = sv + return nil +} +func awsEc2query_deserializeDocumentSecondaryNetwork(v **types.SecondaryNetwork, decoder smithyxml.NodeDecoder) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + var sv *types.SecondaryNetwork + if *v == nil { + sv = &types.SecondaryNetwork{} + } else { + sv = *v + } + + for { + t, done, err := decoder.Token() + if err != nil { + return err + } + if done { + break + } + originalDecoder := decoder + decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) + switch { + case strings.EqualFold("ipv4CidrBlockAssociationSet", t.Name.Local): + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + if err := awsEc2query_deserializeDocumentSecondaryNetworkIpv4CidrBlockAssociationList(&sv.Ipv4CidrBlockAssociations, 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("secondaryNetworkArn", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.SecondaryNetworkArn = ptr.String(xtv) + } + + case strings.EqualFold("secondaryNetworkId", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.SecondaryNetworkId = 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.SecondaryNetworkState(xtv) + } + + case strings.EqualFold("stateReason", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.StateReason = ptr.String(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 + } + + case strings.EqualFold("type", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.Type = types.SecondaryNetworkType(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_deserializeDocumentSecondaryNetworkIpv4CidrBlockAssociation(v **types.SecondaryNetworkIpv4CidrBlockAssociation, decoder smithyxml.NodeDecoder) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + var sv *types.SecondaryNetworkIpv4CidrBlockAssociation + if *v == nil { + sv = &types.SecondaryNetworkIpv4CidrBlockAssociation{} + } else { + sv = *v + } + + for { + t, done, err := decoder.Token() + if err != nil { + return err + } + if done { + break + } + originalDecoder := decoder + decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) + switch { + case strings.EqualFold("associationId", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.AssociationId = ptr.String(xtv) + } + + case strings.EqualFold("cidrBlock", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.CidrBlock = 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.SecondaryNetworkCidrBlockAssociationState(xtv) + } + + case strings.EqualFold("stateReason", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.StateReason = 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_deserializeDocumentSecondaryNetworkIpv4CidrBlockAssociationList(v *[]types.SecondaryNetworkIpv4CidrBlockAssociation, decoder smithyxml.NodeDecoder) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + var sv []types.SecondaryNetworkIpv4CidrBlockAssociation + if *v == nil { + sv = make([]types.SecondaryNetworkIpv4CidrBlockAssociation, 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.SecondaryNetworkIpv4CidrBlockAssociation + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + destAddr := &col + if err := awsEc2query_deserializeDocumentSecondaryNetworkIpv4CidrBlockAssociation(&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_deserializeDocumentSecondaryNetworkIpv4CidrBlockAssociationListUnwrapped(v *[]types.SecondaryNetworkIpv4CidrBlockAssociation, decoder smithyxml.NodeDecoder) error { + var sv []types.SecondaryNetworkIpv4CidrBlockAssociation + if *v == nil { + sv = make([]types.SecondaryNetworkIpv4CidrBlockAssociation, 0) + } else { + sv = *v + } + + switch { + default: + var mv types.SecondaryNetworkIpv4CidrBlockAssociation + t := decoder.StartEl + _ = t + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + destAddr := &mv + if err := awsEc2query_deserializeDocumentSecondaryNetworkIpv4CidrBlockAssociation(&destAddr, nodeDecoder); err != nil { + return err + } + mv = *destAddr + sv = append(sv, mv) + } + *v = sv + return nil +} +func awsEc2query_deserializeDocumentSecondaryNetworkList(v *[]types.SecondaryNetwork, decoder smithyxml.NodeDecoder) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + var sv []types.SecondaryNetwork + if *v == nil { + sv = make([]types.SecondaryNetwork, 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.SecondaryNetwork + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + destAddr := &col + if err := awsEc2query_deserializeDocumentSecondaryNetwork(&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_deserializeDocumentSecondaryNetworkListUnwrapped(v *[]types.SecondaryNetwork, decoder smithyxml.NodeDecoder) error { + var sv []types.SecondaryNetwork + if *v == nil { + sv = make([]types.SecondaryNetwork, 0) + } else { + sv = *v + } + + switch { + default: + var mv types.SecondaryNetwork + t := decoder.StartEl + _ = t + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + destAddr := &mv + if err := awsEc2query_deserializeDocumentSecondaryNetwork(&destAddr, nodeDecoder); err != nil { + return err + } + mv = *destAddr + sv = append(sv, mv) + } + *v = sv + return nil +} +func awsEc2query_deserializeDocumentSecondarySubnet(v **types.SecondarySubnet, decoder smithyxml.NodeDecoder) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + var sv *types.SecondarySubnet + if *v == nil { + sv = &types.SecondarySubnet{} + } else { + sv = *v + } + + for { + t, done, err := decoder.Token() + if err != nil { + return err + } + if done { + break + } + originalDecoder := decoder + decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) + switch { + case strings.EqualFold("availabilityZone", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.AvailabilityZone = ptr.String(xtv) + } + + case strings.EqualFold("availabilityZoneId", t.Name.Local): val, err := decoder.Value() if err != nil { return err @@ -144293,14 +147760,16 @@ func awsEc2query_deserializeDocumentScheduledInstanceAvailability(v **types.Sche } { xtv := string(val) - i64, err := strconv.ParseInt(xtv, 10, 64) - if err != nil { - return err - } - sv.AvailableInstanceCount = ptr.Int32(int32(i64)) + sv.AvailabilityZoneId = ptr.String(xtv) } - case strings.EqualFold("firstSlotStartTime", t.Name.Local): + case strings.EqualFold("ipv4CidrBlockAssociationSet", t.Name.Local): + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + if err := awsEc2query_deserializeDocumentSecondarySubnetIpv4CidrBlockAssociationList(&sv.Ipv4CidrBlockAssociations, nodeDecoder); err != nil { + return err + } + + case strings.EqualFold("ownerId", t.Name.Local): val, err := decoder.Value() if err != nil { return err @@ -144310,14 +147779,10 @@ func awsEc2query_deserializeDocumentScheduledInstanceAvailability(v **types.Sche } { xtv := string(val) - t, err := smithytime.ParseDateTime(xtv) - if err != nil { - return err - } - sv.FirstSlotStartTime = ptr.Time(t) + sv.OwnerId = ptr.String(xtv) } - case strings.EqualFold("hourlyPrice", t.Name.Local): + case strings.EqualFold("secondaryNetworkId", t.Name.Local): val, err := decoder.Value() if err != nil { return err @@ -144327,10 +147792,10 @@ func awsEc2query_deserializeDocumentScheduledInstanceAvailability(v **types.Sche } { xtv := string(val) - sv.HourlyPrice = ptr.String(xtv) + sv.SecondaryNetworkId = ptr.String(xtv) } - case strings.EqualFold("instanceType", t.Name.Local): + case strings.EqualFold("secondaryNetworkType", t.Name.Local): val, err := decoder.Value() if err != nil { return err @@ -144340,10 +147805,10 @@ func awsEc2query_deserializeDocumentScheduledInstanceAvailability(v **types.Sche } { xtv := string(val) - sv.InstanceType = ptr.String(xtv) + sv.SecondaryNetworkType = types.SecondaryNetworkType(xtv) } - case strings.EqualFold("maxTermDurationInDays", t.Name.Local): + case strings.EqualFold("secondarySubnetArn", t.Name.Local): val, err := decoder.Value() if err != nil { return err @@ -144353,14 +147818,10 @@ func awsEc2query_deserializeDocumentScheduledInstanceAvailability(v **types.Sche } { xtv := string(val) - i64, err := strconv.ParseInt(xtv, 10, 64) - if err != nil { - return err - } - sv.MaxTermDurationInDays = ptr.Int32(int32(i64)) + sv.SecondarySubnetArn = ptr.String(xtv) } - case strings.EqualFold("minTermDurationInDays", t.Name.Local): + case strings.EqualFold("secondarySubnetId", t.Name.Local): val, err := decoder.Value() if err != nil { return err @@ -144370,14 +147831,10 @@ func awsEc2query_deserializeDocumentScheduledInstanceAvailability(v **types.Sche } { xtv := string(val) - i64, err := strconv.ParseInt(xtv, 10, 64) - if err != nil { - return err - } - sv.MinTermDurationInDays = ptr.Int32(int32(i64)) + sv.SecondarySubnetId = ptr.String(xtv) } - case strings.EqualFold("networkPlatform", t.Name.Local): + case strings.EqualFold("state", t.Name.Local): val, err := decoder.Value() if err != nil { return err @@ -144387,10 +147844,10 @@ func awsEc2query_deserializeDocumentScheduledInstanceAvailability(v **types.Sche } { xtv := string(val) - sv.NetworkPlatform = ptr.String(xtv) + sv.State = types.SecondarySubnetState(xtv) } - case strings.EqualFold("platform", t.Name.Local): + case strings.EqualFold("stateReason", t.Name.Local): val, err := decoder.Value() if err != nil { return err @@ -144400,10 +147857,52 @@ func awsEc2query_deserializeDocumentScheduledInstanceAvailability(v **types.Sche } { xtv := string(val) - sv.Platform = ptr.String(xtv) + sv.StateReason = ptr.String(xtv) } - case strings.EqualFold("purchaseToken", t.Name.Local): + 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_deserializeDocumentSecondarySubnetIpv4CidrBlockAssociation(v **types.SecondarySubnetIpv4CidrBlockAssociation, decoder smithyxml.NodeDecoder) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + var sv *types.SecondarySubnetIpv4CidrBlockAssociation + if *v == nil { + sv = &types.SecondarySubnetIpv4CidrBlockAssociation{} + } else { + sv = *v + } + + for { + t, done, err := decoder.Token() + if err != nil { + return err + } + if done { + break + } + originalDecoder := decoder + decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) + switch { + case strings.EqualFold("associationId", t.Name.Local): val, err := decoder.Value() if err != nil { return err @@ -144413,16 +147912,23 @@ func awsEc2query_deserializeDocumentScheduledInstanceAvailability(v **types.Sche } { xtv := string(val) - sv.PurchaseToken = ptr.String(xtv) + sv.AssociationId = ptr.String(xtv) } - case strings.EqualFold("recurrence", t.Name.Local): - nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) - if err := awsEc2query_deserializeDocumentScheduledInstanceRecurrence(&sv.Recurrence, nodeDecoder); err != nil { + case strings.EqualFold("cidrBlock", t.Name.Local): + val, err := decoder.Value() + if err != nil { return err } + if val == nil { + break + } + { + xtv := string(val) + sv.CidrBlock = ptr.String(xtv) + } - case strings.EqualFold("slotDurationInHours", t.Name.Local): + case strings.EqualFold("state", t.Name.Local): val, err := decoder.Value() if err != nil { return err @@ -144432,14 +147938,10 @@ func awsEc2query_deserializeDocumentScheduledInstanceAvailability(v **types.Sche } { xtv := string(val) - i64, err := strconv.ParseInt(xtv, 10, 64) - if err != nil { - return err - } - sv.SlotDurationInHours = ptr.Int32(int32(i64)) + sv.State = types.SecondarySubnetCidrBlockAssociationState(xtv) } - case strings.EqualFold("totalScheduledInstanceHours", t.Name.Local): + case strings.EqualFold("stateReason", t.Name.Local): val, err := decoder.Value() if err != nil { return err @@ -144449,11 +147951,7 @@ func awsEc2query_deserializeDocumentScheduledInstanceAvailability(v **types.Sche } { xtv := string(val) - i64, err := strconv.ParseInt(xtv, 10, 64) - if err != nil { - return err - } - sv.TotalScheduledInstanceHours = ptr.Int32(int32(i64)) + sv.StateReason = ptr.String(xtv) } default: @@ -144470,13 +147968,13 @@ func awsEc2query_deserializeDocumentScheduledInstanceAvailability(v **types.Sche return nil } -func awsEc2query_deserializeDocumentScheduledInstanceAvailabilitySet(v *[]types.ScheduledInstanceAvailability, decoder smithyxml.NodeDecoder) error { +func awsEc2query_deserializeDocumentSecondarySubnetIpv4CidrBlockAssociationList(v *[]types.SecondarySubnetIpv4CidrBlockAssociation, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } - var sv []types.ScheduledInstanceAvailability + var sv []types.SecondarySubnetIpv4CidrBlockAssociation if *v == nil { - sv = make([]types.ScheduledInstanceAvailability, 0) + sv = make([]types.SecondarySubnetIpv4CidrBlockAssociation, 0) } else { sv = *v } @@ -144492,10 +147990,10 @@ func awsEc2query_deserializeDocumentScheduledInstanceAvailabilitySet(v *[]types. } switch { case strings.EqualFold("item", t.Name.Local): - var col types.ScheduledInstanceAvailability + var col types.SecondarySubnetIpv4CidrBlockAssociation nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) destAddr := &col - if err := awsEc2query_deserializeDocumentScheduledInstanceAvailability(&destAddr, nodeDecoder); err != nil { + if err := awsEc2query_deserializeDocumentSecondarySubnetIpv4CidrBlockAssociation(&destAddr, nodeDecoder); err != nil { return err } col = *destAddr @@ -144514,22 +148012,22 @@ func awsEc2query_deserializeDocumentScheduledInstanceAvailabilitySet(v *[]types. return nil } -func awsEc2query_deserializeDocumentScheduledInstanceAvailabilitySetUnwrapped(v *[]types.ScheduledInstanceAvailability, decoder smithyxml.NodeDecoder) error { - var sv []types.ScheduledInstanceAvailability +func awsEc2query_deserializeDocumentSecondarySubnetIpv4CidrBlockAssociationListUnwrapped(v *[]types.SecondarySubnetIpv4CidrBlockAssociation, decoder smithyxml.NodeDecoder) error { + var sv []types.SecondarySubnetIpv4CidrBlockAssociation if *v == nil { - sv = make([]types.ScheduledInstanceAvailability, 0) + sv = make([]types.SecondarySubnetIpv4CidrBlockAssociation, 0) } else { sv = *v } switch { default: - var mv types.ScheduledInstanceAvailability + var mv types.SecondarySubnetIpv4CidrBlockAssociation t := decoder.StartEl _ = t nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) destAddr := &mv - if err := awsEc2query_deserializeDocumentScheduledInstanceAvailability(&destAddr, nodeDecoder); err != nil { + if err := awsEc2query_deserializeDocumentSecondarySubnetIpv4CidrBlockAssociation(&destAddr, nodeDecoder); err != nil { return err } mv = *destAddr @@ -144538,114 +148036,13 @@ func awsEc2query_deserializeDocumentScheduledInstanceAvailabilitySetUnwrapped(v *v = sv return nil } -func awsEc2query_deserializeDocumentScheduledInstanceRecurrence(v **types.ScheduledInstanceRecurrence, decoder smithyxml.NodeDecoder) error { +func awsEc2query_deserializeDocumentSecondarySubnetList(v *[]types.SecondarySubnet, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } - var sv *types.ScheduledInstanceRecurrence + var sv []types.SecondarySubnet if *v == nil { - sv = &types.ScheduledInstanceRecurrence{} - } else { - sv = *v - } - - for { - t, done, err := decoder.Token() - if err != nil { - return err - } - if done { - break - } - originalDecoder := decoder - decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) - switch { - case strings.EqualFold("frequency", t.Name.Local): - val, err := decoder.Value() - if err != nil { - return err - } - if val == nil { - break - } - { - xtv := string(val) - sv.Frequency = ptr.String(xtv) - } - - case strings.EqualFold("interval", 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.Interval = ptr.Int32(int32(i64)) - } - - case strings.EqualFold("occurrenceDaySet", t.Name.Local): - nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) - if err := awsEc2query_deserializeDocumentOccurrenceDaySet(&sv.OccurrenceDaySet, nodeDecoder); err != nil { - return err - } - - case strings.EqualFold("occurrenceRelativeToEnd", 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.OccurrenceRelativeToEnd = ptr.Bool(xtv) - } - - case strings.EqualFold("occurrenceUnit", t.Name.Local): - val, err := decoder.Value() - if err != nil { - return err - } - if val == nil { - break - } - { - xtv := string(val) - sv.OccurrenceUnit = 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_deserializeDocumentScheduledInstanceSet(v *[]types.ScheduledInstance, decoder smithyxml.NodeDecoder) error { - if v == nil { - return fmt.Errorf("unexpected nil of type %T", v) - } - var sv []types.ScheduledInstance - if *v == nil { - sv = make([]types.ScheduledInstance, 0) + sv = make([]types.SecondarySubnet, 0) } else { sv = *v } @@ -144661,10 +148058,10 @@ func awsEc2query_deserializeDocumentScheduledInstanceSet(v *[]types.ScheduledIns } switch { case strings.EqualFold("item", t.Name.Local): - var col types.ScheduledInstance + var col types.SecondarySubnet nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) destAddr := &col - if err := awsEc2query_deserializeDocumentScheduledInstance(&destAddr, nodeDecoder); err != nil { + if err := awsEc2query_deserializeDocumentSecondarySubnet(&destAddr, nodeDecoder); err != nil { return err } col = *destAddr @@ -144683,22 +148080,22 @@ func awsEc2query_deserializeDocumentScheduledInstanceSet(v *[]types.ScheduledIns return nil } -func awsEc2query_deserializeDocumentScheduledInstanceSetUnwrapped(v *[]types.ScheduledInstance, decoder smithyxml.NodeDecoder) error { - var sv []types.ScheduledInstance +func awsEc2query_deserializeDocumentSecondarySubnetListUnwrapped(v *[]types.SecondarySubnet, decoder smithyxml.NodeDecoder) error { + var sv []types.SecondarySubnet if *v == nil { - sv = make([]types.ScheduledInstance, 0) + sv = make([]types.SecondarySubnet, 0) } else { sv = *v } switch { default: - var mv types.ScheduledInstance + var mv types.SecondarySubnet t := decoder.StartEl _ = t nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) destAddr := &mv - if err := awsEc2query_deserializeDocumentScheduledInstance(&destAddr, nodeDecoder); err != nil { + if err := awsEc2query_deserializeDocumentSecondarySubnet(&destAddr, nodeDecoder); err != nil { return err } mv = *destAddr @@ -178414,9 +181811,209 @@ func awsEc2query_deserializeOpDocumentCreateNatGatewayOutput(v **CreateNatGatewa sv.ClientToken = ptr.String(xtv) } - case strings.EqualFold("natGateway", t.Name.Local): + case strings.EqualFold("natGateway", t.Name.Local): + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + if err := awsEc2query_deserializeDocumentNatGateway(&sv.NatGateway, 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_deserializeOpDocumentCreateNetworkAclOutput(v **CreateNetworkAclOutput, decoder smithyxml.NodeDecoder) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + var sv *CreateNetworkAclOutput + if *v == nil { + sv = &CreateNetworkAclOutput{} + } else { + sv = *v + } + + for { + t, done, err := decoder.Token() + if err != nil { + return err + } + if done { + break + } + originalDecoder := decoder + decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) + switch { + case strings.EqualFold("clientToken", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.ClientToken = ptr.String(xtv) + } + + case strings.EqualFold("networkAcl", t.Name.Local): + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + if err := awsEc2query_deserializeDocumentNetworkAcl(&sv.NetworkAcl, 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_deserializeOpDocumentCreateNetworkInsightsAccessScopeOutput(v **CreateNetworkInsightsAccessScopeOutput, decoder smithyxml.NodeDecoder) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + var sv *CreateNetworkInsightsAccessScopeOutput + if *v == nil { + sv = &CreateNetworkInsightsAccessScopeOutput{} + } else { + sv = *v + } + + for { + t, done, err := decoder.Token() + if err != nil { + return err + } + if done { + break + } + originalDecoder := decoder + decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) + switch { + case strings.EqualFold("networkInsightsAccessScope", t.Name.Local): + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + if err := awsEc2query_deserializeDocumentNetworkInsightsAccessScope(&sv.NetworkInsightsAccessScope, nodeDecoder); err != nil { + return err + } + + case strings.EqualFold("networkInsightsAccessScopeContent", t.Name.Local): + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + if err := awsEc2query_deserializeDocumentNetworkInsightsAccessScopeContent(&sv.NetworkInsightsAccessScopeContent, 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_deserializeOpDocumentCreateNetworkInsightsPathOutput(v **CreateNetworkInsightsPathOutput, decoder smithyxml.NodeDecoder) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + var sv *CreateNetworkInsightsPathOutput + if *v == nil { + sv = &CreateNetworkInsightsPathOutput{} + } else { + sv = *v + } + + for { + t, done, err := decoder.Token() + if err != nil { + return err + } + if done { + break + } + originalDecoder := decoder + decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) + switch { + case strings.EqualFold("networkInsightsPath", t.Name.Local): + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + if err := awsEc2query_deserializeDocumentNetworkInsightsPath(&sv.NetworkInsightsPath, 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_deserializeOpDocumentCreateNetworkInterfaceOutput(v **CreateNetworkInterfaceOutput, decoder smithyxml.NodeDecoder) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + var sv *CreateNetworkInterfaceOutput + if *v == nil { + sv = &CreateNetworkInterfaceOutput{} + } else { + sv = *v + } + + for { + t, done, err := decoder.Token() + if err != nil { + return err + } + if done { + break + } + originalDecoder := decoder + decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) + switch { + case strings.EqualFold("clientToken", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.ClientToken = ptr.String(xtv) + } + + case strings.EqualFold("networkInterface", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) - if err := awsEc2query_deserializeDocumentNatGateway(&sv.NatGateway, nodeDecoder); err != nil { + if err := awsEc2query_deserializeDocumentNetworkInterface(&sv.NetworkInterface, nodeDecoder); err != nil { return err } @@ -178434,13 +182031,13 @@ func awsEc2query_deserializeOpDocumentCreateNatGatewayOutput(v **CreateNatGatewa return nil } -func awsEc2query_deserializeOpDocumentCreateNetworkAclOutput(v **CreateNetworkAclOutput, decoder smithyxml.NodeDecoder) error { +func awsEc2query_deserializeOpDocumentCreateNetworkInterfacePermissionOutput(v **CreateNetworkInterfacePermissionOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } - var sv *CreateNetworkAclOutput + var sv *CreateNetworkInterfacePermissionOutput if *v == nil { - sv = &CreateNetworkAclOutput{} + sv = &CreateNetworkInterfacePermissionOutput{} } else { sv = *v } @@ -178456,22 +182053,9 @@ func awsEc2query_deserializeOpDocumentCreateNetworkAclOutput(v **CreateNetworkAc originalDecoder := decoder decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) switch { - case strings.EqualFold("clientToken", t.Name.Local): - val, err := decoder.Value() - if err != nil { - return err - } - if val == nil { - break - } - { - xtv := string(val) - sv.ClientToken = ptr.String(xtv) - } - - case strings.EqualFold("networkAcl", t.Name.Local): + case strings.EqualFold("interfacePermission", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) - if err := awsEc2query_deserializeDocumentNetworkAcl(&sv.NetworkAcl, nodeDecoder); err != nil { + if err := awsEc2query_deserializeDocumentNetworkInterfacePermission(&sv.InterfacePermission, nodeDecoder); err != nil { return err } @@ -178489,13 +182073,13 @@ func awsEc2query_deserializeOpDocumentCreateNetworkAclOutput(v **CreateNetworkAc return nil } -func awsEc2query_deserializeOpDocumentCreateNetworkInsightsAccessScopeOutput(v **CreateNetworkInsightsAccessScopeOutput, decoder smithyxml.NodeDecoder) error { +func awsEc2query_deserializeOpDocumentCreatePlacementGroupOutput(v **CreatePlacementGroupOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } - var sv *CreateNetworkInsightsAccessScopeOutput + var sv *CreatePlacementGroupOutput if *v == nil { - sv = &CreateNetworkInsightsAccessScopeOutput{} + sv = &CreatePlacementGroupOutput{} } else { sv = *v } @@ -178511,15 +182095,9 @@ func awsEc2query_deserializeOpDocumentCreateNetworkInsightsAccessScopeOutput(v * originalDecoder := decoder decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) switch { - case strings.EqualFold("networkInsightsAccessScope", t.Name.Local): - nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) - if err := awsEc2query_deserializeDocumentNetworkInsightsAccessScope(&sv.NetworkInsightsAccessScope, nodeDecoder); err != nil { - return err - } - - case strings.EqualFold("networkInsightsAccessScopeContent", t.Name.Local): + case strings.EqualFold("placementGroup", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) - if err := awsEc2query_deserializeDocumentNetworkInsightsAccessScopeContent(&sv.NetworkInsightsAccessScopeContent, nodeDecoder); err != nil { + if err := awsEc2query_deserializeDocumentPlacementGroup(&sv.PlacementGroup, nodeDecoder); err != nil { return err } @@ -178537,13 +182115,13 @@ func awsEc2query_deserializeOpDocumentCreateNetworkInsightsAccessScopeOutput(v * return nil } -func awsEc2query_deserializeOpDocumentCreateNetworkInsightsPathOutput(v **CreateNetworkInsightsPathOutput, decoder smithyxml.NodeDecoder) error { +func awsEc2query_deserializeOpDocumentCreatePublicIpv4PoolOutput(v **CreatePublicIpv4PoolOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } - var sv *CreateNetworkInsightsPathOutput + var sv *CreatePublicIpv4PoolOutput if *v == nil { - sv = &CreateNetworkInsightsPathOutput{} + sv = &CreatePublicIpv4PoolOutput{} } else { sv = *v } @@ -178559,11 +182137,18 @@ func awsEc2query_deserializeOpDocumentCreateNetworkInsightsPathOutput(v **Create originalDecoder := decoder decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) switch { - case strings.EqualFold("networkInsightsPath", t.Name.Local): - nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) - if err := awsEc2query_deserializeDocumentNetworkInsightsPath(&sv.NetworkInsightsPath, nodeDecoder); err != nil { + case strings.EqualFold("poolId", t.Name.Local): + val, err := decoder.Value() + if err != nil { return err } + if val == nil { + break + } + { + xtv := string(val) + sv.PoolId = ptr.String(xtv) + } default: // Do nothing and ignore the unexpected tag element @@ -178579,13 +182164,13 @@ func awsEc2query_deserializeOpDocumentCreateNetworkInsightsPathOutput(v **Create return nil } -func awsEc2query_deserializeOpDocumentCreateNetworkInterfaceOutput(v **CreateNetworkInterfaceOutput, decoder smithyxml.NodeDecoder) error { +func awsEc2query_deserializeOpDocumentCreateReplaceRootVolumeTaskOutput(v **CreateReplaceRootVolumeTaskOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } - var sv *CreateNetworkInterfaceOutput + var sv *CreateReplaceRootVolumeTaskOutput if *v == nil { - sv = &CreateNetworkInterfaceOutput{} + sv = &CreateReplaceRootVolumeTaskOutput{} } else { sv = *v } @@ -178601,22 +182186,9 @@ func awsEc2query_deserializeOpDocumentCreateNetworkInterfaceOutput(v **CreateNet originalDecoder := decoder decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) switch { - case strings.EqualFold("clientToken", t.Name.Local): - val, err := decoder.Value() - if err != nil { - return err - } - if val == nil { - break - } - { - xtv := string(val) - sv.ClientToken = ptr.String(xtv) - } - - case strings.EqualFold("networkInterface", t.Name.Local): + case strings.EqualFold("replaceRootVolumeTask", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) - if err := awsEc2query_deserializeDocumentNetworkInterface(&sv.NetworkInterface, nodeDecoder); err != nil { + if err := awsEc2query_deserializeDocumentReplaceRootVolumeTask(&sv.ReplaceRootVolumeTask, nodeDecoder); err != nil { return err } @@ -178634,13 +182206,13 @@ func awsEc2query_deserializeOpDocumentCreateNetworkInterfaceOutput(v **CreateNet return nil } -func awsEc2query_deserializeOpDocumentCreateNetworkInterfacePermissionOutput(v **CreateNetworkInterfacePermissionOutput, decoder smithyxml.NodeDecoder) error { +func awsEc2query_deserializeOpDocumentCreateReservedInstancesListingOutput(v **CreateReservedInstancesListingOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } - var sv *CreateNetworkInterfacePermissionOutput + var sv *CreateReservedInstancesListingOutput if *v == nil { - sv = &CreateNetworkInterfacePermissionOutput{} + sv = &CreateReservedInstancesListingOutput{} } else { sv = *v } @@ -178656,9 +182228,9 @@ func awsEc2query_deserializeOpDocumentCreateNetworkInterfacePermissionOutput(v * originalDecoder := decoder decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) switch { - case strings.EqualFold("interfacePermission", t.Name.Local): + case strings.EqualFold("reservedInstancesListingsSet", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) - if err := awsEc2query_deserializeDocumentNetworkInterfacePermission(&sv.InterfacePermission, nodeDecoder); err != nil { + if err := awsEc2query_deserializeDocumentReservedInstancesListingList(&sv.ReservedInstancesListings, nodeDecoder); err != nil { return err } @@ -178676,13 +182248,13 @@ func awsEc2query_deserializeOpDocumentCreateNetworkInterfacePermissionOutput(v * return nil } -func awsEc2query_deserializeOpDocumentCreatePlacementGroupOutput(v **CreatePlacementGroupOutput, decoder smithyxml.NodeDecoder) error { +func awsEc2query_deserializeOpDocumentCreateRestoreImageTaskOutput(v **CreateRestoreImageTaskOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } - var sv *CreatePlacementGroupOutput + var sv *CreateRestoreImageTaskOutput if *v == nil { - sv = &CreatePlacementGroupOutput{} + sv = &CreateRestoreImageTaskOutput{} } else { sv = *v } @@ -178698,11 +182270,18 @@ func awsEc2query_deserializeOpDocumentCreatePlacementGroupOutput(v **CreatePlace originalDecoder := decoder decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) switch { - case strings.EqualFold("placementGroup", t.Name.Local): - nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) - if err := awsEc2query_deserializeDocumentPlacementGroup(&sv.PlacementGroup, nodeDecoder); err != nil { + case strings.EqualFold("imageId", t.Name.Local): + val, err := decoder.Value() + if err != nil { return err } + if val == nil { + break + } + { + xtv := string(val) + sv.ImageId = ptr.String(xtv) + } default: // Do nothing and ignore the unexpected tag element @@ -178718,13 +182297,13 @@ func awsEc2query_deserializeOpDocumentCreatePlacementGroupOutput(v **CreatePlace return nil } -func awsEc2query_deserializeOpDocumentCreatePublicIpv4PoolOutput(v **CreatePublicIpv4PoolOutput, decoder smithyxml.NodeDecoder) error { +func awsEc2query_deserializeOpDocumentCreateRouteOutput(v **CreateRouteOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } - var sv *CreatePublicIpv4PoolOutput + var sv *CreateRouteOutput if *v == nil { - sv = &CreatePublicIpv4PoolOutput{} + sv = &CreateRouteOutput{} } else { sv = *v } @@ -178740,7 +182319,7 @@ func awsEc2query_deserializeOpDocumentCreatePublicIpv4PoolOutput(v **CreatePubli originalDecoder := decoder decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) switch { - case strings.EqualFold("poolId", t.Name.Local): + case strings.EqualFold("return", t.Name.Local): val, err := decoder.Value() if err != nil { return err @@ -178749,8 +182328,11 @@ func awsEc2query_deserializeOpDocumentCreatePublicIpv4PoolOutput(v **CreatePubli break } { - xtv := string(val) - sv.PoolId = ptr.String(xtv) + xtv, err := strconv.ParseBool(string(val)) + if err != nil { + return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", val) + } + sv.Return = ptr.Bool(xtv) } default: @@ -178767,13 +182349,13 @@ func awsEc2query_deserializeOpDocumentCreatePublicIpv4PoolOutput(v **CreatePubli return nil } -func awsEc2query_deserializeOpDocumentCreateReplaceRootVolumeTaskOutput(v **CreateReplaceRootVolumeTaskOutput, decoder smithyxml.NodeDecoder) error { +func awsEc2query_deserializeOpDocumentCreateRouteServerEndpointOutput(v **CreateRouteServerEndpointOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } - var sv *CreateReplaceRootVolumeTaskOutput + var sv *CreateRouteServerEndpointOutput if *v == nil { - sv = &CreateReplaceRootVolumeTaskOutput{} + sv = &CreateRouteServerEndpointOutput{} } else { sv = *v } @@ -178789,9 +182371,9 @@ func awsEc2query_deserializeOpDocumentCreateReplaceRootVolumeTaskOutput(v **Crea originalDecoder := decoder decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) switch { - case strings.EqualFold("replaceRootVolumeTask", t.Name.Local): + case strings.EqualFold("routeServerEndpoint", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) - if err := awsEc2query_deserializeDocumentReplaceRootVolumeTask(&sv.ReplaceRootVolumeTask, nodeDecoder); err != nil { + if err := awsEc2query_deserializeDocumentRouteServerEndpoint(&sv.RouteServerEndpoint, nodeDecoder); err != nil { return err } @@ -178809,13 +182391,13 @@ func awsEc2query_deserializeOpDocumentCreateReplaceRootVolumeTaskOutput(v **Crea return nil } -func awsEc2query_deserializeOpDocumentCreateReservedInstancesListingOutput(v **CreateReservedInstancesListingOutput, decoder smithyxml.NodeDecoder) error { +func awsEc2query_deserializeOpDocumentCreateRouteServerOutput(v **CreateRouteServerOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } - var sv *CreateReservedInstancesListingOutput + var sv *CreateRouteServerOutput if *v == nil { - sv = &CreateReservedInstancesListingOutput{} + sv = &CreateRouteServerOutput{} } else { sv = *v } @@ -178831,9 +182413,9 @@ func awsEc2query_deserializeOpDocumentCreateReservedInstancesListingOutput(v **C originalDecoder := decoder decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) switch { - case strings.EqualFold("reservedInstancesListingsSet", t.Name.Local): + case strings.EqualFold("routeServer", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) - if err := awsEc2query_deserializeDocumentReservedInstancesListingList(&sv.ReservedInstancesListings, nodeDecoder); err != nil { + if err := awsEc2query_deserializeDocumentRouteServer(&sv.RouteServer, nodeDecoder); err != nil { return err } @@ -178851,13 +182433,13 @@ func awsEc2query_deserializeOpDocumentCreateReservedInstancesListingOutput(v **C return nil } -func awsEc2query_deserializeOpDocumentCreateRestoreImageTaskOutput(v **CreateRestoreImageTaskOutput, decoder smithyxml.NodeDecoder) error { +func awsEc2query_deserializeOpDocumentCreateRouteServerPeerOutput(v **CreateRouteServerPeerOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } - var sv *CreateRestoreImageTaskOutput + var sv *CreateRouteServerPeerOutput if *v == nil { - sv = &CreateRestoreImageTaskOutput{} + sv = &CreateRouteServerPeerOutput{} } else { sv = *v } @@ -178873,18 +182455,11 @@ func awsEc2query_deserializeOpDocumentCreateRestoreImageTaskOutput(v **CreateRes originalDecoder := decoder decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) switch { - case strings.EqualFold("imageId", t.Name.Local): - val, err := decoder.Value() - if err != nil { + case strings.EqualFold("routeServerPeer", t.Name.Local): + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + if err := awsEc2query_deserializeDocumentRouteServerPeer(&sv.RouteServerPeer, nodeDecoder); err != nil { return err } - if val == nil { - break - } - { - xtv := string(val) - sv.ImageId = ptr.String(xtv) - } default: // Do nothing and ignore the unexpected tag element @@ -178900,13 +182475,13 @@ func awsEc2query_deserializeOpDocumentCreateRestoreImageTaskOutput(v **CreateRes return nil } -func awsEc2query_deserializeOpDocumentCreateRouteOutput(v **CreateRouteOutput, decoder smithyxml.NodeDecoder) error { +func awsEc2query_deserializeOpDocumentCreateRouteTableOutput(v **CreateRouteTableOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } - var sv *CreateRouteOutput + var sv *CreateRouteTableOutput if *v == nil { - sv = &CreateRouteOutput{} + sv = &CreateRouteTableOutput{} } else { sv = *v } @@ -178922,7 +182497,7 @@ func awsEc2query_deserializeOpDocumentCreateRouteOutput(v **CreateRouteOutput, d originalDecoder := decoder decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) switch { - case strings.EqualFold("return", t.Name.Local): + case strings.EqualFold("clientToken", t.Name.Local): val, err := decoder.Value() if err != nil { return err @@ -178931,52 +182506,13 @@ func awsEc2query_deserializeOpDocumentCreateRouteOutput(v **CreateRouteOutput, d 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.Return = ptr.Bool(xtv) - } - - default: - // Do nothing and ignore the unexpected tag element - err = decoder.Decoder.Skip() - if err != nil { - return err + xtv := string(val) + sv.ClientToken = ptr.String(xtv) } - } - decoder = originalDecoder - } - *v = sv - return nil -} - -func awsEc2query_deserializeOpDocumentCreateRouteServerEndpointOutput(v **CreateRouteServerEndpointOutput, decoder smithyxml.NodeDecoder) error { - if v == nil { - return fmt.Errorf("unexpected nil of type %T", v) - } - var sv *CreateRouteServerEndpointOutput - if *v == nil { - sv = &CreateRouteServerEndpointOutput{} - } else { - sv = *v - } - - for { - t, done, err := decoder.Token() - if err != nil { - return err - } - if done { - break - } - originalDecoder := decoder - decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) - switch { - case strings.EqualFold("routeServerEndpoint", t.Name.Local): + case strings.EqualFold("routeTable", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) - if err := awsEc2query_deserializeDocumentRouteServerEndpoint(&sv.RouteServerEndpoint, nodeDecoder); err != nil { + if err := awsEc2query_deserializeDocumentRouteTable(&sv.RouteTable, nodeDecoder); err != nil { return err } @@ -178994,13 +182530,13 @@ func awsEc2query_deserializeOpDocumentCreateRouteServerEndpointOutput(v **Create return nil } -func awsEc2query_deserializeOpDocumentCreateRouteServerOutput(v **CreateRouteServerOutput, decoder smithyxml.NodeDecoder) error { +func awsEc2query_deserializeOpDocumentCreateSecondaryNetworkOutput(v **CreateSecondaryNetworkOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } - var sv *CreateRouteServerOutput + var sv *CreateSecondaryNetworkOutput if *v == nil { - sv = &CreateRouteServerOutput{} + sv = &CreateSecondaryNetworkOutput{} } else { sv = *v } @@ -179016,51 +182552,22 @@ func awsEc2query_deserializeOpDocumentCreateRouteServerOutput(v **CreateRouteSer originalDecoder := decoder decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) switch { - case strings.EqualFold("routeServer", t.Name.Local): - nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) - if err := awsEc2query_deserializeDocumentRouteServer(&sv.RouteServer, nodeDecoder); err != nil { - return err - } - - default: - // Do nothing and ignore the unexpected tag element - err = decoder.Decoder.Skip() + case strings.EqualFold("clientToken", t.Name.Local): + val, err := decoder.Value() if err != nil { return err } + if val == nil { + break + } + { + xtv := string(val) + sv.ClientToken = ptr.String(xtv) + } - } - decoder = originalDecoder - } - *v = sv - return nil -} - -func awsEc2query_deserializeOpDocumentCreateRouteServerPeerOutput(v **CreateRouteServerPeerOutput, decoder smithyxml.NodeDecoder) error { - if v == nil { - return fmt.Errorf("unexpected nil of type %T", v) - } - var sv *CreateRouteServerPeerOutput - if *v == nil { - sv = &CreateRouteServerPeerOutput{} - } else { - sv = *v - } - - for { - t, done, err := decoder.Token() - if err != nil { - return err - } - if done { - break - } - originalDecoder := decoder - decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) - switch { - case strings.EqualFold("routeServerPeer", t.Name.Local): + case strings.EqualFold("secondaryNetwork", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) - if err := awsEc2query_deserializeDocumentRouteServerPeer(&sv.RouteServerPeer, nodeDecoder); err != nil { + if err := awsEc2query_deserializeDocumentSecondaryNetwork(&sv.SecondaryNetwork, nodeDecoder); err != nil { return err } @@ -179078,13 +182585,13 @@ func awsEc2query_deserializeOpDocumentCreateRouteServerPeerOutput(v **CreateRout return nil } -func awsEc2query_deserializeOpDocumentCreateRouteTableOutput(v **CreateRouteTableOutput, decoder smithyxml.NodeDecoder) error { +func awsEc2query_deserializeOpDocumentCreateSecondarySubnetOutput(v **CreateSecondarySubnetOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } - var sv *CreateRouteTableOutput + var sv *CreateSecondarySubnetOutput if *v == nil { - sv = &CreateRouteTableOutput{} + sv = &CreateSecondarySubnetOutput{} } else { sv = *v } @@ -179113,9 +182620,9 @@ func awsEc2query_deserializeOpDocumentCreateRouteTableOutput(v **CreateRouteTabl sv.ClientToken = ptr.String(xtv) } - case strings.EqualFold("routeTable", t.Name.Local): + case strings.EqualFold("secondarySubnet", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) - if err := awsEc2query_deserializeDocumentRouteTable(&sv.RouteTable, nodeDecoder); err != nil { + if err := awsEc2query_deserializeDocumentSecondarySubnet(&sv.SecondarySubnet, nodeDecoder); err != nil { return err } @@ -183380,6 +186887,116 @@ func awsEc2query_deserializeOpDocumentDeleteRouteServerPeerOutput(v **DeleteRout return nil } +func awsEc2query_deserializeOpDocumentDeleteSecondaryNetworkOutput(v **DeleteSecondaryNetworkOutput, decoder smithyxml.NodeDecoder) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + var sv *DeleteSecondaryNetworkOutput + if *v == nil { + sv = &DeleteSecondaryNetworkOutput{} + } else { + sv = *v + } + + for { + t, done, err := decoder.Token() + if err != nil { + return err + } + if done { + break + } + originalDecoder := decoder + decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) + switch { + case strings.EqualFold("clientToken", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.ClientToken = ptr.String(xtv) + } + + case strings.EqualFold("secondaryNetwork", t.Name.Local): + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + if err := awsEc2query_deserializeDocumentSecondaryNetwork(&sv.SecondaryNetwork, 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_deserializeOpDocumentDeleteSecondarySubnetOutput(v **DeleteSecondarySubnetOutput, decoder smithyxml.NodeDecoder) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + var sv *DeleteSecondarySubnetOutput + if *v == nil { + sv = &DeleteSecondarySubnetOutput{} + } else { + sv = *v + } + + for { + t, done, err := decoder.Token() + if err != nil { + return err + } + if done { + break + } + originalDecoder := decoder + decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) + switch { + case strings.EqualFold("clientToken", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.ClientToken = ptr.String(xtv) + } + + case strings.EqualFold("secondarySubnet", t.Name.Local): + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + if err := awsEc2query_deserializeDocumentSecondarySubnet(&sv.SecondarySubnet, 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_deserializeOpDocumentDeleteSecurityGroupOutput(v **DeleteSecurityGroupOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) @@ -191799,6 +195416,171 @@ func awsEc2query_deserializeOpDocumentDescribeScheduledInstancesOutput(v **Descr return nil } +func awsEc2query_deserializeOpDocumentDescribeSecondaryInterfacesOutput(v **DescribeSecondaryInterfacesOutput, decoder smithyxml.NodeDecoder) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + var sv *DescribeSecondaryInterfacesOutput + if *v == nil { + sv = &DescribeSecondaryInterfacesOutput{} + } else { + sv = *v + } + + for { + t, done, err := decoder.Token() + if err != nil { + return err + } + if done { + break + } + originalDecoder := decoder + decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) + switch { + 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("secondaryInterfaceSet", t.Name.Local): + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + if err := awsEc2query_deserializeDocumentSecondaryInterfaceList(&sv.SecondaryInterfaces, 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_deserializeOpDocumentDescribeSecondaryNetworksOutput(v **DescribeSecondaryNetworksOutput, decoder smithyxml.NodeDecoder) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + var sv *DescribeSecondaryNetworksOutput + if *v == nil { + sv = &DescribeSecondaryNetworksOutput{} + } else { + sv = *v + } + + for { + t, done, err := decoder.Token() + if err != nil { + return err + } + if done { + break + } + originalDecoder := decoder + decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) + switch { + 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("secondaryNetworkSet", t.Name.Local): + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + if err := awsEc2query_deserializeDocumentSecondaryNetworkList(&sv.SecondaryNetworks, 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_deserializeOpDocumentDescribeSecondarySubnetsOutput(v **DescribeSecondarySubnetsOutput, decoder smithyxml.NodeDecoder) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + var sv *DescribeSecondarySubnetsOutput + if *v == nil { + sv = &DescribeSecondarySubnetsOutput{} + } else { + sv = *v + } + + for { + t, done, err := decoder.Token() + if err != nil { + return err + } + if done { + break + } + originalDecoder := decoder + decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) + switch { + 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("secondarySubnetSet", t.Name.Local): + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + if err := awsEc2query_deserializeDocumentSecondarySubnetList(&sv.SecondarySubnets, 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_deserializeOpDocumentDescribeSecurityGroupReferencesOutput(v **DescribeSecurityGroupReferencesOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) @@ -204644,6 +208426,19 @@ func awsEc2query_deserializeOpDocumentModifyInstanceCpuOptionsOutput(v **ModifyI sv.InstanceId = ptr.String(xtv) } + case strings.EqualFold("nestedVirtualization", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.NestedVirtualization = types.NestedVirtualizationSpecification(xtv) + } + case strings.EqualFold("threadsPerCore", t.Name.Local): val, err := decoder.Value() if err != nil { diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/generated.json b/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/generated.json index 3faf6a121..fe91ae53d 100644 --- a/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/generated.json +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/generated.json @@ -133,6 +133,8 @@ "api_op_CreateRouteServerEndpoint.go", "api_op_CreateRouteServerPeer.go", "api_op_CreateRouteTable.go", + "api_op_CreateSecondaryNetwork.go", + "api_op_CreateSecondarySubnet.go", "api_op_CreateSecurityGroup.go", "api_op_CreateSnapshot.go", "api_op_CreateSnapshots.go", @@ -225,6 +227,8 @@ "api_op_DeleteRouteServerEndpoint.go", "api_op_DeleteRouteServerPeer.go", "api_op_DeleteRouteTable.go", + "api_op_DeleteSecondaryNetwork.go", + "api_op_DeleteSecondarySubnet.go", "api_op_DeleteSecurityGroup.go", "api_op_DeleteSnapshot.go", "api_op_DeleteSpotDatafeedSubscription.go", @@ -393,6 +397,9 @@ "api_op_DescribeRouteTables.go", "api_op_DescribeScheduledInstanceAvailability.go", "api_op_DescribeScheduledInstances.go", + "api_op_DescribeSecondaryInterfaces.go", + "api_op_DescribeSecondaryNetworks.go", + "api_op_DescribeSecondarySubnets.go", "api_op_DescribeSecurityGroupReferences.go", "api_op_DescribeSecurityGroupRules.go", "api_op_DescribeSecurityGroupVpcAssociations.go", @@ -770,7 +777,6 @@ "internal/endpoints/endpoints.go", "internal/endpoints/endpoints_test.go", "options.go", - "protocol_test.go", "serializers.go", "snapshot_test.go", "sra_operation_order_test.go", @@ -778,7 +784,7 @@ "types/types.go", "validators.go" ], - "go": "1.23", + "go": "1.24", "module": "github.com/aws/aws-sdk-go-v2/service/ec2", "unstable": false } diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/go_module_metadata.go b/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/go_module_metadata.go index 64abb22a8..2fecab13b 100644 --- a/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/go_module_metadata.go +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/go_module_metadata.go @@ -3,4 +3,4 @@ package ec2 // goModuleVersion is the tagged release for this module -const goModuleVersion = "1.285.0" +const goModuleVersion = "1.294.0" diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/options.go b/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/options.go index 3c934b008..6bb1d113c 100644 --- a/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/options.go +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/options.go @@ -58,8 +58,7 @@ type Options struct { // the client option BaseEndpoint instead. EndpointResolver EndpointResolver - // Resolves the endpoint used for a particular service operation. This should be - // used over the deprecated EndpointResolver. + // Resolves the endpoint used for a particular service operation. EndpointResolverV2 EndpointResolverV2 // Signature Version 4 (SigV4) Signer diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/serializers.go b/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/serializers.go index e9a3bcf3a..be62d86c2 100644 --- a/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/serializers.go +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/serializers.go @@ -8558,6 +8558,146 @@ func (m *awsEc2query_serializeOpCreateRouteTable) HandleSerialize(ctx context.Co return next.HandleSerialize(ctx, in) } +type awsEc2query_serializeOpCreateSecondaryNetwork struct { +} + +func (*awsEc2query_serializeOpCreateSecondaryNetwork) ID() string { + return "OperationSerializer" +} + +func (m *awsEc2query_serializeOpCreateSecondaryNetwork) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( + out middleware.SerializeOutput, metadata middleware.Metadata, err error, +) { + _, span := tracing.StartSpan(ctx, "OperationSerializer") + endTimer := startMetricTimer(ctx, "client.call.serialization_duration") + defer endTimer() + defer span.End() + 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.(*CreateSecondaryNetworkInput) + _ = 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("CreateSecondaryNetwork") + body.Key("Version").String("2016-11-15") + + if err := awsEc2query_serializeOpDocumentCreateSecondaryNetworkInput(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 + + endTimer() + span.End() + return next.HandleSerialize(ctx, in) +} + +type awsEc2query_serializeOpCreateSecondarySubnet struct { +} + +func (*awsEc2query_serializeOpCreateSecondarySubnet) ID() string { + return "OperationSerializer" +} + +func (m *awsEc2query_serializeOpCreateSecondarySubnet) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( + out middleware.SerializeOutput, metadata middleware.Metadata, err error, +) { + _, span := tracing.StartSpan(ctx, "OperationSerializer") + endTimer := startMetricTimer(ctx, "client.call.serialization_duration") + defer endTimer() + defer span.End() + 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.(*CreateSecondarySubnetInput) + _ = 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("CreateSecondarySubnet") + body.Key("Version").String("2016-11-15") + + if err := awsEc2query_serializeOpDocumentCreateSecondarySubnetInput(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 + + endTimer() + span.End() + return next.HandleSerialize(ctx, in) +} + type awsEc2query_serializeOpCreateSecurityGroup struct { } @@ -14998,6 +15138,146 @@ func (m *awsEc2query_serializeOpDeleteRouteTable) HandleSerialize(ctx context.Co return next.HandleSerialize(ctx, in) } +type awsEc2query_serializeOpDeleteSecondaryNetwork struct { +} + +func (*awsEc2query_serializeOpDeleteSecondaryNetwork) ID() string { + return "OperationSerializer" +} + +func (m *awsEc2query_serializeOpDeleteSecondaryNetwork) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( + out middleware.SerializeOutput, metadata middleware.Metadata, err error, +) { + _, span := tracing.StartSpan(ctx, "OperationSerializer") + endTimer := startMetricTimer(ctx, "client.call.serialization_duration") + defer endTimer() + defer span.End() + 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.(*DeleteSecondaryNetworkInput) + _ = 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("DeleteSecondaryNetwork") + body.Key("Version").String("2016-11-15") + + if err := awsEc2query_serializeOpDocumentDeleteSecondaryNetworkInput(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 + + endTimer() + span.End() + return next.HandleSerialize(ctx, in) +} + +type awsEc2query_serializeOpDeleteSecondarySubnet struct { +} + +func (*awsEc2query_serializeOpDeleteSecondarySubnet) ID() string { + return "OperationSerializer" +} + +func (m *awsEc2query_serializeOpDeleteSecondarySubnet) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( + out middleware.SerializeOutput, metadata middleware.Metadata, err error, +) { + _, span := tracing.StartSpan(ctx, "OperationSerializer") + endTimer := startMetricTimer(ctx, "client.call.serialization_duration") + defer endTimer() + defer span.End() + 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.(*DeleteSecondarySubnetInput) + _ = 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("DeleteSecondarySubnet") + body.Key("Version").String("2016-11-15") + + if err := awsEc2query_serializeOpDocumentDeleteSecondarySubnetInput(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 + + endTimer() + span.End() + return next.HandleSerialize(ctx, in) +} + type awsEc2query_serializeOpDeleteSecurityGroup struct { } @@ -26758,14 +27038,14 @@ func (m *awsEc2query_serializeOpDescribeScheduledInstances) HandleSerialize(ctx return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpDescribeSecurityGroupReferences struct { +type awsEc2query_serializeOpDescribeSecondaryInterfaces struct { } -func (*awsEc2query_serializeOpDescribeSecurityGroupReferences) ID() string { +func (*awsEc2query_serializeOpDescribeSecondaryInterfaces) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpDescribeSecurityGroupReferences) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDescribeSecondaryInterfaces) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -26777,7 +27057,7 @@ func (m *awsEc2query_serializeOpDescribeSecurityGroupReferences) HandleSerialize return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DescribeSecurityGroupReferencesInput) + input, ok := in.Parameters.(*DescribeSecondaryInterfacesInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -26802,10 +27082,10 @@ func (m *awsEc2query_serializeOpDescribeSecurityGroupReferences) HandleSerialize bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("DescribeSecurityGroupReferences") + body.Key("Action").String("DescribeSecondaryInterfaces") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentDescribeSecurityGroupReferencesInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentDescribeSecondaryInterfacesInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -26828,14 +27108,14 @@ func (m *awsEc2query_serializeOpDescribeSecurityGroupReferences) HandleSerialize return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpDescribeSecurityGroupRules struct { +type awsEc2query_serializeOpDescribeSecondaryNetworks struct { } -func (*awsEc2query_serializeOpDescribeSecurityGroupRules) ID() string { +func (*awsEc2query_serializeOpDescribeSecondaryNetworks) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpDescribeSecurityGroupRules) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDescribeSecondaryNetworks) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -26847,7 +27127,7 @@ func (m *awsEc2query_serializeOpDescribeSecurityGroupRules) HandleSerialize(ctx return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DescribeSecurityGroupRulesInput) + input, ok := in.Parameters.(*DescribeSecondaryNetworksInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -26872,10 +27152,10 @@ func (m *awsEc2query_serializeOpDescribeSecurityGroupRules) HandleSerialize(ctx bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("DescribeSecurityGroupRules") + body.Key("Action").String("DescribeSecondaryNetworks") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentDescribeSecurityGroupRulesInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentDescribeSecondaryNetworksInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -26898,14 +27178,14 @@ func (m *awsEc2query_serializeOpDescribeSecurityGroupRules) HandleSerialize(ctx return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpDescribeSecurityGroups struct { +type awsEc2query_serializeOpDescribeSecondarySubnets struct { } -func (*awsEc2query_serializeOpDescribeSecurityGroups) ID() string { +func (*awsEc2query_serializeOpDescribeSecondarySubnets) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpDescribeSecurityGroups) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDescribeSecondarySubnets) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -26917,7 +27197,7 @@ func (m *awsEc2query_serializeOpDescribeSecurityGroups) HandleSerialize(ctx cont return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DescribeSecurityGroupsInput) + input, ok := in.Parameters.(*DescribeSecondarySubnetsInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -26942,10 +27222,10 @@ func (m *awsEc2query_serializeOpDescribeSecurityGroups) HandleSerialize(ctx cont bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("DescribeSecurityGroups") + body.Key("Action").String("DescribeSecondarySubnets") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentDescribeSecurityGroupsInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentDescribeSecondarySubnetsInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -26968,14 +27248,14 @@ func (m *awsEc2query_serializeOpDescribeSecurityGroups) HandleSerialize(ctx cont return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpDescribeSecurityGroupVpcAssociations struct { +type awsEc2query_serializeOpDescribeSecurityGroupReferences struct { } -func (*awsEc2query_serializeOpDescribeSecurityGroupVpcAssociations) ID() string { +func (*awsEc2query_serializeOpDescribeSecurityGroupReferences) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpDescribeSecurityGroupVpcAssociations) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDescribeSecurityGroupReferences) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -26987,7 +27267,7 @@ func (m *awsEc2query_serializeOpDescribeSecurityGroupVpcAssociations) HandleSeri return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DescribeSecurityGroupVpcAssociationsInput) + input, ok := in.Parameters.(*DescribeSecurityGroupReferencesInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -27012,10 +27292,10 @@ func (m *awsEc2query_serializeOpDescribeSecurityGroupVpcAssociations) HandleSeri bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("DescribeSecurityGroupVpcAssociations") + body.Key("Action").String("DescribeSecurityGroupReferences") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentDescribeSecurityGroupVpcAssociationsInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentDescribeSecurityGroupReferencesInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -27038,14 +27318,14 @@ func (m *awsEc2query_serializeOpDescribeSecurityGroupVpcAssociations) HandleSeri return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpDescribeServiceLinkVirtualInterfaces struct { +type awsEc2query_serializeOpDescribeSecurityGroupRules struct { } -func (*awsEc2query_serializeOpDescribeServiceLinkVirtualInterfaces) ID() string { +func (*awsEc2query_serializeOpDescribeSecurityGroupRules) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpDescribeServiceLinkVirtualInterfaces) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDescribeSecurityGroupRules) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -27057,7 +27337,7 @@ func (m *awsEc2query_serializeOpDescribeServiceLinkVirtualInterfaces) HandleSeri return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DescribeServiceLinkVirtualInterfacesInput) + input, ok := in.Parameters.(*DescribeSecurityGroupRulesInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -27082,10 +27362,10 @@ func (m *awsEc2query_serializeOpDescribeServiceLinkVirtualInterfaces) HandleSeri bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("DescribeServiceLinkVirtualInterfaces") + body.Key("Action").String("DescribeSecurityGroupRules") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentDescribeServiceLinkVirtualInterfacesInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentDescribeSecurityGroupRulesInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -27108,14 +27388,14 @@ func (m *awsEc2query_serializeOpDescribeServiceLinkVirtualInterfaces) HandleSeri return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpDescribeSnapshotAttribute struct { +type awsEc2query_serializeOpDescribeSecurityGroups struct { } -func (*awsEc2query_serializeOpDescribeSnapshotAttribute) ID() string { +func (*awsEc2query_serializeOpDescribeSecurityGroups) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpDescribeSnapshotAttribute) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDescribeSecurityGroups) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -27127,7 +27407,7 @@ func (m *awsEc2query_serializeOpDescribeSnapshotAttribute) HandleSerialize(ctx c return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DescribeSnapshotAttributeInput) + input, ok := in.Parameters.(*DescribeSecurityGroupsInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -27152,10 +27432,10 @@ func (m *awsEc2query_serializeOpDescribeSnapshotAttribute) HandleSerialize(ctx c bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("DescribeSnapshotAttribute") + body.Key("Action").String("DescribeSecurityGroups") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentDescribeSnapshotAttributeInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentDescribeSecurityGroupsInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -27178,14 +27458,14 @@ func (m *awsEc2query_serializeOpDescribeSnapshotAttribute) HandleSerialize(ctx c return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpDescribeSnapshots struct { +type awsEc2query_serializeOpDescribeSecurityGroupVpcAssociations struct { } -func (*awsEc2query_serializeOpDescribeSnapshots) ID() string { +func (*awsEc2query_serializeOpDescribeSecurityGroupVpcAssociations) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpDescribeSnapshots) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDescribeSecurityGroupVpcAssociations) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -27197,7 +27477,7 @@ func (m *awsEc2query_serializeOpDescribeSnapshots) HandleSerialize(ctx context.C return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DescribeSnapshotsInput) + input, ok := in.Parameters.(*DescribeSecurityGroupVpcAssociationsInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -27222,10 +27502,10 @@ func (m *awsEc2query_serializeOpDescribeSnapshots) HandleSerialize(ctx context.C bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("DescribeSnapshots") + body.Key("Action").String("DescribeSecurityGroupVpcAssociations") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentDescribeSnapshotsInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentDescribeSecurityGroupVpcAssociationsInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -27248,14 +27528,14 @@ func (m *awsEc2query_serializeOpDescribeSnapshots) HandleSerialize(ctx context.C return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpDescribeSnapshotTierStatus struct { +type awsEc2query_serializeOpDescribeServiceLinkVirtualInterfaces struct { } -func (*awsEc2query_serializeOpDescribeSnapshotTierStatus) ID() string { +func (*awsEc2query_serializeOpDescribeServiceLinkVirtualInterfaces) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpDescribeSnapshotTierStatus) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDescribeServiceLinkVirtualInterfaces) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -27267,7 +27547,7 @@ func (m *awsEc2query_serializeOpDescribeSnapshotTierStatus) HandleSerialize(ctx return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DescribeSnapshotTierStatusInput) + input, ok := in.Parameters.(*DescribeServiceLinkVirtualInterfacesInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -27292,10 +27572,10 @@ func (m *awsEc2query_serializeOpDescribeSnapshotTierStatus) HandleSerialize(ctx bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("DescribeSnapshotTierStatus") + body.Key("Action").String("DescribeServiceLinkVirtualInterfaces") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentDescribeSnapshotTierStatusInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentDescribeServiceLinkVirtualInterfacesInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -27318,14 +27598,14 @@ func (m *awsEc2query_serializeOpDescribeSnapshotTierStatus) HandleSerialize(ctx return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpDescribeSpotDatafeedSubscription struct { +type awsEc2query_serializeOpDescribeSnapshotAttribute struct { } -func (*awsEc2query_serializeOpDescribeSpotDatafeedSubscription) ID() string { +func (*awsEc2query_serializeOpDescribeSnapshotAttribute) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpDescribeSpotDatafeedSubscription) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDescribeSnapshotAttribute) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -27337,7 +27617,7 @@ func (m *awsEc2query_serializeOpDescribeSpotDatafeedSubscription) HandleSerializ return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DescribeSpotDatafeedSubscriptionInput) + input, ok := in.Parameters.(*DescribeSnapshotAttributeInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -27362,10 +27642,10 @@ func (m *awsEc2query_serializeOpDescribeSpotDatafeedSubscription) HandleSerializ bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("DescribeSpotDatafeedSubscription") + body.Key("Action").String("DescribeSnapshotAttribute") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentDescribeSpotDatafeedSubscriptionInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentDescribeSnapshotAttributeInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -27388,14 +27668,14 @@ func (m *awsEc2query_serializeOpDescribeSpotDatafeedSubscription) HandleSerializ return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpDescribeSpotFleetInstances struct { +type awsEc2query_serializeOpDescribeSnapshots struct { } -func (*awsEc2query_serializeOpDescribeSpotFleetInstances) ID() string { +func (*awsEc2query_serializeOpDescribeSnapshots) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpDescribeSpotFleetInstances) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDescribeSnapshots) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -27407,7 +27687,7 @@ func (m *awsEc2query_serializeOpDescribeSpotFleetInstances) HandleSerialize(ctx return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DescribeSpotFleetInstancesInput) + input, ok := in.Parameters.(*DescribeSnapshotsInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -27432,10 +27712,10 @@ func (m *awsEc2query_serializeOpDescribeSpotFleetInstances) HandleSerialize(ctx bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("DescribeSpotFleetInstances") + body.Key("Action").String("DescribeSnapshots") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentDescribeSpotFleetInstancesInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentDescribeSnapshotsInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -27458,14 +27738,14 @@ func (m *awsEc2query_serializeOpDescribeSpotFleetInstances) HandleSerialize(ctx return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpDescribeSpotFleetRequestHistory struct { +type awsEc2query_serializeOpDescribeSnapshotTierStatus struct { } -func (*awsEc2query_serializeOpDescribeSpotFleetRequestHistory) ID() string { +func (*awsEc2query_serializeOpDescribeSnapshotTierStatus) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpDescribeSpotFleetRequestHistory) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDescribeSnapshotTierStatus) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -27477,7 +27757,7 @@ func (m *awsEc2query_serializeOpDescribeSpotFleetRequestHistory) HandleSerialize return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DescribeSpotFleetRequestHistoryInput) + input, ok := in.Parameters.(*DescribeSnapshotTierStatusInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -27502,10 +27782,10 @@ func (m *awsEc2query_serializeOpDescribeSpotFleetRequestHistory) HandleSerialize bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("DescribeSpotFleetRequestHistory") + body.Key("Action").String("DescribeSnapshotTierStatus") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentDescribeSpotFleetRequestHistoryInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentDescribeSnapshotTierStatusInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -27528,14 +27808,14 @@ func (m *awsEc2query_serializeOpDescribeSpotFleetRequestHistory) HandleSerialize return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpDescribeSpotFleetRequests struct { +type awsEc2query_serializeOpDescribeSpotDatafeedSubscription struct { } -func (*awsEc2query_serializeOpDescribeSpotFleetRequests) ID() string { +func (*awsEc2query_serializeOpDescribeSpotDatafeedSubscription) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpDescribeSpotFleetRequests) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDescribeSpotDatafeedSubscription) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -27547,7 +27827,7 @@ func (m *awsEc2query_serializeOpDescribeSpotFleetRequests) HandleSerialize(ctx c return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DescribeSpotFleetRequestsInput) + input, ok := in.Parameters.(*DescribeSpotDatafeedSubscriptionInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -27572,10 +27852,10 @@ func (m *awsEc2query_serializeOpDescribeSpotFleetRequests) HandleSerialize(ctx c bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("DescribeSpotFleetRequests") + body.Key("Action").String("DescribeSpotDatafeedSubscription") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentDescribeSpotFleetRequestsInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentDescribeSpotDatafeedSubscriptionInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -27598,14 +27878,14 @@ func (m *awsEc2query_serializeOpDescribeSpotFleetRequests) HandleSerialize(ctx c return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpDescribeSpotInstanceRequests struct { +type awsEc2query_serializeOpDescribeSpotFleetInstances struct { } -func (*awsEc2query_serializeOpDescribeSpotInstanceRequests) ID() string { +func (*awsEc2query_serializeOpDescribeSpotFleetInstances) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpDescribeSpotInstanceRequests) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDescribeSpotFleetInstances) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -27617,7 +27897,7 @@ func (m *awsEc2query_serializeOpDescribeSpotInstanceRequests) HandleSerialize(ct return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DescribeSpotInstanceRequestsInput) + input, ok := in.Parameters.(*DescribeSpotFleetInstancesInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -27642,10 +27922,10 @@ func (m *awsEc2query_serializeOpDescribeSpotInstanceRequests) HandleSerialize(ct bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("DescribeSpotInstanceRequests") + body.Key("Action").String("DescribeSpotFleetInstances") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentDescribeSpotInstanceRequestsInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentDescribeSpotFleetInstancesInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -27668,14 +27948,14 @@ func (m *awsEc2query_serializeOpDescribeSpotInstanceRequests) HandleSerialize(ct return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpDescribeSpotPriceHistory struct { +type awsEc2query_serializeOpDescribeSpotFleetRequestHistory struct { } -func (*awsEc2query_serializeOpDescribeSpotPriceHistory) ID() string { +func (*awsEc2query_serializeOpDescribeSpotFleetRequestHistory) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpDescribeSpotPriceHistory) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDescribeSpotFleetRequestHistory) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -27687,7 +27967,7 @@ func (m *awsEc2query_serializeOpDescribeSpotPriceHistory) HandleSerialize(ctx co return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DescribeSpotPriceHistoryInput) + input, ok := in.Parameters.(*DescribeSpotFleetRequestHistoryInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -27712,10 +27992,10 @@ func (m *awsEc2query_serializeOpDescribeSpotPriceHistory) HandleSerialize(ctx co bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("DescribeSpotPriceHistory") + body.Key("Action").String("DescribeSpotFleetRequestHistory") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentDescribeSpotPriceHistoryInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentDescribeSpotFleetRequestHistoryInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -27738,14 +28018,14 @@ func (m *awsEc2query_serializeOpDescribeSpotPriceHistory) HandleSerialize(ctx co return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpDescribeStaleSecurityGroups struct { +type awsEc2query_serializeOpDescribeSpotFleetRequests struct { } -func (*awsEc2query_serializeOpDescribeStaleSecurityGroups) ID() string { +func (*awsEc2query_serializeOpDescribeSpotFleetRequests) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpDescribeStaleSecurityGroups) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDescribeSpotFleetRequests) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -27757,7 +28037,7 @@ func (m *awsEc2query_serializeOpDescribeStaleSecurityGroups) HandleSerialize(ctx return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DescribeStaleSecurityGroupsInput) + input, ok := in.Parameters.(*DescribeSpotFleetRequestsInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -27782,10 +28062,10 @@ func (m *awsEc2query_serializeOpDescribeStaleSecurityGroups) HandleSerialize(ctx bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("DescribeStaleSecurityGroups") + body.Key("Action").String("DescribeSpotFleetRequests") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentDescribeStaleSecurityGroupsInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentDescribeSpotFleetRequestsInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -27808,14 +28088,14 @@ func (m *awsEc2query_serializeOpDescribeStaleSecurityGroups) HandleSerialize(ctx return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpDescribeStoreImageTasks struct { +type awsEc2query_serializeOpDescribeSpotInstanceRequests struct { } -func (*awsEc2query_serializeOpDescribeStoreImageTasks) ID() string { +func (*awsEc2query_serializeOpDescribeSpotInstanceRequests) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpDescribeStoreImageTasks) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDescribeSpotInstanceRequests) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -27827,7 +28107,7 @@ func (m *awsEc2query_serializeOpDescribeStoreImageTasks) HandleSerialize(ctx con return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DescribeStoreImageTasksInput) + input, ok := in.Parameters.(*DescribeSpotInstanceRequestsInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -27852,10 +28132,10 @@ func (m *awsEc2query_serializeOpDescribeStoreImageTasks) HandleSerialize(ctx con bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("DescribeStoreImageTasks") + body.Key("Action").String("DescribeSpotInstanceRequests") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentDescribeStoreImageTasksInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentDescribeSpotInstanceRequestsInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -27878,14 +28158,14 @@ func (m *awsEc2query_serializeOpDescribeStoreImageTasks) HandleSerialize(ctx con return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpDescribeSubnets struct { +type awsEc2query_serializeOpDescribeSpotPriceHistory struct { } -func (*awsEc2query_serializeOpDescribeSubnets) ID() string { +func (*awsEc2query_serializeOpDescribeSpotPriceHistory) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpDescribeSubnets) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDescribeSpotPriceHistory) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -27897,7 +28177,7 @@ func (m *awsEc2query_serializeOpDescribeSubnets) HandleSerialize(ctx context.Con return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DescribeSubnetsInput) + input, ok := in.Parameters.(*DescribeSpotPriceHistoryInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -27922,10 +28202,10 @@ func (m *awsEc2query_serializeOpDescribeSubnets) HandleSerialize(ctx context.Con bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("DescribeSubnets") + body.Key("Action").String("DescribeSpotPriceHistory") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentDescribeSubnetsInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentDescribeSpotPriceHistoryInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -27948,14 +28228,14 @@ func (m *awsEc2query_serializeOpDescribeSubnets) HandleSerialize(ctx context.Con return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpDescribeTags struct { +type awsEc2query_serializeOpDescribeStaleSecurityGroups struct { } -func (*awsEc2query_serializeOpDescribeTags) ID() string { +func (*awsEc2query_serializeOpDescribeStaleSecurityGroups) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpDescribeTags) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDescribeStaleSecurityGroups) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -27967,7 +28247,7 @@ func (m *awsEc2query_serializeOpDescribeTags) HandleSerialize(ctx context.Contex return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DescribeTagsInput) + input, ok := in.Parameters.(*DescribeStaleSecurityGroupsInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -27992,10 +28272,10 @@ func (m *awsEc2query_serializeOpDescribeTags) HandleSerialize(ctx context.Contex bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("DescribeTags") + body.Key("Action").String("DescribeStaleSecurityGroups") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentDescribeTagsInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentDescribeStaleSecurityGroupsInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -28018,14 +28298,14 @@ func (m *awsEc2query_serializeOpDescribeTags) HandleSerialize(ctx context.Contex return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpDescribeTrafficMirrorFilterRules struct { +type awsEc2query_serializeOpDescribeStoreImageTasks struct { } -func (*awsEc2query_serializeOpDescribeTrafficMirrorFilterRules) ID() string { +func (*awsEc2query_serializeOpDescribeStoreImageTasks) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpDescribeTrafficMirrorFilterRules) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDescribeStoreImageTasks) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -28037,7 +28317,7 @@ func (m *awsEc2query_serializeOpDescribeTrafficMirrorFilterRules) HandleSerializ return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DescribeTrafficMirrorFilterRulesInput) + input, ok := in.Parameters.(*DescribeStoreImageTasksInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -28062,10 +28342,10 @@ func (m *awsEc2query_serializeOpDescribeTrafficMirrorFilterRules) HandleSerializ bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("DescribeTrafficMirrorFilterRules") + body.Key("Action").String("DescribeStoreImageTasks") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentDescribeTrafficMirrorFilterRulesInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentDescribeStoreImageTasksInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -28088,14 +28368,14 @@ func (m *awsEc2query_serializeOpDescribeTrafficMirrorFilterRules) HandleSerializ return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpDescribeTrafficMirrorFilters struct { +type awsEc2query_serializeOpDescribeSubnets struct { } -func (*awsEc2query_serializeOpDescribeTrafficMirrorFilters) ID() string { +func (*awsEc2query_serializeOpDescribeSubnets) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpDescribeTrafficMirrorFilters) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDescribeSubnets) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -28107,7 +28387,7 @@ func (m *awsEc2query_serializeOpDescribeTrafficMirrorFilters) HandleSerialize(ct return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DescribeTrafficMirrorFiltersInput) + input, ok := in.Parameters.(*DescribeSubnetsInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -28132,10 +28412,10 @@ func (m *awsEc2query_serializeOpDescribeTrafficMirrorFilters) HandleSerialize(ct bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("DescribeTrafficMirrorFilters") + body.Key("Action").String("DescribeSubnets") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentDescribeTrafficMirrorFiltersInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentDescribeSubnetsInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -28158,14 +28438,14 @@ func (m *awsEc2query_serializeOpDescribeTrafficMirrorFilters) HandleSerialize(ct return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpDescribeTrafficMirrorSessions struct { +type awsEc2query_serializeOpDescribeTags struct { } -func (*awsEc2query_serializeOpDescribeTrafficMirrorSessions) ID() string { +func (*awsEc2query_serializeOpDescribeTags) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpDescribeTrafficMirrorSessions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDescribeTags) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -28177,7 +28457,7 @@ func (m *awsEc2query_serializeOpDescribeTrafficMirrorSessions) HandleSerialize(c return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DescribeTrafficMirrorSessionsInput) + input, ok := in.Parameters.(*DescribeTagsInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -28202,10 +28482,10 @@ func (m *awsEc2query_serializeOpDescribeTrafficMirrorSessions) HandleSerialize(c bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("DescribeTrafficMirrorSessions") + body.Key("Action").String("DescribeTags") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentDescribeTrafficMirrorSessionsInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentDescribeTagsInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -28228,14 +28508,14 @@ func (m *awsEc2query_serializeOpDescribeTrafficMirrorSessions) HandleSerialize(c return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpDescribeTrafficMirrorTargets struct { +type awsEc2query_serializeOpDescribeTrafficMirrorFilterRules struct { } -func (*awsEc2query_serializeOpDescribeTrafficMirrorTargets) ID() string { +func (*awsEc2query_serializeOpDescribeTrafficMirrorFilterRules) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpDescribeTrafficMirrorTargets) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDescribeTrafficMirrorFilterRules) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -28247,7 +28527,7 @@ func (m *awsEc2query_serializeOpDescribeTrafficMirrorTargets) HandleSerialize(ct return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DescribeTrafficMirrorTargetsInput) + input, ok := in.Parameters.(*DescribeTrafficMirrorFilterRulesInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -28272,10 +28552,10 @@ func (m *awsEc2query_serializeOpDescribeTrafficMirrorTargets) HandleSerialize(ct bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("DescribeTrafficMirrorTargets") + body.Key("Action").String("DescribeTrafficMirrorFilterRules") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentDescribeTrafficMirrorTargetsInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentDescribeTrafficMirrorFilterRulesInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -28298,14 +28578,14 @@ func (m *awsEc2query_serializeOpDescribeTrafficMirrorTargets) HandleSerialize(ct return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpDescribeTransitGatewayAttachments struct { +type awsEc2query_serializeOpDescribeTrafficMirrorFilters struct { } -func (*awsEc2query_serializeOpDescribeTransitGatewayAttachments) ID() string { +func (*awsEc2query_serializeOpDescribeTrafficMirrorFilters) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpDescribeTransitGatewayAttachments) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDescribeTrafficMirrorFilters) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -28317,7 +28597,7 @@ func (m *awsEc2query_serializeOpDescribeTransitGatewayAttachments) HandleSeriali return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DescribeTransitGatewayAttachmentsInput) + input, ok := in.Parameters.(*DescribeTrafficMirrorFiltersInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -28342,10 +28622,10 @@ func (m *awsEc2query_serializeOpDescribeTransitGatewayAttachments) HandleSeriali bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("DescribeTransitGatewayAttachments") + body.Key("Action").String("DescribeTrafficMirrorFilters") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentDescribeTransitGatewayAttachmentsInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentDescribeTrafficMirrorFiltersInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -28368,14 +28648,14 @@ func (m *awsEc2query_serializeOpDescribeTransitGatewayAttachments) HandleSeriali return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpDescribeTransitGatewayConnectPeers struct { +type awsEc2query_serializeOpDescribeTrafficMirrorSessions struct { } -func (*awsEc2query_serializeOpDescribeTransitGatewayConnectPeers) ID() string { +func (*awsEc2query_serializeOpDescribeTrafficMirrorSessions) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpDescribeTransitGatewayConnectPeers) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDescribeTrafficMirrorSessions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -28387,7 +28667,7 @@ func (m *awsEc2query_serializeOpDescribeTransitGatewayConnectPeers) HandleSerial return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DescribeTransitGatewayConnectPeersInput) + input, ok := in.Parameters.(*DescribeTrafficMirrorSessionsInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -28412,10 +28692,10 @@ func (m *awsEc2query_serializeOpDescribeTransitGatewayConnectPeers) HandleSerial bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("DescribeTransitGatewayConnectPeers") + body.Key("Action").String("DescribeTrafficMirrorSessions") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentDescribeTransitGatewayConnectPeersInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentDescribeTrafficMirrorSessionsInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -28438,14 +28718,14 @@ func (m *awsEc2query_serializeOpDescribeTransitGatewayConnectPeers) HandleSerial return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpDescribeTransitGatewayConnects struct { +type awsEc2query_serializeOpDescribeTrafficMirrorTargets struct { } -func (*awsEc2query_serializeOpDescribeTransitGatewayConnects) ID() string { +func (*awsEc2query_serializeOpDescribeTrafficMirrorTargets) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpDescribeTransitGatewayConnects) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDescribeTrafficMirrorTargets) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -28457,7 +28737,7 @@ func (m *awsEc2query_serializeOpDescribeTransitGatewayConnects) HandleSerialize( return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DescribeTransitGatewayConnectsInput) + input, ok := in.Parameters.(*DescribeTrafficMirrorTargetsInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -28482,10 +28762,10 @@ func (m *awsEc2query_serializeOpDescribeTransitGatewayConnects) HandleSerialize( bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("DescribeTransitGatewayConnects") + body.Key("Action").String("DescribeTrafficMirrorTargets") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentDescribeTransitGatewayConnectsInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentDescribeTrafficMirrorTargetsInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -28508,14 +28788,14 @@ func (m *awsEc2query_serializeOpDescribeTransitGatewayConnects) HandleSerialize( return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpDescribeTransitGatewayMeteringPolicies struct { +type awsEc2query_serializeOpDescribeTransitGatewayAttachments struct { } -func (*awsEc2query_serializeOpDescribeTransitGatewayMeteringPolicies) ID() string { +func (*awsEc2query_serializeOpDescribeTransitGatewayAttachments) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpDescribeTransitGatewayMeteringPolicies) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDescribeTransitGatewayAttachments) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -28527,7 +28807,7 @@ func (m *awsEc2query_serializeOpDescribeTransitGatewayMeteringPolicies) HandleSe return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DescribeTransitGatewayMeteringPoliciesInput) + input, ok := in.Parameters.(*DescribeTransitGatewayAttachmentsInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -28552,10 +28832,10 @@ func (m *awsEc2query_serializeOpDescribeTransitGatewayMeteringPolicies) HandleSe bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("DescribeTransitGatewayMeteringPolicies") + body.Key("Action").String("DescribeTransitGatewayAttachments") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentDescribeTransitGatewayMeteringPoliciesInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentDescribeTransitGatewayAttachmentsInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -28578,14 +28858,14 @@ func (m *awsEc2query_serializeOpDescribeTransitGatewayMeteringPolicies) HandleSe return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpDescribeTransitGatewayMulticastDomains struct { +type awsEc2query_serializeOpDescribeTransitGatewayConnectPeers struct { } -func (*awsEc2query_serializeOpDescribeTransitGatewayMulticastDomains) ID() string { +func (*awsEc2query_serializeOpDescribeTransitGatewayConnectPeers) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpDescribeTransitGatewayMulticastDomains) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDescribeTransitGatewayConnectPeers) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -28597,7 +28877,7 @@ func (m *awsEc2query_serializeOpDescribeTransitGatewayMulticastDomains) HandleSe return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DescribeTransitGatewayMulticastDomainsInput) + input, ok := in.Parameters.(*DescribeTransitGatewayConnectPeersInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -28622,10 +28902,10 @@ func (m *awsEc2query_serializeOpDescribeTransitGatewayMulticastDomains) HandleSe bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("DescribeTransitGatewayMulticastDomains") + body.Key("Action").String("DescribeTransitGatewayConnectPeers") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentDescribeTransitGatewayMulticastDomainsInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentDescribeTransitGatewayConnectPeersInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -28648,14 +28928,14 @@ func (m *awsEc2query_serializeOpDescribeTransitGatewayMulticastDomains) HandleSe return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpDescribeTransitGatewayPeeringAttachments struct { +type awsEc2query_serializeOpDescribeTransitGatewayConnects struct { } -func (*awsEc2query_serializeOpDescribeTransitGatewayPeeringAttachments) ID() string { +func (*awsEc2query_serializeOpDescribeTransitGatewayConnects) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpDescribeTransitGatewayPeeringAttachments) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDescribeTransitGatewayConnects) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -28667,7 +28947,7 @@ func (m *awsEc2query_serializeOpDescribeTransitGatewayPeeringAttachments) Handle return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DescribeTransitGatewayPeeringAttachmentsInput) + input, ok := in.Parameters.(*DescribeTransitGatewayConnectsInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -28692,10 +28972,10 @@ func (m *awsEc2query_serializeOpDescribeTransitGatewayPeeringAttachments) Handle bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("DescribeTransitGatewayPeeringAttachments") + body.Key("Action").String("DescribeTransitGatewayConnects") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentDescribeTransitGatewayPeeringAttachmentsInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentDescribeTransitGatewayConnectsInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -28718,14 +28998,14 @@ func (m *awsEc2query_serializeOpDescribeTransitGatewayPeeringAttachments) Handle return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpDescribeTransitGatewayPolicyTables struct { +type awsEc2query_serializeOpDescribeTransitGatewayMeteringPolicies struct { } -func (*awsEc2query_serializeOpDescribeTransitGatewayPolicyTables) ID() string { +func (*awsEc2query_serializeOpDescribeTransitGatewayMeteringPolicies) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpDescribeTransitGatewayPolicyTables) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDescribeTransitGatewayMeteringPolicies) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -28737,7 +29017,7 @@ func (m *awsEc2query_serializeOpDescribeTransitGatewayPolicyTables) HandleSerial return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DescribeTransitGatewayPolicyTablesInput) + input, ok := in.Parameters.(*DescribeTransitGatewayMeteringPoliciesInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -28762,10 +29042,10 @@ func (m *awsEc2query_serializeOpDescribeTransitGatewayPolicyTables) HandleSerial bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("DescribeTransitGatewayPolicyTables") + body.Key("Action").String("DescribeTransitGatewayMeteringPolicies") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentDescribeTransitGatewayPolicyTablesInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentDescribeTransitGatewayMeteringPoliciesInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -28788,14 +29068,14 @@ func (m *awsEc2query_serializeOpDescribeTransitGatewayPolicyTables) HandleSerial return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpDescribeTransitGatewayRouteTableAnnouncements struct { +type awsEc2query_serializeOpDescribeTransitGatewayMulticastDomains struct { } -func (*awsEc2query_serializeOpDescribeTransitGatewayRouteTableAnnouncements) ID() string { +func (*awsEc2query_serializeOpDescribeTransitGatewayMulticastDomains) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpDescribeTransitGatewayRouteTableAnnouncements) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDescribeTransitGatewayMulticastDomains) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -28807,7 +29087,7 @@ func (m *awsEc2query_serializeOpDescribeTransitGatewayRouteTableAnnouncements) H return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DescribeTransitGatewayRouteTableAnnouncementsInput) + input, ok := in.Parameters.(*DescribeTransitGatewayMulticastDomainsInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -28832,10 +29112,10 @@ func (m *awsEc2query_serializeOpDescribeTransitGatewayRouteTableAnnouncements) H bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("DescribeTransitGatewayRouteTableAnnouncements") + body.Key("Action").String("DescribeTransitGatewayMulticastDomains") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentDescribeTransitGatewayRouteTableAnnouncementsInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentDescribeTransitGatewayMulticastDomainsInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -28858,14 +29138,14 @@ func (m *awsEc2query_serializeOpDescribeTransitGatewayRouteTableAnnouncements) H return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpDescribeTransitGatewayRouteTables struct { +type awsEc2query_serializeOpDescribeTransitGatewayPeeringAttachments struct { } -func (*awsEc2query_serializeOpDescribeTransitGatewayRouteTables) ID() string { +func (*awsEc2query_serializeOpDescribeTransitGatewayPeeringAttachments) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpDescribeTransitGatewayRouteTables) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDescribeTransitGatewayPeeringAttachments) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -28877,7 +29157,7 @@ func (m *awsEc2query_serializeOpDescribeTransitGatewayRouteTables) HandleSeriali return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DescribeTransitGatewayRouteTablesInput) + input, ok := in.Parameters.(*DescribeTransitGatewayPeeringAttachmentsInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -28902,10 +29182,10 @@ func (m *awsEc2query_serializeOpDescribeTransitGatewayRouteTables) HandleSeriali bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("DescribeTransitGatewayRouteTables") + body.Key("Action").String("DescribeTransitGatewayPeeringAttachments") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentDescribeTransitGatewayRouteTablesInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentDescribeTransitGatewayPeeringAttachmentsInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -28928,14 +29208,14 @@ func (m *awsEc2query_serializeOpDescribeTransitGatewayRouteTables) HandleSeriali return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpDescribeTransitGateways struct { +type awsEc2query_serializeOpDescribeTransitGatewayPolicyTables struct { } -func (*awsEc2query_serializeOpDescribeTransitGateways) ID() string { +func (*awsEc2query_serializeOpDescribeTransitGatewayPolicyTables) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpDescribeTransitGateways) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDescribeTransitGatewayPolicyTables) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -28947,7 +29227,7 @@ func (m *awsEc2query_serializeOpDescribeTransitGateways) HandleSerialize(ctx con return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DescribeTransitGatewaysInput) + input, ok := in.Parameters.(*DescribeTransitGatewayPolicyTablesInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -28972,10 +29252,10 @@ func (m *awsEc2query_serializeOpDescribeTransitGateways) HandleSerialize(ctx con bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("DescribeTransitGateways") + body.Key("Action").String("DescribeTransitGatewayPolicyTables") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentDescribeTransitGatewaysInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentDescribeTransitGatewayPolicyTablesInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -28998,14 +29278,14 @@ func (m *awsEc2query_serializeOpDescribeTransitGateways) HandleSerialize(ctx con return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpDescribeTransitGatewayVpcAttachments struct { +type awsEc2query_serializeOpDescribeTransitGatewayRouteTableAnnouncements struct { } -func (*awsEc2query_serializeOpDescribeTransitGatewayVpcAttachments) ID() string { +func (*awsEc2query_serializeOpDescribeTransitGatewayRouteTableAnnouncements) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpDescribeTransitGatewayVpcAttachments) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDescribeTransitGatewayRouteTableAnnouncements) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -29017,7 +29297,7 @@ func (m *awsEc2query_serializeOpDescribeTransitGatewayVpcAttachments) HandleSeri return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DescribeTransitGatewayVpcAttachmentsInput) + input, ok := in.Parameters.(*DescribeTransitGatewayRouteTableAnnouncementsInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -29042,10 +29322,10 @@ func (m *awsEc2query_serializeOpDescribeTransitGatewayVpcAttachments) HandleSeri bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("DescribeTransitGatewayVpcAttachments") + body.Key("Action").String("DescribeTransitGatewayRouteTableAnnouncements") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentDescribeTransitGatewayVpcAttachmentsInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentDescribeTransitGatewayRouteTableAnnouncementsInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -29068,14 +29348,14 @@ func (m *awsEc2query_serializeOpDescribeTransitGatewayVpcAttachments) HandleSeri return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpDescribeTrunkInterfaceAssociations struct { +type awsEc2query_serializeOpDescribeTransitGatewayRouteTables struct { } -func (*awsEc2query_serializeOpDescribeTrunkInterfaceAssociations) ID() string { +func (*awsEc2query_serializeOpDescribeTransitGatewayRouteTables) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpDescribeTrunkInterfaceAssociations) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDescribeTransitGatewayRouteTables) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -29087,7 +29367,7 @@ func (m *awsEc2query_serializeOpDescribeTrunkInterfaceAssociations) HandleSerial return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DescribeTrunkInterfaceAssociationsInput) + input, ok := in.Parameters.(*DescribeTransitGatewayRouteTablesInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -29112,10 +29392,10 @@ func (m *awsEc2query_serializeOpDescribeTrunkInterfaceAssociations) HandleSerial bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("DescribeTrunkInterfaceAssociations") + body.Key("Action").String("DescribeTransitGatewayRouteTables") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentDescribeTrunkInterfaceAssociationsInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentDescribeTransitGatewayRouteTablesInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -29138,14 +29418,14 @@ func (m *awsEc2query_serializeOpDescribeTrunkInterfaceAssociations) HandleSerial return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpDescribeVerifiedAccessEndpoints struct { +type awsEc2query_serializeOpDescribeTransitGateways struct { } -func (*awsEc2query_serializeOpDescribeVerifiedAccessEndpoints) ID() string { +func (*awsEc2query_serializeOpDescribeTransitGateways) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpDescribeVerifiedAccessEndpoints) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDescribeTransitGateways) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -29157,7 +29437,7 @@ func (m *awsEc2query_serializeOpDescribeVerifiedAccessEndpoints) HandleSerialize return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DescribeVerifiedAccessEndpointsInput) + input, ok := in.Parameters.(*DescribeTransitGatewaysInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -29182,10 +29462,10 @@ func (m *awsEc2query_serializeOpDescribeVerifiedAccessEndpoints) HandleSerialize bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("DescribeVerifiedAccessEndpoints") + body.Key("Action").String("DescribeTransitGateways") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentDescribeVerifiedAccessEndpointsInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentDescribeTransitGatewaysInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -29208,14 +29488,14 @@ func (m *awsEc2query_serializeOpDescribeVerifiedAccessEndpoints) HandleSerialize return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpDescribeVerifiedAccessGroups struct { +type awsEc2query_serializeOpDescribeTransitGatewayVpcAttachments struct { } -func (*awsEc2query_serializeOpDescribeVerifiedAccessGroups) ID() string { +func (*awsEc2query_serializeOpDescribeTransitGatewayVpcAttachments) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpDescribeVerifiedAccessGroups) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDescribeTransitGatewayVpcAttachments) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -29227,7 +29507,7 @@ func (m *awsEc2query_serializeOpDescribeVerifiedAccessGroups) HandleSerialize(ct return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DescribeVerifiedAccessGroupsInput) + input, ok := in.Parameters.(*DescribeTransitGatewayVpcAttachmentsInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -29252,10 +29532,10 @@ func (m *awsEc2query_serializeOpDescribeVerifiedAccessGroups) HandleSerialize(ct bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("DescribeVerifiedAccessGroups") + body.Key("Action").String("DescribeTransitGatewayVpcAttachments") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentDescribeVerifiedAccessGroupsInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentDescribeTransitGatewayVpcAttachmentsInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -29278,14 +29558,14 @@ func (m *awsEc2query_serializeOpDescribeVerifiedAccessGroups) HandleSerialize(ct return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpDescribeVerifiedAccessInstanceLoggingConfigurations struct { +type awsEc2query_serializeOpDescribeTrunkInterfaceAssociations struct { } -func (*awsEc2query_serializeOpDescribeVerifiedAccessInstanceLoggingConfigurations) ID() string { +func (*awsEc2query_serializeOpDescribeTrunkInterfaceAssociations) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpDescribeVerifiedAccessInstanceLoggingConfigurations) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDescribeTrunkInterfaceAssociations) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -29297,7 +29577,7 @@ func (m *awsEc2query_serializeOpDescribeVerifiedAccessInstanceLoggingConfigurati return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DescribeVerifiedAccessInstanceLoggingConfigurationsInput) + input, ok := in.Parameters.(*DescribeTrunkInterfaceAssociationsInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -29322,10 +29602,10 @@ func (m *awsEc2query_serializeOpDescribeVerifiedAccessInstanceLoggingConfigurati bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("DescribeVerifiedAccessInstanceLoggingConfigurations") + body.Key("Action").String("DescribeTrunkInterfaceAssociations") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentDescribeVerifiedAccessInstanceLoggingConfigurationsInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentDescribeTrunkInterfaceAssociationsInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -29348,14 +29628,14 @@ func (m *awsEc2query_serializeOpDescribeVerifiedAccessInstanceLoggingConfigurati return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpDescribeVerifiedAccessInstances struct { +type awsEc2query_serializeOpDescribeVerifiedAccessEndpoints struct { } -func (*awsEc2query_serializeOpDescribeVerifiedAccessInstances) ID() string { +func (*awsEc2query_serializeOpDescribeVerifiedAccessEndpoints) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpDescribeVerifiedAccessInstances) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDescribeVerifiedAccessEndpoints) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -29367,7 +29647,7 @@ func (m *awsEc2query_serializeOpDescribeVerifiedAccessInstances) HandleSerialize return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DescribeVerifiedAccessInstancesInput) + input, ok := in.Parameters.(*DescribeVerifiedAccessEndpointsInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -29392,10 +29672,10 @@ func (m *awsEc2query_serializeOpDescribeVerifiedAccessInstances) HandleSerialize bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("DescribeVerifiedAccessInstances") + body.Key("Action").String("DescribeVerifiedAccessEndpoints") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentDescribeVerifiedAccessInstancesInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentDescribeVerifiedAccessEndpointsInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -29418,14 +29698,14 @@ func (m *awsEc2query_serializeOpDescribeVerifiedAccessInstances) HandleSerialize return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpDescribeVerifiedAccessTrustProviders struct { +type awsEc2query_serializeOpDescribeVerifiedAccessGroups struct { } -func (*awsEc2query_serializeOpDescribeVerifiedAccessTrustProviders) ID() string { +func (*awsEc2query_serializeOpDescribeVerifiedAccessGroups) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpDescribeVerifiedAccessTrustProviders) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDescribeVerifiedAccessGroups) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -29437,7 +29717,7 @@ func (m *awsEc2query_serializeOpDescribeVerifiedAccessTrustProviders) HandleSeri return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DescribeVerifiedAccessTrustProvidersInput) + input, ok := in.Parameters.(*DescribeVerifiedAccessGroupsInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -29462,10 +29742,10 @@ func (m *awsEc2query_serializeOpDescribeVerifiedAccessTrustProviders) HandleSeri bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("DescribeVerifiedAccessTrustProviders") + body.Key("Action").String("DescribeVerifiedAccessGroups") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentDescribeVerifiedAccessTrustProvidersInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentDescribeVerifiedAccessGroupsInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -29488,14 +29768,14 @@ func (m *awsEc2query_serializeOpDescribeVerifiedAccessTrustProviders) HandleSeri return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpDescribeVolumeAttribute struct { +type awsEc2query_serializeOpDescribeVerifiedAccessInstanceLoggingConfigurations struct { } -func (*awsEc2query_serializeOpDescribeVolumeAttribute) ID() string { +func (*awsEc2query_serializeOpDescribeVerifiedAccessInstanceLoggingConfigurations) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpDescribeVolumeAttribute) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDescribeVerifiedAccessInstanceLoggingConfigurations) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -29507,7 +29787,7 @@ func (m *awsEc2query_serializeOpDescribeVolumeAttribute) HandleSerialize(ctx con return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DescribeVolumeAttributeInput) + input, ok := in.Parameters.(*DescribeVerifiedAccessInstanceLoggingConfigurationsInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -29532,10 +29812,10 @@ func (m *awsEc2query_serializeOpDescribeVolumeAttribute) HandleSerialize(ctx con bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("DescribeVolumeAttribute") + body.Key("Action").String("DescribeVerifiedAccessInstanceLoggingConfigurations") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentDescribeVolumeAttributeInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentDescribeVerifiedAccessInstanceLoggingConfigurationsInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -29558,14 +29838,14 @@ func (m *awsEc2query_serializeOpDescribeVolumeAttribute) HandleSerialize(ctx con return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpDescribeVolumes struct { +type awsEc2query_serializeOpDescribeVerifiedAccessInstances struct { } -func (*awsEc2query_serializeOpDescribeVolumes) ID() string { +func (*awsEc2query_serializeOpDescribeVerifiedAccessInstances) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpDescribeVolumes) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDescribeVerifiedAccessInstances) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -29577,7 +29857,7 @@ func (m *awsEc2query_serializeOpDescribeVolumes) HandleSerialize(ctx context.Con return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DescribeVolumesInput) + input, ok := in.Parameters.(*DescribeVerifiedAccessInstancesInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -29602,10 +29882,10 @@ func (m *awsEc2query_serializeOpDescribeVolumes) HandleSerialize(ctx context.Con bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("DescribeVolumes") + body.Key("Action").String("DescribeVerifiedAccessInstances") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentDescribeVolumesInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentDescribeVerifiedAccessInstancesInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -29628,14 +29908,14 @@ func (m *awsEc2query_serializeOpDescribeVolumes) HandleSerialize(ctx context.Con return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpDescribeVolumesModifications struct { +type awsEc2query_serializeOpDescribeVerifiedAccessTrustProviders struct { } -func (*awsEc2query_serializeOpDescribeVolumesModifications) ID() string { +func (*awsEc2query_serializeOpDescribeVerifiedAccessTrustProviders) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpDescribeVolumesModifications) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDescribeVerifiedAccessTrustProviders) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -29647,7 +29927,7 @@ func (m *awsEc2query_serializeOpDescribeVolumesModifications) HandleSerialize(ct return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DescribeVolumesModificationsInput) + input, ok := in.Parameters.(*DescribeVerifiedAccessTrustProvidersInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -29672,10 +29952,10 @@ func (m *awsEc2query_serializeOpDescribeVolumesModifications) HandleSerialize(ct bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("DescribeVolumesModifications") + body.Key("Action").String("DescribeVerifiedAccessTrustProviders") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentDescribeVolumesModificationsInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentDescribeVerifiedAccessTrustProvidersInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -29698,14 +29978,14 @@ func (m *awsEc2query_serializeOpDescribeVolumesModifications) HandleSerialize(ct return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpDescribeVolumeStatus struct { +type awsEc2query_serializeOpDescribeVolumeAttribute struct { } -func (*awsEc2query_serializeOpDescribeVolumeStatus) ID() string { +func (*awsEc2query_serializeOpDescribeVolumeAttribute) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpDescribeVolumeStatus) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDescribeVolumeAttribute) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -29717,7 +29997,7 @@ func (m *awsEc2query_serializeOpDescribeVolumeStatus) HandleSerialize(ctx contex return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DescribeVolumeStatusInput) + input, ok := in.Parameters.(*DescribeVolumeAttributeInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -29742,10 +30022,10 @@ func (m *awsEc2query_serializeOpDescribeVolumeStatus) HandleSerialize(ctx contex bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("DescribeVolumeStatus") + body.Key("Action").String("DescribeVolumeAttribute") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentDescribeVolumeStatusInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentDescribeVolumeAttributeInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -29768,14 +30048,14 @@ func (m *awsEc2query_serializeOpDescribeVolumeStatus) HandleSerialize(ctx contex return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpDescribeVpcAttribute struct { +type awsEc2query_serializeOpDescribeVolumes struct { } -func (*awsEc2query_serializeOpDescribeVpcAttribute) ID() string { +func (*awsEc2query_serializeOpDescribeVolumes) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpDescribeVpcAttribute) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDescribeVolumes) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -29787,7 +30067,7 @@ func (m *awsEc2query_serializeOpDescribeVpcAttribute) HandleSerialize(ctx contex return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DescribeVpcAttributeInput) + input, ok := in.Parameters.(*DescribeVolumesInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -29812,10 +30092,10 @@ func (m *awsEc2query_serializeOpDescribeVpcAttribute) HandleSerialize(ctx contex bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("DescribeVpcAttribute") + body.Key("Action").String("DescribeVolumes") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentDescribeVpcAttributeInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentDescribeVolumesInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -29838,14 +30118,14 @@ func (m *awsEc2query_serializeOpDescribeVpcAttribute) HandleSerialize(ctx contex return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpDescribeVpcBlockPublicAccessExclusions struct { +type awsEc2query_serializeOpDescribeVolumesModifications struct { } -func (*awsEc2query_serializeOpDescribeVpcBlockPublicAccessExclusions) ID() string { +func (*awsEc2query_serializeOpDescribeVolumesModifications) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpDescribeVpcBlockPublicAccessExclusions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDescribeVolumesModifications) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -29857,7 +30137,7 @@ func (m *awsEc2query_serializeOpDescribeVpcBlockPublicAccessExclusions) HandleSe return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DescribeVpcBlockPublicAccessExclusionsInput) + input, ok := in.Parameters.(*DescribeVolumesModificationsInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -29882,10 +30162,10 @@ func (m *awsEc2query_serializeOpDescribeVpcBlockPublicAccessExclusions) HandleSe bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("DescribeVpcBlockPublicAccessExclusions") + body.Key("Action").String("DescribeVolumesModifications") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentDescribeVpcBlockPublicAccessExclusionsInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentDescribeVolumesModificationsInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -29908,14 +30188,14 @@ func (m *awsEc2query_serializeOpDescribeVpcBlockPublicAccessExclusions) HandleSe return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpDescribeVpcBlockPublicAccessOptions struct { +type awsEc2query_serializeOpDescribeVolumeStatus struct { } -func (*awsEc2query_serializeOpDescribeVpcBlockPublicAccessOptions) ID() string { +func (*awsEc2query_serializeOpDescribeVolumeStatus) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpDescribeVpcBlockPublicAccessOptions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDescribeVolumeStatus) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -29927,7 +30207,7 @@ func (m *awsEc2query_serializeOpDescribeVpcBlockPublicAccessOptions) HandleSeria return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DescribeVpcBlockPublicAccessOptionsInput) + input, ok := in.Parameters.(*DescribeVolumeStatusInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -29952,10 +30232,10 @@ func (m *awsEc2query_serializeOpDescribeVpcBlockPublicAccessOptions) HandleSeria bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("DescribeVpcBlockPublicAccessOptions") + body.Key("Action").String("DescribeVolumeStatus") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentDescribeVpcBlockPublicAccessOptionsInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentDescribeVolumeStatusInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -29978,14 +30258,14 @@ func (m *awsEc2query_serializeOpDescribeVpcBlockPublicAccessOptions) HandleSeria return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpDescribeVpcClassicLink struct { +type awsEc2query_serializeOpDescribeVpcAttribute struct { } -func (*awsEc2query_serializeOpDescribeVpcClassicLink) ID() string { +func (*awsEc2query_serializeOpDescribeVpcAttribute) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpDescribeVpcClassicLink) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDescribeVpcAttribute) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -29997,7 +30277,7 @@ func (m *awsEc2query_serializeOpDescribeVpcClassicLink) HandleSerialize(ctx cont return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DescribeVpcClassicLinkInput) + input, ok := in.Parameters.(*DescribeVpcAttributeInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -30022,10 +30302,10 @@ func (m *awsEc2query_serializeOpDescribeVpcClassicLink) HandleSerialize(ctx cont bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("DescribeVpcClassicLink") + body.Key("Action").String("DescribeVpcAttribute") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentDescribeVpcClassicLinkInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentDescribeVpcAttributeInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -30048,14 +30328,14 @@ func (m *awsEc2query_serializeOpDescribeVpcClassicLink) HandleSerialize(ctx cont return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpDescribeVpcClassicLinkDnsSupport struct { +type awsEc2query_serializeOpDescribeVpcBlockPublicAccessExclusions struct { } -func (*awsEc2query_serializeOpDescribeVpcClassicLinkDnsSupport) ID() string { +func (*awsEc2query_serializeOpDescribeVpcBlockPublicAccessExclusions) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpDescribeVpcClassicLinkDnsSupport) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDescribeVpcBlockPublicAccessExclusions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -30067,7 +30347,7 @@ func (m *awsEc2query_serializeOpDescribeVpcClassicLinkDnsSupport) HandleSerializ return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DescribeVpcClassicLinkDnsSupportInput) + input, ok := in.Parameters.(*DescribeVpcBlockPublicAccessExclusionsInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -30092,10 +30372,10 @@ func (m *awsEc2query_serializeOpDescribeVpcClassicLinkDnsSupport) HandleSerializ bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("DescribeVpcClassicLinkDnsSupport") + body.Key("Action").String("DescribeVpcBlockPublicAccessExclusions") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentDescribeVpcClassicLinkDnsSupportInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentDescribeVpcBlockPublicAccessExclusionsInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -30118,14 +30398,14 @@ func (m *awsEc2query_serializeOpDescribeVpcClassicLinkDnsSupport) HandleSerializ return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpDescribeVpcEncryptionControls struct { +type awsEc2query_serializeOpDescribeVpcBlockPublicAccessOptions struct { } -func (*awsEc2query_serializeOpDescribeVpcEncryptionControls) ID() string { +func (*awsEc2query_serializeOpDescribeVpcBlockPublicAccessOptions) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpDescribeVpcEncryptionControls) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDescribeVpcBlockPublicAccessOptions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -30137,7 +30417,7 @@ func (m *awsEc2query_serializeOpDescribeVpcEncryptionControls) HandleSerialize(c return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DescribeVpcEncryptionControlsInput) + input, ok := in.Parameters.(*DescribeVpcBlockPublicAccessOptionsInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -30162,10 +30442,10 @@ func (m *awsEc2query_serializeOpDescribeVpcEncryptionControls) HandleSerialize(c bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("DescribeVpcEncryptionControls") + body.Key("Action").String("DescribeVpcBlockPublicAccessOptions") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentDescribeVpcEncryptionControlsInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentDescribeVpcBlockPublicAccessOptionsInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -30188,14 +30468,14 @@ func (m *awsEc2query_serializeOpDescribeVpcEncryptionControls) HandleSerialize(c return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpDescribeVpcEndpointAssociations struct { +type awsEc2query_serializeOpDescribeVpcClassicLink struct { } -func (*awsEc2query_serializeOpDescribeVpcEndpointAssociations) ID() string { +func (*awsEc2query_serializeOpDescribeVpcClassicLink) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpDescribeVpcEndpointAssociations) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDescribeVpcClassicLink) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -30207,7 +30487,7 @@ func (m *awsEc2query_serializeOpDescribeVpcEndpointAssociations) HandleSerialize return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DescribeVpcEndpointAssociationsInput) + input, ok := in.Parameters.(*DescribeVpcClassicLinkInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -30232,10 +30512,10 @@ func (m *awsEc2query_serializeOpDescribeVpcEndpointAssociations) HandleSerialize bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("DescribeVpcEndpointAssociations") + body.Key("Action").String("DescribeVpcClassicLink") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentDescribeVpcEndpointAssociationsInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentDescribeVpcClassicLinkInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -30258,14 +30538,14 @@ func (m *awsEc2query_serializeOpDescribeVpcEndpointAssociations) HandleSerialize return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpDescribeVpcEndpointConnectionNotifications struct { +type awsEc2query_serializeOpDescribeVpcClassicLinkDnsSupport struct { } -func (*awsEc2query_serializeOpDescribeVpcEndpointConnectionNotifications) ID() string { +func (*awsEc2query_serializeOpDescribeVpcClassicLinkDnsSupport) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpDescribeVpcEndpointConnectionNotifications) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDescribeVpcClassicLinkDnsSupport) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -30277,7 +30557,7 @@ func (m *awsEc2query_serializeOpDescribeVpcEndpointConnectionNotifications) Hand return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DescribeVpcEndpointConnectionNotificationsInput) + input, ok := in.Parameters.(*DescribeVpcClassicLinkDnsSupportInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -30302,10 +30582,10 @@ func (m *awsEc2query_serializeOpDescribeVpcEndpointConnectionNotifications) Hand bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("DescribeVpcEndpointConnectionNotifications") + body.Key("Action").String("DescribeVpcClassicLinkDnsSupport") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentDescribeVpcEndpointConnectionNotificationsInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentDescribeVpcClassicLinkDnsSupportInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -30328,14 +30608,14 @@ func (m *awsEc2query_serializeOpDescribeVpcEndpointConnectionNotifications) Hand return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpDescribeVpcEndpointConnections struct { +type awsEc2query_serializeOpDescribeVpcEncryptionControls struct { } -func (*awsEc2query_serializeOpDescribeVpcEndpointConnections) ID() string { +func (*awsEc2query_serializeOpDescribeVpcEncryptionControls) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpDescribeVpcEndpointConnections) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDescribeVpcEncryptionControls) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -30347,7 +30627,7 @@ func (m *awsEc2query_serializeOpDescribeVpcEndpointConnections) HandleSerialize( return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DescribeVpcEndpointConnectionsInput) + input, ok := in.Parameters.(*DescribeVpcEncryptionControlsInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -30372,10 +30652,10 @@ func (m *awsEc2query_serializeOpDescribeVpcEndpointConnections) HandleSerialize( bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("DescribeVpcEndpointConnections") + body.Key("Action").String("DescribeVpcEncryptionControls") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentDescribeVpcEndpointConnectionsInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentDescribeVpcEncryptionControlsInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -30398,14 +30678,14 @@ func (m *awsEc2query_serializeOpDescribeVpcEndpointConnections) HandleSerialize( return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpDescribeVpcEndpoints struct { +type awsEc2query_serializeOpDescribeVpcEndpointAssociations struct { } -func (*awsEc2query_serializeOpDescribeVpcEndpoints) ID() string { +func (*awsEc2query_serializeOpDescribeVpcEndpointAssociations) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpDescribeVpcEndpoints) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDescribeVpcEndpointAssociations) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -30417,7 +30697,7 @@ func (m *awsEc2query_serializeOpDescribeVpcEndpoints) HandleSerialize(ctx contex return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DescribeVpcEndpointsInput) + input, ok := in.Parameters.(*DescribeVpcEndpointAssociationsInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -30442,10 +30722,10 @@ func (m *awsEc2query_serializeOpDescribeVpcEndpoints) HandleSerialize(ctx contex bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("DescribeVpcEndpoints") + body.Key("Action").String("DescribeVpcEndpointAssociations") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentDescribeVpcEndpointsInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentDescribeVpcEndpointAssociationsInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -30468,14 +30748,14 @@ func (m *awsEc2query_serializeOpDescribeVpcEndpoints) HandleSerialize(ctx contex return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpDescribeVpcEndpointServiceConfigurations struct { +type awsEc2query_serializeOpDescribeVpcEndpointConnectionNotifications struct { } -func (*awsEc2query_serializeOpDescribeVpcEndpointServiceConfigurations) ID() string { +func (*awsEc2query_serializeOpDescribeVpcEndpointConnectionNotifications) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpDescribeVpcEndpointServiceConfigurations) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDescribeVpcEndpointConnectionNotifications) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -30487,7 +30767,7 @@ func (m *awsEc2query_serializeOpDescribeVpcEndpointServiceConfigurations) Handle return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DescribeVpcEndpointServiceConfigurationsInput) + input, ok := in.Parameters.(*DescribeVpcEndpointConnectionNotificationsInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -30512,10 +30792,10 @@ func (m *awsEc2query_serializeOpDescribeVpcEndpointServiceConfigurations) Handle bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("DescribeVpcEndpointServiceConfigurations") + body.Key("Action").String("DescribeVpcEndpointConnectionNotifications") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentDescribeVpcEndpointServiceConfigurationsInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentDescribeVpcEndpointConnectionNotificationsInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -30538,14 +30818,14 @@ func (m *awsEc2query_serializeOpDescribeVpcEndpointServiceConfigurations) Handle return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpDescribeVpcEndpointServicePermissions struct { +type awsEc2query_serializeOpDescribeVpcEndpointConnections struct { } -func (*awsEc2query_serializeOpDescribeVpcEndpointServicePermissions) ID() string { +func (*awsEc2query_serializeOpDescribeVpcEndpointConnections) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpDescribeVpcEndpointServicePermissions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDescribeVpcEndpointConnections) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -30557,7 +30837,7 @@ func (m *awsEc2query_serializeOpDescribeVpcEndpointServicePermissions) HandleSer return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DescribeVpcEndpointServicePermissionsInput) + input, ok := in.Parameters.(*DescribeVpcEndpointConnectionsInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -30582,10 +30862,10 @@ func (m *awsEc2query_serializeOpDescribeVpcEndpointServicePermissions) HandleSer bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("DescribeVpcEndpointServicePermissions") + body.Key("Action").String("DescribeVpcEndpointConnections") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentDescribeVpcEndpointServicePermissionsInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentDescribeVpcEndpointConnectionsInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -30608,14 +30888,14 @@ func (m *awsEc2query_serializeOpDescribeVpcEndpointServicePermissions) HandleSer return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpDescribeVpcEndpointServices struct { +type awsEc2query_serializeOpDescribeVpcEndpoints struct { } -func (*awsEc2query_serializeOpDescribeVpcEndpointServices) ID() string { +func (*awsEc2query_serializeOpDescribeVpcEndpoints) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpDescribeVpcEndpointServices) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDescribeVpcEndpoints) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -30627,7 +30907,7 @@ func (m *awsEc2query_serializeOpDescribeVpcEndpointServices) HandleSerialize(ctx return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DescribeVpcEndpointServicesInput) + input, ok := in.Parameters.(*DescribeVpcEndpointsInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -30652,10 +30932,10 @@ func (m *awsEc2query_serializeOpDescribeVpcEndpointServices) HandleSerialize(ctx bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("DescribeVpcEndpointServices") + body.Key("Action").String("DescribeVpcEndpoints") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentDescribeVpcEndpointServicesInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentDescribeVpcEndpointsInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -30678,14 +30958,14 @@ func (m *awsEc2query_serializeOpDescribeVpcEndpointServices) HandleSerialize(ctx return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpDescribeVpcPeeringConnections struct { +type awsEc2query_serializeOpDescribeVpcEndpointServiceConfigurations struct { } -func (*awsEc2query_serializeOpDescribeVpcPeeringConnections) ID() string { +func (*awsEc2query_serializeOpDescribeVpcEndpointServiceConfigurations) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpDescribeVpcPeeringConnections) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDescribeVpcEndpointServiceConfigurations) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -30697,7 +30977,7 @@ func (m *awsEc2query_serializeOpDescribeVpcPeeringConnections) HandleSerialize(c return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DescribeVpcPeeringConnectionsInput) + input, ok := in.Parameters.(*DescribeVpcEndpointServiceConfigurationsInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -30722,10 +31002,10 @@ func (m *awsEc2query_serializeOpDescribeVpcPeeringConnections) HandleSerialize(c bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("DescribeVpcPeeringConnections") + body.Key("Action").String("DescribeVpcEndpointServiceConfigurations") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentDescribeVpcPeeringConnectionsInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentDescribeVpcEndpointServiceConfigurationsInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -30748,14 +31028,14 @@ func (m *awsEc2query_serializeOpDescribeVpcPeeringConnections) HandleSerialize(c return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpDescribeVpcs struct { +type awsEc2query_serializeOpDescribeVpcEndpointServicePermissions struct { } -func (*awsEc2query_serializeOpDescribeVpcs) ID() string { +func (*awsEc2query_serializeOpDescribeVpcEndpointServicePermissions) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpDescribeVpcs) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDescribeVpcEndpointServicePermissions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -30767,7 +31047,7 @@ func (m *awsEc2query_serializeOpDescribeVpcs) HandleSerialize(ctx context.Contex return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DescribeVpcsInput) + input, ok := in.Parameters.(*DescribeVpcEndpointServicePermissionsInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -30792,10 +31072,10 @@ func (m *awsEc2query_serializeOpDescribeVpcs) HandleSerialize(ctx context.Contex bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("DescribeVpcs") + body.Key("Action").String("DescribeVpcEndpointServicePermissions") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentDescribeVpcsInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentDescribeVpcEndpointServicePermissionsInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -30818,14 +31098,14 @@ func (m *awsEc2query_serializeOpDescribeVpcs) HandleSerialize(ctx context.Contex return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpDescribeVpnConcentrators struct { +type awsEc2query_serializeOpDescribeVpcEndpointServices struct { } -func (*awsEc2query_serializeOpDescribeVpnConcentrators) ID() string { +func (*awsEc2query_serializeOpDescribeVpcEndpointServices) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpDescribeVpnConcentrators) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDescribeVpcEndpointServices) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -30837,7 +31117,7 @@ func (m *awsEc2query_serializeOpDescribeVpnConcentrators) HandleSerialize(ctx co return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DescribeVpnConcentratorsInput) + input, ok := in.Parameters.(*DescribeVpcEndpointServicesInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -30862,10 +31142,10 @@ func (m *awsEc2query_serializeOpDescribeVpnConcentrators) HandleSerialize(ctx co bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("DescribeVpnConcentrators") + body.Key("Action").String("DescribeVpcEndpointServices") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentDescribeVpnConcentratorsInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentDescribeVpcEndpointServicesInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -30888,14 +31168,14 @@ func (m *awsEc2query_serializeOpDescribeVpnConcentrators) HandleSerialize(ctx co return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpDescribeVpnConnections struct { +type awsEc2query_serializeOpDescribeVpcPeeringConnections struct { } -func (*awsEc2query_serializeOpDescribeVpnConnections) ID() string { +func (*awsEc2query_serializeOpDescribeVpcPeeringConnections) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpDescribeVpnConnections) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDescribeVpcPeeringConnections) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -30907,7 +31187,7 @@ func (m *awsEc2query_serializeOpDescribeVpnConnections) HandleSerialize(ctx cont return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DescribeVpnConnectionsInput) + input, ok := in.Parameters.(*DescribeVpcPeeringConnectionsInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -30932,10 +31212,10 @@ func (m *awsEc2query_serializeOpDescribeVpnConnections) HandleSerialize(ctx cont bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("DescribeVpnConnections") + body.Key("Action").String("DescribeVpcPeeringConnections") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentDescribeVpnConnectionsInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentDescribeVpcPeeringConnectionsInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -30958,14 +31238,14 @@ func (m *awsEc2query_serializeOpDescribeVpnConnections) HandleSerialize(ctx cont return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpDescribeVpnGateways struct { +type awsEc2query_serializeOpDescribeVpcs struct { } -func (*awsEc2query_serializeOpDescribeVpnGateways) ID() string { +func (*awsEc2query_serializeOpDescribeVpcs) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpDescribeVpnGateways) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDescribeVpcs) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -30977,7 +31257,7 @@ func (m *awsEc2query_serializeOpDescribeVpnGateways) HandleSerialize(ctx context return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DescribeVpnGatewaysInput) + input, ok := in.Parameters.(*DescribeVpcsInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -31002,10 +31282,10 @@ func (m *awsEc2query_serializeOpDescribeVpnGateways) HandleSerialize(ctx context bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("DescribeVpnGateways") + body.Key("Action").String("DescribeVpcs") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentDescribeVpnGatewaysInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentDescribeVpcsInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -31028,14 +31308,14 @@ func (m *awsEc2query_serializeOpDescribeVpnGateways) HandleSerialize(ctx context return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpDetachClassicLinkVpc struct { +type awsEc2query_serializeOpDescribeVpnConcentrators struct { } -func (*awsEc2query_serializeOpDetachClassicLinkVpc) ID() string { +func (*awsEc2query_serializeOpDescribeVpnConcentrators) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpDetachClassicLinkVpc) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDescribeVpnConcentrators) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -31047,7 +31327,7 @@ func (m *awsEc2query_serializeOpDetachClassicLinkVpc) HandleSerialize(ctx contex return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DetachClassicLinkVpcInput) + input, ok := in.Parameters.(*DescribeVpnConcentratorsInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -31072,10 +31352,10 @@ func (m *awsEc2query_serializeOpDetachClassicLinkVpc) HandleSerialize(ctx contex bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("DetachClassicLinkVpc") + body.Key("Action").String("DescribeVpnConcentrators") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentDetachClassicLinkVpcInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentDescribeVpnConcentratorsInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -31098,14 +31378,14 @@ func (m *awsEc2query_serializeOpDetachClassicLinkVpc) HandleSerialize(ctx contex return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpDetachInternetGateway struct { +type awsEc2query_serializeOpDescribeVpnConnections struct { } -func (*awsEc2query_serializeOpDetachInternetGateway) ID() string { +func (*awsEc2query_serializeOpDescribeVpnConnections) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpDetachInternetGateway) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDescribeVpnConnections) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -31117,7 +31397,7 @@ func (m *awsEc2query_serializeOpDetachInternetGateway) HandleSerialize(ctx conte return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DetachInternetGatewayInput) + input, ok := in.Parameters.(*DescribeVpnConnectionsInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -31142,10 +31422,10 @@ func (m *awsEc2query_serializeOpDetachInternetGateway) HandleSerialize(ctx conte bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("DetachInternetGateway") + body.Key("Action").String("DescribeVpnConnections") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentDetachInternetGatewayInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentDescribeVpnConnectionsInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -31168,14 +31448,14 @@ func (m *awsEc2query_serializeOpDetachInternetGateway) HandleSerialize(ctx conte return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpDetachNetworkInterface struct { +type awsEc2query_serializeOpDescribeVpnGateways struct { } -func (*awsEc2query_serializeOpDetachNetworkInterface) ID() string { +func (*awsEc2query_serializeOpDescribeVpnGateways) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpDetachNetworkInterface) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDescribeVpnGateways) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -31187,7 +31467,7 @@ func (m *awsEc2query_serializeOpDetachNetworkInterface) HandleSerialize(ctx cont return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DetachNetworkInterfaceInput) + input, ok := in.Parameters.(*DescribeVpnGatewaysInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -31212,10 +31492,10 @@ func (m *awsEc2query_serializeOpDetachNetworkInterface) HandleSerialize(ctx cont bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("DetachNetworkInterface") + body.Key("Action").String("DescribeVpnGateways") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentDetachNetworkInterfaceInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentDescribeVpnGatewaysInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -31238,14 +31518,14 @@ func (m *awsEc2query_serializeOpDetachNetworkInterface) HandleSerialize(ctx cont return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpDetachVerifiedAccessTrustProvider struct { +type awsEc2query_serializeOpDetachClassicLinkVpc struct { } -func (*awsEc2query_serializeOpDetachVerifiedAccessTrustProvider) ID() string { +func (*awsEc2query_serializeOpDetachClassicLinkVpc) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpDetachVerifiedAccessTrustProvider) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDetachClassicLinkVpc) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -31257,7 +31537,7 @@ func (m *awsEc2query_serializeOpDetachVerifiedAccessTrustProvider) HandleSeriali return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DetachVerifiedAccessTrustProviderInput) + input, ok := in.Parameters.(*DetachClassicLinkVpcInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -31282,10 +31562,10 @@ func (m *awsEc2query_serializeOpDetachVerifiedAccessTrustProvider) HandleSeriali bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("DetachVerifiedAccessTrustProvider") + body.Key("Action").String("DetachClassicLinkVpc") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentDetachVerifiedAccessTrustProviderInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentDetachClassicLinkVpcInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -31308,14 +31588,14 @@ func (m *awsEc2query_serializeOpDetachVerifiedAccessTrustProvider) HandleSeriali return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpDetachVolume struct { +type awsEc2query_serializeOpDetachInternetGateway struct { } -func (*awsEc2query_serializeOpDetachVolume) ID() string { +func (*awsEc2query_serializeOpDetachInternetGateway) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpDetachVolume) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDetachInternetGateway) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -31327,7 +31607,7 @@ func (m *awsEc2query_serializeOpDetachVolume) HandleSerialize(ctx context.Contex return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DetachVolumeInput) + input, ok := in.Parameters.(*DetachInternetGatewayInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -31352,10 +31632,10 @@ func (m *awsEc2query_serializeOpDetachVolume) HandleSerialize(ctx context.Contex bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("DetachVolume") + body.Key("Action").String("DetachInternetGateway") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentDetachVolumeInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentDetachInternetGatewayInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -31378,14 +31658,14 @@ func (m *awsEc2query_serializeOpDetachVolume) HandleSerialize(ctx context.Contex return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpDetachVpnGateway struct { +type awsEc2query_serializeOpDetachNetworkInterface struct { } -func (*awsEc2query_serializeOpDetachVpnGateway) ID() string { +func (*awsEc2query_serializeOpDetachNetworkInterface) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpDetachVpnGateway) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDetachNetworkInterface) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -31397,7 +31677,7 @@ func (m *awsEc2query_serializeOpDetachVpnGateway) HandleSerialize(ctx context.Co return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DetachVpnGatewayInput) + input, ok := in.Parameters.(*DetachNetworkInterfaceInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -31422,10 +31702,10 @@ func (m *awsEc2query_serializeOpDetachVpnGateway) HandleSerialize(ctx context.Co bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("DetachVpnGateway") + body.Key("Action").String("DetachNetworkInterface") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentDetachVpnGatewayInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentDetachNetworkInterfaceInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -31448,14 +31728,14 @@ func (m *awsEc2query_serializeOpDetachVpnGateway) HandleSerialize(ctx context.Co return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpDisableAddressTransfer struct { +type awsEc2query_serializeOpDetachVerifiedAccessTrustProvider struct { } -func (*awsEc2query_serializeOpDisableAddressTransfer) ID() string { +func (*awsEc2query_serializeOpDetachVerifiedAccessTrustProvider) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpDisableAddressTransfer) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDetachVerifiedAccessTrustProvider) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -31467,7 +31747,7 @@ func (m *awsEc2query_serializeOpDisableAddressTransfer) HandleSerialize(ctx cont return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DisableAddressTransferInput) + input, ok := in.Parameters.(*DetachVerifiedAccessTrustProviderInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -31492,10 +31772,10 @@ func (m *awsEc2query_serializeOpDisableAddressTransfer) HandleSerialize(ctx cont bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("DisableAddressTransfer") + body.Key("Action").String("DetachVerifiedAccessTrustProvider") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentDisableAddressTransferInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentDetachVerifiedAccessTrustProviderInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -31518,14 +31798,14 @@ func (m *awsEc2query_serializeOpDisableAddressTransfer) HandleSerialize(ctx cont return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpDisableAllowedImagesSettings struct { +type awsEc2query_serializeOpDetachVolume struct { } -func (*awsEc2query_serializeOpDisableAllowedImagesSettings) ID() string { +func (*awsEc2query_serializeOpDetachVolume) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpDisableAllowedImagesSettings) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDetachVolume) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -31537,7 +31817,7 @@ func (m *awsEc2query_serializeOpDisableAllowedImagesSettings) HandleSerialize(ct return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DisableAllowedImagesSettingsInput) + input, ok := in.Parameters.(*DetachVolumeInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -31562,10 +31842,10 @@ func (m *awsEc2query_serializeOpDisableAllowedImagesSettings) HandleSerialize(ct bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("DisableAllowedImagesSettings") + body.Key("Action").String("DetachVolume") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentDisableAllowedImagesSettingsInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentDetachVolumeInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -31588,14 +31868,14 @@ func (m *awsEc2query_serializeOpDisableAllowedImagesSettings) HandleSerialize(ct return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpDisableAwsNetworkPerformanceMetricSubscription struct { +type awsEc2query_serializeOpDetachVpnGateway struct { } -func (*awsEc2query_serializeOpDisableAwsNetworkPerformanceMetricSubscription) ID() string { +func (*awsEc2query_serializeOpDetachVpnGateway) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpDisableAwsNetworkPerformanceMetricSubscription) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDetachVpnGateway) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -31607,7 +31887,7 @@ func (m *awsEc2query_serializeOpDisableAwsNetworkPerformanceMetricSubscription) return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DisableAwsNetworkPerformanceMetricSubscriptionInput) + input, ok := in.Parameters.(*DetachVpnGatewayInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -31632,10 +31912,10 @@ func (m *awsEc2query_serializeOpDisableAwsNetworkPerformanceMetricSubscription) bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("DisableAwsNetworkPerformanceMetricSubscription") + body.Key("Action").String("DetachVpnGateway") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentDisableAwsNetworkPerformanceMetricSubscriptionInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentDetachVpnGatewayInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -31658,14 +31938,14 @@ func (m *awsEc2query_serializeOpDisableAwsNetworkPerformanceMetricSubscription) return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpDisableCapacityManager struct { +type awsEc2query_serializeOpDisableAddressTransfer struct { } -func (*awsEc2query_serializeOpDisableCapacityManager) ID() string { +func (*awsEc2query_serializeOpDisableAddressTransfer) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpDisableCapacityManager) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDisableAddressTransfer) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -31677,7 +31957,7 @@ func (m *awsEc2query_serializeOpDisableCapacityManager) HandleSerialize(ctx cont return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DisableCapacityManagerInput) + input, ok := in.Parameters.(*DisableAddressTransferInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -31702,10 +31982,10 @@ func (m *awsEc2query_serializeOpDisableCapacityManager) HandleSerialize(ctx cont bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("DisableCapacityManager") + body.Key("Action").String("DisableAddressTransfer") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentDisableCapacityManagerInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentDisableAddressTransferInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -31728,14 +32008,14 @@ func (m *awsEc2query_serializeOpDisableCapacityManager) HandleSerialize(ctx cont return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpDisableEbsEncryptionByDefault struct { +type awsEc2query_serializeOpDisableAllowedImagesSettings struct { } -func (*awsEc2query_serializeOpDisableEbsEncryptionByDefault) ID() string { +func (*awsEc2query_serializeOpDisableAllowedImagesSettings) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpDisableEbsEncryptionByDefault) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDisableAllowedImagesSettings) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -31747,7 +32027,7 @@ func (m *awsEc2query_serializeOpDisableEbsEncryptionByDefault) HandleSerialize(c return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DisableEbsEncryptionByDefaultInput) + input, ok := in.Parameters.(*DisableAllowedImagesSettingsInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -31772,10 +32052,10 @@ func (m *awsEc2query_serializeOpDisableEbsEncryptionByDefault) HandleSerialize(c bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("DisableEbsEncryptionByDefault") + body.Key("Action").String("DisableAllowedImagesSettings") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentDisableEbsEncryptionByDefaultInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentDisableAllowedImagesSettingsInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -31798,14 +32078,14 @@ func (m *awsEc2query_serializeOpDisableEbsEncryptionByDefault) HandleSerialize(c return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpDisableFastLaunch struct { +type awsEc2query_serializeOpDisableAwsNetworkPerformanceMetricSubscription struct { } -func (*awsEc2query_serializeOpDisableFastLaunch) ID() string { +func (*awsEc2query_serializeOpDisableAwsNetworkPerformanceMetricSubscription) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpDisableFastLaunch) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDisableAwsNetworkPerformanceMetricSubscription) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -31817,7 +32097,7 @@ func (m *awsEc2query_serializeOpDisableFastLaunch) HandleSerialize(ctx context.C return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DisableFastLaunchInput) + input, ok := in.Parameters.(*DisableAwsNetworkPerformanceMetricSubscriptionInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -31842,10 +32122,10 @@ func (m *awsEc2query_serializeOpDisableFastLaunch) HandleSerialize(ctx context.C bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("DisableFastLaunch") + body.Key("Action").String("DisableAwsNetworkPerformanceMetricSubscription") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentDisableFastLaunchInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentDisableAwsNetworkPerformanceMetricSubscriptionInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -31868,14 +32148,14 @@ func (m *awsEc2query_serializeOpDisableFastLaunch) HandleSerialize(ctx context.C return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpDisableFastSnapshotRestores struct { +type awsEc2query_serializeOpDisableCapacityManager struct { } -func (*awsEc2query_serializeOpDisableFastSnapshotRestores) ID() string { +func (*awsEc2query_serializeOpDisableCapacityManager) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpDisableFastSnapshotRestores) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDisableCapacityManager) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -31887,7 +32167,7 @@ func (m *awsEc2query_serializeOpDisableFastSnapshotRestores) HandleSerialize(ctx return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DisableFastSnapshotRestoresInput) + input, ok := in.Parameters.(*DisableCapacityManagerInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -31912,10 +32192,10 @@ func (m *awsEc2query_serializeOpDisableFastSnapshotRestores) HandleSerialize(ctx bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("DisableFastSnapshotRestores") + body.Key("Action").String("DisableCapacityManager") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentDisableFastSnapshotRestoresInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentDisableCapacityManagerInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -31938,14 +32218,14 @@ func (m *awsEc2query_serializeOpDisableFastSnapshotRestores) HandleSerialize(ctx return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpDisableImage struct { +type awsEc2query_serializeOpDisableEbsEncryptionByDefault struct { } -func (*awsEc2query_serializeOpDisableImage) ID() string { +func (*awsEc2query_serializeOpDisableEbsEncryptionByDefault) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpDisableImage) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDisableEbsEncryptionByDefault) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -31957,7 +32237,7 @@ func (m *awsEc2query_serializeOpDisableImage) HandleSerialize(ctx context.Contex return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DisableImageInput) + input, ok := in.Parameters.(*DisableEbsEncryptionByDefaultInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -31982,10 +32262,10 @@ func (m *awsEc2query_serializeOpDisableImage) HandleSerialize(ctx context.Contex bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("DisableImage") + body.Key("Action").String("DisableEbsEncryptionByDefault") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentDisableImageInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentDisableEbsEncryptionByDefaultInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -32008,14 +32288,14 @@ func (m *awsEc2query_serializeOpDisableImage) HandleSerialize(ctx context.Contex return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpDisableImageBlockPublicAccess struct { +type awsEc2query_serializeOpDisableFastLaunch struct { } -func (*awsEc2query_serializeOpDisableImageBlockPublicAccess) ID() string { +func (*awsEc2query_serializeOpDisableFastLaunch) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpDisableImageBlockPublicAccess) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDisableFastLaunch) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -32027,7 +32307,7 @@ func (m *awsEc2query_serializeOpDisableImageBlockPublicAccess) HandleSerialize(c return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DisableImageBlockPublicAccessInput) + input, ok := in.Parameters.(*DisableFastLaunchInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -32052,10 +32332,10 @@ func (m *awsEc2query_serializeOpDisableImageBlockPublicAccess) HandleSerialize(c bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("DisableImageBlockPublicAccess") + body.Key("Action").String("DisableFastLaunch") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentDisableImageBlockPublicAccessInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentDisableFastLaunchInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -32078,14 +32358,14 @@ func (m *awsEc2query_serializeOpDisableImageBlockPublicAccess) HandleSerialize(c return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpDisableImageDeprecation struct { +type awsEc2query_serializeOpDisableFastSnapshotRestores struct { } -func (*awsEc2query_serializeOpDisableImageDeprecation) ID() string { +func (*awsEc2query_serializeOpDisableFastSnapshotRestores) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpDisableImageDeprecation) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDisableFastSnapshotRestores) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -32097,7 +32377,7 @@ func (m *awsEc2query_serializeOpDisableImageDeprecation) HandleSerialize(ctx con return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DisableImageDeprecationInput) + input, ok := in.Parameters.(*DisableFastSnapshotRestoresInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -32122,10 +32402,10 @@ func (m *awsEc2query_serializeOpDisableImageDeprecation) HandleSerialize(ctx con bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("DisableImageDeprecation") + body.Key("Action").String("DisableFastSnapshotRestores") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentDisableImageDeprecationInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentDisableFastSnapshotRestoresInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -32148,14 +32428,14 @@ func (m *awsEc2query_serializeOpDisableImageDeprecation) HandleSerialize(ctx con return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpDisableImageDeregistrationProtection struct { +type awsEc2query_serializeOpDisableImage struct { } -func (*awsEc2query_serializeOpDisableImageDeregistrationProtection) ID() string { +func (*awsEc2query_serializeOpDisableImage) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpDisableImageDeregistrationProtection) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDisableImage) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -32167,7 +32447,7 @@ func (m *awsEc2query_serializeOpDisableImageDeregistrationProtection) HandleSeri return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DisableImageDeregistrationProtectionInput) + input, ok := in.Parameters.(*DisableImageInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -32192,10 +32472,10 @@ func (m *awsEc2query_serializeOpDisableImageDeregistrationProtection) HandleSeri bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("DisableImageDeregistrationProtection") + body.Key("Action").String("DisableImage") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentDisableImageDeregistrationProtectionInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentDisableImageInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -32218,14 +32498,14 @@ func (m *awsEc2query_serializeOpDisableImageDeregistrationProtection) HandleSeri return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpDisableInstanceSqlHaStandbyDetections struct { +type awsEc2query_serializeOpDisableImageBlockPublicAccess struct { } -func (*awsEc2query_serializeOpDisableInstanceSqlHaStandbyDetections) ID() string { +func (*awsEc2query_serializeOpDisableImageBlockPublicAccess) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpDisableInstanceSqlHaStandbyDetections) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDisableImageBlockPublicAccess) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -32237,7 +32517,7 @@ func (m *awsEc2query_serializeOpDisableInstanceSqlHaStandbyDetections) HandleSer return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DisableInstanceSqlHaStandbyDetectionsInput) + input, ok := in.Parameters.(*DisableImageBlockPublicAccessInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -32262,10 +32542,10 @@ func (m *awsEc2query_serializeOpDisableInstanceSqlHaStandbyDetections) HandleSer bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("DisableInstanceSqlHaStandbyDetections") + body.Key("Action").String("DisableImageBlockPublicAccess") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentDisableInstanceSqlHaStandbyDetectionsInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentDisableImageBlockPublicAccessInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -32288,14 +32568,14 @@ func (m *awsEc2query_serializeOpDisableInstanceSqlHaStandbyDetections) HandleSer return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpDisableIpamOrganizationAdminAccount struct { +type awsEc2query_serializeOpDisableImageDeprecation struct { } -func (*awsEc2query_serializeOpDisableIpamOrganizationAdminAccount) ID() string { +func (*awsEc2query_serializeOpDisableImageDeprecation) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpDisableIpamOrganizationAdminAccount) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDisableImageDeprecation) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -32307,7 +32587,7 @@ func (m *awsEc2query_serializeOpDisableIpamOrganizationAdminAccount) HandleSeria return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DisableIpamOrganizationAdminAccountInput) + input, ok := in.Parameters.(*DisableImageDeprecationInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -32332,10 +32612,10 @@ func (m *awsEc2query_serializeOpDisableIpamOrganizationAdminAccount) HandleSeria bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("DisableIpamOrganizationAdminAccount") + body.Key("Action").String("DisableImageDeprecation") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentDisableIpamOrganizationAdminAccountInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentDisableImageDeprecationInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -32358,14 +32638,14 @@ func (m *awsEc2query_serializeOpDisableIpamOrganizationAdminAccount) HandleSeria return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpDisableIpamPolicy struct { +type awsEc2query_serializeOpDisableImageDeregistrationProtection struct { } -func (*awsEc2query_serializeOpDisableIpamPolicy) ID() string { +func (*awsEc2query_serializeOpDisableImageDeregistrationProtection) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpDisableIpamPolicy) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDisableImageDeregistrationProtection) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -32377,7 +32657,7 @@ func (m *awsEc2query_serializeOpDisableIpamPolicy) HandleSerialize(ctx context.C return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DisableIpamPolicyInput) + input, ok := in.Parameters.(*DisableImageDeregistrationProtectionInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -32402,10 +32682,10 @@ func (m *awsEc2query_serializeOpDisableIpamPolicy) HandleSerialize(ctx context.C bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("DisableIpamPolicy") + body.Key("Action").String("DisableImageDeregistrationProtection") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentDisableIpamPolicyInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentDisableImageDeregistrationProtectionInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -32428,14 +32708,14 @@ func (m *awsEc2query_serializeOpDisableIpamPolicy) HandleSerialize(ctx context.C return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpDisableRouteServerPropagation struct { +type awsEc2query_serializeOpDisableInstanceSqlHaStandbyDetections struct { } -func (*awsEc2query_serializeOpDisableRouteServerPropagation) ID() string { +func (*awsEc2query_serializeOpDisableInstanceSqlHaStandbyDetections) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpDisableRouteServerPropagation) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDisableInstanceSqlHaStandbyDetections) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -32447,7 +32727,7 @@ func (m *awsEc2query_serializeOpDisableRouteServerPropagation) HandleSerialize(c return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DisableRouteServerPropagationInput) + input, ok := in.Parameters.(*DisableInstanceSqlHaStandbyDetectionsInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -32472,10 +32752,10 @@ func (m *awsEc2query_serializeOpDisableRouteServerPropagation) HandleSerialize(c bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("DisableRouteServerPropagation") + body.Key("Action").String("DisableInstanceSqlHaStandbyDetections") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentDisableRouteServerPropagationInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentDisableInstanceSqlHaStandbyDetectionsInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -32498,14 +32778,14 @@ func (m *awsEc2query_serializeOpDisableRouteServerPropagation) HandleSerialize(c return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpDisableSerialConsoleAccess struct { +type awsEc2query_serializeOpDisableIpamOrganizationAdminAccount struct { } -func (*awsEc2query_serializeOpDisableSerialConsoleAccess) ID() string { +func (*awsEc2query_serializeOpDisableIpamOrganizationAdminAccount) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpDisableSerialConsoleAccess) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDisableIpamOrganizationAdminAccount) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -32517,7 +32797,7 @@ func (m *awsEc2query_serializeOpDisableSerialConsoleAccess) HandleSerialize(ctx return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DisableSerialConsoleAccessInput) + input, ok := in.Parameters.(*DisableIpamOrganizationAdminAccountInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -32542,10 +32822,10 @@ func (m *awsEc2query_serializeOpDisableSerialConsoleAccess) HandleSerialize(ctx bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("DisableSerialConsoleAccess") + body.Key("Action").String("DisableIpamOrganizationAdminAccount") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentDisableSerialConsoleAccessInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentDisableIpamOrganizationAdminAccountInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -32568,14 +32848,14 @@ func (m *awsEc2query_serializeOpDisableSerialConsoleAccess) HandleSerialize(ctx return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpDisableSnapshotBlockPublicAccess struct { +type awsEc2query_serializeOpDisableIpamPolicy struct { } -func (*awsEc2query_serializeOpDisableSnapshotBlockPublicAccess) ID() string { +func (*awsEc2query_serializeOpDisableIpamPolicy) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpDisableSnapshotBlockPublicAccess) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDisableIpamPolicy) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -32587,7 +32867,7 @@ func (m *awsEc2query_serializeOpDisableSnapshotBlockPublicAccess) HandleSerializ return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DisableSnapshotBlockPublicAccessInput) + input, ok := in.Parameters.(*DisableIpamPolicyInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -32612,10 +32892,10 @@ func (m *awsEc2query_serializeOpDisableSnapshotBlockPublicAccess) HandleSerializ bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("DisableSnapshotBlockPublicAccess") + body.Key("Action").String("DisableIpamPolicy") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentDisableSnapshotBlockPublicAccessInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentDisableIpamPolicyInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -32638,14 +32918,14 @@ func (m *awsEc2query_serializeOpDisableSnapshotBlockPublicAccess) HandleSerializ return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpDisableTransitGatewayRouteTablePropagation struct { +type awsEc2query_serializeOpDisableRouteServerPropagation struct { } -func (*awsEc2query_serializeOpDisableTransitGatewayRouteTablePropagation) ID() string { +func (*awsEc2query_serializeOpDisableRouteServerPropagation) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpDisableTransitGatewayRouteTablePropagation) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDisableRouteServerPropagation) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -32657,7 +32937,7 @@ func (m *awsEc2query_serializeOpDisableTransitGatewayRouteTablePropagation) Hand return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DisableTransitGatewayRouteTablePropagationInput) + input, ok := in.Parameters.(*DisableRouteServerPropagationInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -32682,10 +32962,10 @@ func (m *awsEc2query_serializeOpDisableTransitGatewayRouteTablePropagation) Hand bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("DisableTransitGatewayRouteTablePropagation") + body.Key("Action").String("DisableRouteServerPropagation") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentDisableTransitGatewayRouteTablePropagationInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentDisableRouteServerPropagationInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -32708,14 +32988,14 @@ func (m *awsEc2query_serializeOpDisableTransitGatewayRouteTablePropagation) Hand return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpDisableVgwRoutePropagation struct { +type awsEc2query_serializeOpDisableSerialConsoleAccess struct { } -func (*awsEc2query_serializeOpDisableVgwRoutePropagation) ID() string { +func (*awsEc2query_serializeOpDisableSerialConsoleAccess) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpDisableVgwRoutePropagation) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDisableSerialConsoleAccess) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -32727,7 +33007,7 @@ func (m *awsEc2query_serializeOpDisableVgwRoutePropagation) HandleSerialize(ctx return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DisableVgwRoutePropagationInput) + input, ok := in.Parameters.(*DisableSerialConsoleAccessInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -32752,10 +33032,10 @@ func (m *awsEc2query_serializeOpDisableVgwRoutePropagation) HandleSerialize(ctx bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("DisableVgwRoutePropagation") + body.Key("Action").String("DisableSerialConsoleAccess") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentDisableVgwRoutePropagationInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentDisableSerialConsoleAccessInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -32778,14 +33058,14 @@ func (m *awsEc2query_serializeOpDisableVgwRoutePropagation) HandleSerialize(ctx return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpDisableVpcClassicLink struct { +type awsEc2query_serializeOpDisableSnapshotBlockPublicAccess struct { } -func (*awsEc2query_serializeOpDisableVpcClassicLink) ID() string { +func (*awsEc2query_serializeOpDisableSnapshotBlockPublicAccess) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpDisableVpcClassicLink) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDisableSnapshotBlockPublicAccess) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -32797,7 +33077,7 @@ func (m *awsEc2query_serializeOpDisableVpcClassicLink) HandleSerialize(ctx conte return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DisableVpcClassicLinkInput) + input, ok := in.Parameters.(*DisableSnapshotBlockPublicAccessInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -32822,10 +33102,10 @@ func (m *awsEc2query_serializeOpDisableVpcClassicLink) HandleSerialize(ctx conte bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("DisableVpcClassicLink") + body.Key("Action").String("DisableSnapshotBlockPublicAccess") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentDisableVpcClassicLinkInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentDisableSnapshotBlockPublicAccessInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -32848,14 +33128,14 @@ func (m *awsEc2query_serializeOpDisableVpcClassicLink) HandleSerialize(ctx conte return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpDisableVpcClassicLinkDnsSupport struct { +type awsEc2query_serializeOpDisableTransitGatewayRouteTablePropagation struct { } -func (*awsEc2query_serializeOpDisableVpcClassicLinkDnsSupport) ID() string { +func (*awsEc2query_serializeOpDisableTransitGatewayRouteTablePropagation) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpDisableVpcClassicLinkDnsSupport) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDisableTransitGatewayRouteTablePropagation) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -32867,7 +33147,7 @@ func (m *awsEc2query_serializeOpDisableVpcClassicLinkDnsSupport) HandleSerialize return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DisableVpcClassicLinkDnsSupportInput) + input, ok := in.Parameters.(*DisableTransitGatewayRouteTablePropagationInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -32892,10 +33172,10 @@ func (m *awsEc2query_serializeOpDisableVpcClassicLinkDnsSupport) HandleSerialize bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("DisableVpcClassicLinkDnsSupport") + body.Key("Action").String("DisableTransitGatewayRouteTablePropagation") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentDisableVpcClassicLinkDnsSupportInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentDisableTransitGatewayRouteTablePropagationInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -32918,14 +33198,14 @@ func (m *awsEc2query_serializeOpDisableVpcClassicLinkDnsSupport) HandleSerialize return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpDisassociateAddress struct { +type awsEc2query_serializeOpDisableVgwRoutePropagation struct { } -func (*awsEc2query_serializeOpDisassociateAddress) ID() string { +func (*awsEc2query_serializeOpDisableVgwRoutePropagation) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpDisassociateAddress) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDisableVgwRoutePropagation) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -32937,7 +33217,7 @@ func (m *awsEc2query_serializeOpDisassociateAddress) HandleSerialize(ctx context return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DisassociateAddressInput) + input, ok := in.Parameters.(*DisableVgwRoutePropagationInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -32962,10 +33242,10 @@ func (m *awsEc2query_serializeOpDisassociateAddress) HandleSerialize(ctx context bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("DisassociateAddress") + body.Key("Action").String("DisableVgwRoutePropagation") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentDisassociateAddressInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentDisableVgwRoutePropagationInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -32988,14 +33268,14 @@ func (m *awsEc2query_serializeOpDisassociateAddress) HandleSerialize(ctx context return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpDisassociateCapacityReservationBillingOwner struct { +type awsEc2query_serializeOpDisableVpcClassicLink struct { } -func (*awsEc2query_serializeOpDisassociateCapacityReservationBillingOwner) ID() string { +func (*awsEc2query_serializeOpDisableVpcClassicLink) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpDisassociateCapacityReservationBillingOwner) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDisableVpcClassicLink) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -33007,7 +33287,7 @@ func (m *awsEc2query_serializeOpDisassociateCapacityReservationBillingOwner) Han return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DisassociateCapacityReservationBillingOwnerInput) + input, ok := in.Parameters.(*DisableVpcClassicLinkInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -33032,10 +33312,10 @@ func (m *awsEc2query_serializeOpDisassociateCapacityReservationBillingOwner) Han bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("DisassociateCapacityReservationBillingOwner") + body.Key("Action").String("DisableVpcClassicLink") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentDisassociateCapacityReservationBillingOwnerInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentDisableVpcClassicLinkInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -33058,14 +33338,14 @@ func (m *awsEc2query_serializeOpDisassociateCapacityReservationBillingOwner) Han return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpDisassociateClientVpnTargetNetwork struct { +type awsEc2query_serializeOpDisableVpcClassicLinkDnsSupport struct { } -func (*awsEc2query_serializeOpDisassociateClientVpnTargetNetwork) ID() string { +func (*awsEc2query_serializeOpDisableVpcClassicLinkDnsSupport) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpDisassociateClientVpnTargetNetwork) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDisableVpcClassicLinkDnsSupport) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -33077,7 +33357,7 @@ func (m *awsEc2query_serializeOpDisassociateClientVpnTargetNetwork) HandleSerial return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DisassociateClientVpnTargetNetworkInput) + input, ok := in.Parameters.(*DisableVpcClassicLinkDnsSupportInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -33102,10 +33382,10 @@ func (m *awsEc2query_serializeOpDisassociateClientVpnTargetNetwork) HandleSerial bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("DisassociateClientVpnTargetNetwork") + body.Key("Action").String("DisableVpcClassicLinkDnsSupport") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentDisassociateClientVpnTargetNetworkInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentDisableVpcClassicLinkDnsSupportInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -33128,14 +33408,14 @@ func (m *awsEc2query_serializeOpDisassociateClientVpnTargetNetwork) HandleSerial return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpDisassociateEnclaveCertificateIamRole struct { +type awsEc2query_serializeOpDisassociateAddress struct { } -func (*awsEc2query_serializeOpDisassociateEnclaveCertificateIamRole) ID() string { +func (*awsEc2query_serializeOpDisassociateAddress) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpDisassociateEnclaveCertificateIamRole) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDisassociateAddress) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -33147,7 +33427,7 @@ func (m *awsEc2query_serializeOpDisassociateEnclaveCertificateIamRole) HandleSer return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DisassociateEnclaveCertificateIamRoleInput) + input, ok := in.Parameters.(*DisassociateAddressInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -33172,10 +33452,10 @@ func (m *awsEc2query_serializeOpDisassociateEnclaveCertificateIamRole) HandleSer bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("DisassociateEnclaveCertificateIamRole") + body.Key("Action").String("DisassociateAddress") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentDisassociateEnclaveCertificateIamRoleInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentDisassociateAddressInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -33198,14 +33478,14 @@ func (m *awsEc2query_serializeOpDisassociateEnclaveCertificateIamRole) HandleSer return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpDisassociateIamInstanceProfile struct { +type awsEc2query_serializeOpDisassociateCapacityReservationBillingOwner struct { } -func (*awsEc2query_serializeOpDisassociateIamInstanceProfile) ID() string { +func (*awsEc2query_serializeOpDisassociateCapacityReservationBillingOwner) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpDisassociateIamInstanceProfile) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDisassociateCapacityReservationBillingOwner) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -33217,7 +33497,7 @@ func (m *awsEc2query_serializeOpDisassociateIamInstanceProfile) HandleSerialize( return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DisassociateIamInstanceProfileInput) + input, ok := in.Parameters.(*DisassociateCapacityReservationBillingOwnerInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -33242,10 +33522,10 @@ func (m *awsEc2query_serializeOpDisassociateIamInstanceProfile) HandleSerialize( bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("DisassociateIamInstanceProfile") + body.Key("Action").String("DisassociateCapacityReservationBillingOwner") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentDisassociateIamInstanceProfileInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentDisassociateCapacityReservationBillingOwnerInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -33268,14 +33548,14 @@ func (m *awsEc2query_serializeOpDisassociateIamInstanceProfile) HandleSerialize( return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpDisassociateInstanceEventWindow struct { +type awsEc2query_serializeOpDisassociateClientVpnTargetNetwork struct { } -func (*awsEc2query_serializeOpDisassociateInstanceEventWindow) ID() string { +func (*awsEc2query_serializeOpDisassociateClientVpnTargetNetwork) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpDisassociateInstanceEventWindow) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDisassociateClientVpnTargetNetwork) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -33287,7 +33567,7 @@ func (m *awsEc2query_serializeOpDisassociateInstanceEventWindow) HandleSerialize return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DisassociateInstanceEventWindowInput) + input, ok := in.Parameters.(*DisassociateClientVpnTargetNetworkInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -33312,10 +33592,10 @@ func (m *awsEc2query_serializeOpDisassociateInstanceEventWindow) HandleSerialize bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("DisassociateInstanceEventWindow") + body.Key("Action").String("DisassociateClientVpnTargetNetwork") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentDisassociateInstanceEventWindowInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentDisassociateClientVpnTargetNetworkInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -33338,14 +33618,14 @@ func (m *awsEc2query_serializeOpDisassociateInstanceEventWindow) HandleSerialize return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpDisassociateIpamByoasn struct { +type awsEc2query_serializeOpDisassociateEnclaveCertificateIamRole struct { } -func (*awsEc2query_serializeOpDisassociateIpamByoasn) ID() string { +func (*awsEc2query_serializeOpDisassociateEnclaveCertificateIamRole) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpDisassociateIpamByoasn) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDisassociateEnclaveCertificateIamRole) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -33357,7 +33637,7 @@ func (m *awsEc2query_serializeOpDisassociateIpamByoasn) HandleSerialize(ctx cont return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DisassociateIpamByoasnInput) + input, ok := in.Parameters.(*DisassociateEnclaveCertificateIamRoleInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -33382,10 +33662,10 @@ func (m *awsEc2query_serializeOpDisassociateIpamByoasn) HandleSerialize(ctx cont bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("DisassociateIpamByoasn") + body.Key("Action").String("DisassociateEnclaveCertificateIamRole") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentDisassociateIpamByoasnInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentDisassociateEnclaveCertificateIamRoleInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -33408,14 +33688,14 @@ func (m *awsEc2query_serializeOpDisassociateIpamByoasn) HandleSerialize(ctx cont return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpDisassociateIpamResourceDiscovery struct { +type awsEc2query_serializeOpDisassociateIamInstanceProfile struct { } -func (*awsEc2query_serializeOpDisassociateIpamResourceDiscovery) ID() string { +func (*awsEc2query_serializeOpDisassociateIamInstanceProfile) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpDisassociateIpamResourceDiscovery) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDisassociateIamInstanceProfile) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -33427,7 +33707,7 @@ func (m *awsEc2query_serializeOpDisassociateIpamResourceDiscovery) HandleSeriali return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DisassociateIpamResourceDiscoveryInput) + input, ok := in.Parameters.(*DisassociateIamInstanceProfileInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -33452,10 +33732,10 @@ func (m *awsEc2query_serializeOpDisassociateIpamResourceDiscovery) HandleSeriali bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("DisassociateIpamResourceDiscovery") + body.Key("Action").String("DisassociateIamInstanceProfile") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentDisassociateIpamResourceDiscoveryInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentDisassociateIamInstanceProfileInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -33478,14 +33758,14 @@ func (m *awsEc2query_serializeOpDisassociateIpamResourceDiscovery) HandleSeriali return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpDisassociateNatGatewayAddress struct { +type awsEc2query_serializeOpDisassociateInstanceEventWindow struct { } -func (*awsEc2query_serializeOpDisassociateNatGatewayAddress) ID() string { +func (*awsEc2query_serializeOpDisassociateInstanceEventWindow) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpDisassociateNatGatewayAddress) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDisassociateInstanceEventWindow) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -33497,7 +33777,7 @@ func (m *awsEc2query_serializeOpDisassociateNatGatewayAddress) HandleSerialize(c return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DisassociateNatGatewayAddressInput) + input, ok := in.Parameters.(*DisassociateInstanceEventWindowInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -33522,10 +33802,10 @@ func (m *awsEc2query_serializeOpDisassociateNatGatewayAddress) HandleSerialize(c bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("DisassociateNatGatewayAddress") + body.Key("Action").String("DisassociateInstanceEventWindow") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentDisassociateNatGatewayAddressInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentDisassociateInstanceEventWindowInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -33548,14 +33828,14 @@ func (m *awsEc2query_serializeOpDisassociateNatGatewayAddress) HandleSerialize(c return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpDisassociateRouteServer struct { +type awsEc2query_serializeOpDisassociateIpamByoasn struct { } -func (*awsEc2query_serializeOpDisassociateRouteServer) ID() string { +func (*awsEc2query_serializeOpDisassociateIpamByoasn) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpDisassociateRouteServer) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDisassociateIpamByoasn) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -33567,7 +33847,7 @@ func (m *awsEc2query_serializeOpDisassociateRouteServer) HandleSerialize(ctx con return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DisassociateRouteServerInput) + input, ok := in.Parameters.(*DisassociateIpamByoasnInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -33592,10 +33872,10 @@ func (m *awsEc2query_serializeOpDisassociateRouteServer) HandleSerialize(ctx con bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("DisassociateRouteServer") + body.Key("Action").String("DisassociateIpamByoasn") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentDisassociateRouteServerInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentDisassociateIpamByoasnInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -33618,14 +33898,14 @@ func (m *awsEc2query_serializeOpDisassociateRouteServer) HandleSerialize(ctx con return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpDisassociateRouteTable struct { +type awsEc2query_serializeOpDisassociateIpamResourceDiscovery struct { } -func (*awsEc2query_serializeOpDisassociateRouteTable) ID() string { +func (*awsEc2query_serializeOpDisassociateIpamResourceDiscovery) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpDisassociateRouteTable) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDisassociateIpamResourceDiscovery) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -33637,7 +33917,7 @@ func (m *awsEc2query_serializeOpDisassociateRouteTable) HandleSerialize(ctx cont return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DisassociateRouteTableInput) + input, ok := in.Parameters.(*DisassociateIpamResourceDiscoveryInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -33662,10 +33942,10 @@ func (m *awsEc2query_serializeOpDisassociateRouteTable) HandleSerialize(ctx cont bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("DisassociateRouteTable") + body.Key("Action").String("DisassociateIpamResourceDiscovery") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentDisassociateRouteTableInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentDisassociateIpamResourceDiscoveryInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -33688,14 +33968,14 @@ func (m *awsEc2query_serializeOpDisassociateRouteTable) HandleSerialize(ctx cont return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpDisassociateSecurityGroupVpc struct { +type awsEc2query_serializeOpDisassociateNatGatewayAddress struct { } -func (*awsEc2query_serializeOpDisassociateSecurityGroupVpc) ID() string { +func (*awsEc2query_serializeOpDisassociateNatGatewayAddress) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpDisassociateSecurityGroupVpc) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDisassociateNatGatewayAddress) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -33707,7 +33987,7 @@ func (m *awsEc2query_serializeOpDisassociateSecurityGroupVpc) HandleSerialize(ct return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DisassociateSecurityGroupVpcInput) + input, ok := in.Parameters.(*DisassociateNatGatewayAddressInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -33732,10 +34012,10 @@ func (m *awsEc2query_serializeOpDisassociateSecurityGroupVpc) HandleSerialize(ct bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("DisassociateSecurityGroupVpc") + body.Key("Action").String("DisassociateNatGatewayAddress") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentDisassociateSecurityGroupVpcInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentDisassociateNatGatewayAddressInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -33758,14 +34038,14 @@ func (m *awsEc2query_serializeOpDisassociateSecurityGroupVpc) HandleSerialize(ct return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpDisassociateSubnetCidrBlock struct { +type awsEc2query_serializeOpDisassociateRouteServer struct { } -func (*awsEc2query_serializeOpDisassociateSubnetCidrBlock) ID() string { +func (*awsEc2query_serializeOpDisassociateRouteServer) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpDisassociateSubnetCidrBlock) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDisassociateRouteServer) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -33777,7 +34057,7 @@ func (m *awsEc2query_serializeOpDisassociateSubnetCidrBlock) HandleSerialize(ctx return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DisassociateSubnetCidrBlockInput) + input, ok := in.Parameters.(*DisassociateRouteServerInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -33802,10 +34082,10 @@ func (m *awsEc2query_serializeOpDisassociateSubnetCidrBlock) HandleSerialize(ctx bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("DisassociateSubnetCidrBlock") + body.Key("Action").String("DisassociateRouteServer") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentDisassociateSubnetCidrBlockInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentDisassociateRouteServerInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -33828,14 +34108,14 @@ func (m *awsEc2query_serializeOpDisassociateSubnetCidrBlock) HandleSerialize(ctx return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpDisassociateTransitGatewayMulticastDomain struct { +type awsEc2query_serializeOpDisassociateRouteTable struct { } -func (*awsEc2query_serializeOpDisassociateTransitGatewayMulticastDomain) ID() string { +func (*awsEc2query_serializeOpDisassociateRouteTable) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpDisassociateTransitGatewayMulticastDomain) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDisassociateRouteTable) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -33847,7 +34127,7 @@ func (m *awsEc2query_serializeOpDisassociateTransitGatewayMulticastDomain) Handl return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DisassociateTransitGatewayMulticastDomainInput) + input, ok := in.Parameters.(*DisassociateRouteTableInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -33872,10 +34152,10 @@ func (m *awsEc2query_serializeOpDisassociateTransitGatewayMulticastDomain) Handl bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("DisassociateTransitGatewayMulticastDomain") + body.Key("Action").String("DisassociateRouteTable") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentDisassociateTransitGatewayMulticastDomainInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentDisassociateRouteTableInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -33898,14 +34178,14 @@ func (m *awsEc2query_serializeOpDisassociateTransitGatewayMulticastDomain) Handl return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpDisassociateTransitGatewayPolicyTable struct { +type awsEc2query_serializeOpDisassociateSecurityGroupVpc struct { } -func (*awsEc2query_serializeOpDisassociateTransitGatewayPolicyTable) ID() string { +func (*awsEc2query_serializeOpDisassociateSecurityGroupVpc) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpDisassociateTransitGatewayPolicyTable) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDisassociateSecurityGroupVpc) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -33917,7 +34197,7 @@ func (m *awsEc2query_serializeOpDisassociateTransitGatewayPolicyTable) HandleSer return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DisassociateTransitGatewayPolicyTableInput) + input, ok := in.Parameters.(*DisassociateSecurityGroupVpcInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -33942,10 +34222,10 @@ func (m *awsEc2query_serializeOpDisassociateTransitGatewayPolicyTable) HandleSer bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("DisassociateTransitGatewayPolicyTable") + body.Key("Action").String("DisassociateSecurityGroupVpc") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentDisassociateTransitGatewayPolicyTableInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentDisassociateSecurityGroupVpcInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -33968,14 +34248,14 @@ func (m *awsEc2query_serializeOpDisassociateTransitGatewayPolicyTable) HandleSer return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpDisassociateTransitGatewayRouteTable struct { +type awsEc2query_serializeOpDisassociateSubnetCidrBlock struct { } -func (*awsEc2query_serializeOpDisassociateTransitGatewayRouteTable) ID() string { +func (*awsEc2query_serializeOpDisassociateSubnetCidrBlock) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpDisassociateTransitGatewayRouteTable) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDisassociateSubnetCidrBlock) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -33987,7 +34267,7 @@ func (m *awsEc2query_serializeOpDisassociateTransitGatewayRouteTable) HandleSeri return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DisassociateTransitGatewayRouteTableInput) + input, ok := in.Parameters.(*DisassociateSubnetCidrBlockInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -34012,10 +34292,10 @@ func (m *awsEc2query_serializeOpDisassociateTransitGatewayRouteTable) HandleSeri bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("DisassociateTransitGatewayRouteTable") + body.Key("Action").String("DisassociateSubnetCidrBlock") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentDisassociateTransitGatewayRouteTableInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentDisassociateSubnetCidrBlockInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -34038,14 +34318,14 @@ func (m *awsEc2query_serializeOpDisassociateTransitGatewayRouteTable) HandleSeri return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpDisassociateTrunkInterface struct { +type awsEc2query_serializeOpDisassociateTransitGatewayMulticastDomain struct { } -func (*awsEc2query_serializeOpDisassociateTrunkInterface) ID() string { +func (*awsEc2query_serializeOpDisassociateTransitGatewayMulticastDomain) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpDisassociateTrunkInterface) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDisassociateTransitGatewayMulticastDomain) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -34057,7 +34337,7 @@ func (m *awsEc2query_serializeOpDisassociateTrunkInterface) HandleSerialize(ctx return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DisassociateTrunkInterfaceInput) + input, ok := in.Parameters.(*DisassociateTransitGatewayMulticastDomainInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -34082,10 +34362,10 @@ func (m *awsEc2query_serializeOpDisassociateTrunkInterface) HandleSerialize(ctx bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("DisassociateTrunkInterface") + body.Key("Action").String("DisassociateTransitGatewayMulticastDomain") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentDisassociateTrunkInterfaceInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentDisassociateTransitGatewayMulticastDomainInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -34108,14 +34388,14 @@ func (m *awsEc2query_serializeOpDisassociateTrunkInterface) HandleSerialize(ctx return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpDisassociateVpcCidrBlock struct { +type awsEc2query_serializeOpDisassociateTransitGatewayPolicyTable struct { } -func (*awsEc2query_serializeOpDisassociateVpcCidrBlock) ID() string { +func (*awsEc2query_serializeOpDisassociateTransitGatewayPolicyTable) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpDisassociateVpcCidrBlock) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDisassociateTransitGatewayPolicyTable) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -34127,7 +34407,7 @@ func (m *awsEc2query_serializeOpDisassociateVpcCidrBlock) HandleSerialize(ctx co return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*DisassociateVpcCidrBlockInput) + input, ok := in.Parameters.(*DisassociateTransitGatewayPolicyTableInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -34152,10 +34432,10 @@ func (m *awsEc2query_serializeOpDisassociateVpcCidrBlock) HandleSerialize(ctx co bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("DisassociateVpcCidrBlock") + body.Key("Action").String("DisassociateTransitGatewayPolicyTable") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentDisassociateVpcCidrBlockInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentDisassociateTransitGatewayPolicyTableInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -34178,14 +34458,14 @@ func (m *awsEc2query_serializeOpDisassociateVpcCidrBlock) HandleSerialize(ctx co return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpEnableAddressTransfer struct { +type awsEc2query_serializeOpDisassociateTransitGatewayRouteTable struct { } -func (*awsEc2query_serializeOpEnableAddressTransfer) ID() string { +func (*awsEc2query_serializeOpDisassociateTransitGatewayRouteTable) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpEnableAddressTransfer) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDisassociateTransitGatewayRouteTable) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -34197,7 +34477,7 @@ func (m *awsEc2query_serializeOpEnableAddressTransfer) HandleSerialize(ctx conte return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*EnableAddressTransferInput) + input, ok := in.Parameters.(*DisassociateTransitGatewayRouteTableInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -34222,10 +34502,10 @@ func (m *awsEc2query_serializeOpEnableAddressTransfer) HandleSerialize(ctx conte bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("EnableAddressTransfer") + body.Key("Action").String("DisassociateTransitGatewayRouteTable") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentEnableAddressTransferInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentDisassociateTransitGatewayRouteTableInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -34248,14 +34528,14 @@ func (m *awsEc2query_serializeOpEnableAddressTransfer) HandleSerialize(ctx conte return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpEnableAllowedImagesSettings struct { +type awsEc2query_serializeOpDisassociateTrunkInterface struct { } -func (*awsEc2query_serializeOpEnableAllowedImagesSettings) ID() string { +func (*awsEc2query_serializeOpDisassociateTrunkInterface) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpEnableAllowedImagesSettings) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDisassociateTrunkInterface) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -34267,7 +34547,7 @@ func (m *awsEc2query_serializeOpEnableAllowedImagesSettings) HandleSerialize(ctx return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*EnableAllowedImagesSettingsInput) + input, ok := in.Parameters.(*DisassociateTrunkInterfaceInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -34292,10 +34572,10 @@ func (m *awsEc2query_serializeOpEnableAllowedImagesSettings) HandleSerialize(ctx bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("EnableAllowedImagesSettings") + body.Key("Action").String("DisassociateTrunkInterface") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentEnableAllowedImagesSettingsInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentDisassociateTrunkInterfaceInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -34318,14 +34598,14 @@ func (m *awsEc2query_serializeOpEnableAllowedImagesSettings) HandleSerialize(ctx return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpEnableAwsNetworkPerformanceMetricSubscription struct { +type awsEc2query_serializeOpDisassociateVpcCidrBlock struct { } -func (*awsEc2query_serializeOpEnableAwsNetworkPerformanceMetricSubscription) ID() string { +func (*awsEc2query_serializeOpDisassociateVpcCidrBlock) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpEnableAwsNetworkPerformanceMetricSubscription) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpDisassociateVpcCidrBlock) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -34337,7 +34617,7 @@ func (m *awsEc2query_serializeOpEnableAwsNetworkPerformanceMetricSubscription) H return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*EnableAwsNetworkPerformanceMetricSubscriptionInput) + input, ok := in.Parameters.(*DisassociateVpcCidrBlockInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -34362,10 +34642,10 @@ func (m *awsEc2query_serializeOpEnableAwsNetworkPerformanceMetricSubscription) H bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("EnableAwsNetworkPerformanceMetricSubscription") + body.Key("Action").String("DisassociateVpcCidrBlock") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentEnableAwsNetworkPerformanceMetricSubscriptionInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentDisassociateVpcCidrBlockInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -34388,14 +34668,14 @@ func (m *awsEc2query_serializeOpEnableAwsNetworkPerformanceMetricSubscription) H return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpEnableCapacityManager struct { +type awsEc2query_serializeOpEnableAddressTransfer struct { } -func (*awsEc2query_serializeOpEnableCapacityManager) ID() string { +func (*awsEc2query_serializeOpEnableAddressTransfer) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpEnableCapacityManager) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpEnableAddressTransfer) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -34407,7 +34687,7 @@ func (m *awsEc2query_serializeOpEnableCapacityManager) HandleSerialize(ctx conte return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*EnableCapacityManagerInput) + input, ok := in.Parameters.(*EnableAddressTransferInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -34432,10 +34712,10 @@ func (m *awsEc2query_serializeOpEnableCapacityManager) HandleSerialize(ctx conte bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("EnableCapacityManager") + body.Key("Action").String("EnableAddressTransfer") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentEnableCapacityManagerInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentEnableAddressTransferInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -34458,14 +34738,14 @@ func (m *awsEc2query_serializeOpEnableCapacityManager) HandleSerialize(ctx conte return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpEnableEbsEncryptionByDefault struct { +type awsEc2query_serializeOpEnableAllowedImagesSettings struct { } -func (*awsEc2query_serializeOpEnableEbsEncryptionByDefault) ID() string { +func (*awsEc2query_serializeOpEnableAllowedImagesSettings) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpEnableEbsEncryptionByDefault) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpEnableAllowedImagesSettings) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -34477,7 +34757,7 @@ func (m *awsEc2query_serializeOpEnableEbsEncryptionByDefault) HandleSerialize(ct return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*EnableEbsEncryptionByDefaultInput) + input, ok := in.Parameters.(*EnableAllowedImagesSettingsInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -34502,10 +34782,10 @@ func (m *awsEc2query_serializeOpEnableEbsEncryptionByDefault) HandleSerialize(ct bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("EnableEbsEncryptionByDefault") + body.Key("Action").String("EnableAllowedImagesSettings") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentEnableEbsEncryptionByDefaultInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentEnableAllowedImagesSettingsInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -34528,14 +34808,14 @@ func (m *awsEc2query_serializeOpEnableEbsEncryptionByDefault) HandleSerialize(ct return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpEnableFastLaunch struct { +type awsEc2query_serializeOpEnableAwsNetworkPerformanceMetricSubscription struct { } -func (*awsEc2query_serializeOpEnableFastLaunch) ID() string { +func (*awsEc2query_serializeOpEnableAwsNetworkPerformanceMetricSubscription) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpEnableFastLaunch) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpEnableAwsNetworkPerformanceMetricSubscription) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -34547,7 +34827,7 @@ func (m *awsEc2query_serializeOpEnableFastLaunch) HandleSerialize(ctx context.Co return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*EnableFastLaunchInput) + input, ok := in.Parameters.(*EnableAwsNetworkPerformanceMetricSubscriptionInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -34572,10 +34852,10 @@ func (m *awsEc2query_serializeOpEnableFastLaunch) HandleSerialize(ctx context.Co bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("EnableFastLaunch") + body.Key("Action").String("EnableAwsNetworkPerformanceMetricSubscription") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentEnableFastLaunchInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentEnableAwsNetworkPerformanceMetricSubscriptionInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -34598,14 +34878,14 @@ func (m *awsEc2query_serializeOpEnableFastLaunch) HandleSerialize(ctx context.Co return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpEnableFastSnapshotRestores struct { +type awsEc2query_serializeOpEnableCapacityManager struct { } -func (*awsEc2query_serializeOpEnableFastSnapshotRestores) ID() string { +func (*awsEc2query_serializeOpEnableCapacityManager) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpEnableFastSnapshotRestores) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpEnableCapacityManager) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -34617,7 +34897,7 @@ func (m *awsEc2query_serializeOpEnableFastSnapshotRestores) HandleSerialize(ctx return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*EnableFastSnapshotRestoresInput) + input, ok := in.Parameters.(*EnableCapacityManagerInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -34642,10 +34922,10 @@ func (m *awsEc2query_serializeOpEnableFastSnapshotRestores) HandleSerialize(ctx bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("EnableFastSnapshotRestores") + body.Key("Action").String("EnableCapacityManager") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentEnableFastSnapshotRestoresInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentEnableCapacityManagerInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -34668,14 +34948,14 @@ func (m *awsEc2query_serializeOpEnableFastSnapshotRestores) HandleSerialize(ctx return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpEnableImage struct { +type awsEc2query_serializeOpEnableEbsEncryptionByDefault struct { } -func (*awsEc2query_serializeOpEnableImage) ID() string { +func (*awsEc2query_serializeOpEnableEbsEncryptionByDefault) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpEnableImage) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpEnableEbsEncryptionByDefault) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -34687,7 +34967,7 @@ func (m *awsEc2query_serializeOpEnableImage) HandleSerialize(ctx context.Context return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*EnableImageInput) + input, ok := in.Parameters.(*EnableEbsEncryptionByDefaultInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -34712,10 +34992,10 @@ func (m *awsEc2query_serializeOpEnableImage) HandleSerialize(ctx context.Context bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("EnableImage") + body.Key("Action").String("EnableEbsEncryptionByDefault") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentEnableImageInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentEnableEbsEncryptionByDefaultInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -34738,14 +35018,14 @@ func (m *awsEc2query_serializeOpEnableImage) HandleSerialize(ctx context.Context return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpEnableImageBlockPublicAccess struct { +type awsEc2query_serializeOpEnableFastLaunch struct { } -func (*awsEc2query_serializeOpEnableImageBlockPublicAccess) ID() string { +func (*awsEc2query_serializeOpEnableFastLaunch) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpEnableImageBlockPublicAccess) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpEnableFastLaunch) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -34757,7 +35037,7 @@ func (m *awsEc2query_serializeOpEnableImageBlockPublicAccess) HandleSerialize(ct return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*EnableImageBlockPublicAccessInput) + input, ok := in.Parameters.(*EnableFastLaunchInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -34782,10 +35062,10 @@ func (m *awsEc2query_serializeOpEnableImageBlockPublicAccess) HandleSerialize(ct bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("EnableImageBlockPublicAccess") + body.Key("Action").String("EnableFastLaunch") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentEnableImageBlockPublicAccessInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentEnableFastLaunchInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -34808,14 +35088,14 @@ func (m *awsEc2query_serializeOpEnableImageBlockPublicAccess) HandleSerialize(ct return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpEnableImageDeprecation struct { +type awsEc2query_serializeOpEnableFastSnapshotRestores struct { } -func (*awsEc2query_serializeOpEnableImageDeprecation) ID() string { +func (*awsEc2query_serializeOpEnableFastSnapshotRestores) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpEnableImageDeprecation) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpEnableFastSnapshotRestores) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -34827,7 +35107,7 @@ func (m *awsEc2query_serializeOpEnableImageDeprecation) HandleSerialize(ctx cont return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*EnableImageDeprecationInput) + input, ok := in.Parameters.(*EnableFastSnapshotRestoresInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -34852,10 +35132,10 @@ func (m *awsEc2query_serializeOpEnableImageDeprecation) HandleSerialize(ctx cont bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("EnableImageDeprecation") + body.Key("Action").String("EnableFastSnapshotRestores") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentEnableImageDeprecationInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentEnableFastSnapshotRestoresInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -34878,14 +35158,14 @@ func (m *awsEc2query_serializeOpEnableImageDeprecation) HandleSerialize(ctx cont return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpEnableImageDeregistrationProtection struct { +type awsEc2query_serializeOpEnableImage struct { } -func (*awsEc2query_serializeOpEnableImageDeregistrationProtection) ID() string { +func (*awsEc2query_serializeOpEnableImage) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpEnableImageDeregistrationProtection) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpEnableImage) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -34897,7 +35177,7 @@ func (m *awsEc2query_serializeOpEnableImageDeregistrationProtection) HandleSeria return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*EnableImageDeregistrationProtectionInput) + input, ok := in.Parameters.(*EnableImageInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -34922,10 +35202,10 @@ func (m *awsEc2query_serializeOpEnableImageDeregistrationProtection) HandleSeria bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("EnableImageDeregistrationProtection") + body.Key("Action").String("EnableImage") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentEnableImageDeregistrationProtectionInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentEnableImageInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -34948,14 +35228,14 @@ func (m *awsEc2query_serializeOpEnableImageDeregistrationProtection) HandleSeria return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpEnableInstanceSqlHaStandbyDetections struct { +type awsEc2query_serializeOpEnableImageBlockPublicAccess struct { } -func (*awsEc2query_serializeOpEnableInstanceSqlHaStandbyDetections) ID() string { +func (*awsEc2query_serializeOpEnableImageBlockPublicAccess) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpEnableInstanceSqlHaStandbyDetections) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpEnableImageBlockPublicAccess) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -34967,7 +35247,7 @@ func (m *awsEc2query_serializeOpEnableInstanceSqlHaStandbyDetections) HandleSeri return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*EnableInstanceSqlHaStandbyDetectionsInput) + input, ok := in.Parameters.(*EnableImageBlockPublicAccessInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -34992,10 +35272,10 @@ func (m *awsEc2query_serializeOpEnableInstanceSqlHaStandbyDetections) HandleSeri bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("EnableInstanceSqlHaStandbyDetections") + body.Key("Action").String("EnableImageBlockPublicAccess") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentEnableInstanceSqlHaStandbyDetectionsInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentEnableImageBlockPublicAccessInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -35018,14 +35298,14 @@ func (m *awsEc2query_serializeOpEnableInstanceSqlHaStandbyDetections) HandleSeri return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpEnableIpamOrganizationAdminAccount struct { +type awsEc2query_serializeOpEnableImageDeprecation struct { } -func (*awsEc2query_serializeOpEnableIpamOrganizationAdminAccount) ID() string { +func (*awsEc2query_serializeOpEnableImageDeprecation) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpEnableIpamOrganizationAdminAccount) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpEnableImageDeprecation) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -35037,7 +35317,7 @@ func (m *awsEc2query_serializeOpEnableIpamOrganizationAdminAccount) HandleSerial return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*EnableIpamOrganizationAdminAccountInput) + input, ok := in.Parameters.(*EnableImageDeprecationInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -35062,10 +35342,10 @@ func (m *awsEc2query_serializeOpEnableIpamOrganizationAdminAccount) HandleSerial bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("EnableIpamOrganizationAdminAccount") + body.Key("Action").String("EnableImageDeprecation") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentEnableIpamOrganizationAdminAccountInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentEnableImageDeprecationInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -35088,14 +35368,14 @@ func (m *awsEc2query_serializeOpEnableIpamOrganizationAdminAccount) HandleSerial return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpEnableIpamPolicy struct { +type awsEc2query_serializeOpEnableImageDeregistrationProtection struct { } -func (*awsEc2query_serializeOpEnableIpamPolicy) ID() string { +func (*awsEc2query_serializeOpEnableImageDeregistrationProtection) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpEnableIpamPolicy) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpEnableImageDeregistrationProtection) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -35107,7 +35387,7 @@ func (m *awsEc2query_serializeOpEnableIpamPolicy) HandleSerialize(ctx context.Co return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*EnableIpamPolicyInput) + input, ok := in.Parameters.(*EnableImageDeregistrationProtectionInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -35132,10 +35412,10 @@ func (m *awsEc2query_serializeOpEnableIpamPolicy) HandleSerialize(ctx context.Co bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("EnableIpamPolicy") + body.Key("Action").String("EnableImageDeregistrationProtection") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentEnableIpamPolicyInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentEnableImageDeregistrationProtectionInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -35158,14 +35438,14 @@ func (m *awsEc2query_serializeOpEnableIpamPolicy) HandleSerialize(ctx context.Co return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpEnableReachabilityAnalyzerOrganizationSharing struct { +type awsEc2query_serializeOpEnableInstanceSqlHaStandbyDetections struct { } -func (*awsEc2query_serializeOpEnableReachabilityAnalyzerOrganizationSharing) ID() string { +func (*awsEc2query_serializeOpEnableInstanceSqlHaStandbyDetections) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpEnableReachabilityAnalyzerOrganizationSharing) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpEnableInstanceSqlHaStandbyDetections) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -35177,7 +35457,7 @@ func (m *awsEc2query_serializeOpEnableReachabilityAnalyzerOrganizationSharing) H return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*EnableReachabilityAnalyzerOrganizationSharingInput) + input, ok := in.Parameters.(*EnableInstanceSqlHaStandbyDetectionsInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -35202,10 +35482,10 @@ func (m *awsEc2query_serializeOpEnableReachabilityAnalyzerOrganizationSharing) H bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("EnableReachabilityAnalyzerOrganizationSharing") + body.Key("Action").String("EnableInstanceSqlHaStandbyDetections") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentEnableReachabilityAnalyzerOrganizationSharingInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentEnableInstanceSqlHaStandbyDetectionsInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -35228,14 +35508,14 @@ func (m *awsEc2query_serializeOpEnableReachabilityAnalyzerOrganizationSharing) H return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpEnableRouteServerPropagation struct { +type awsEc2query_serializeOpEnableIpamOrganizationAdminAccount struct { } -func (*awsEc2query_serializeOpEnableRouteServerPropagation) ID() string { +func (*awsEc2query_serializeOpEnableIpamOrganizationAdminAccount) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpEnableRouteServerPropagation) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpEnableIpamOrganizationAdminAccount) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -35247,7 +35527,7 @@ func (m *awsEc2query_serializeOpEnableRouteServerPropagation) HandleSerialize(ct return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*EnableRouteServerPropagationInput) + input, ok := in.Parameters.(*EnableIpamOrganizationAdminAccountInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -35272,10 +35552,10 @@ func (m *awsEc2query_serializeOpEnableRouteServerPropagation) HandleSerialize(ct bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("EnableRouteServerPropagation") + body.Key("Action").String("EnableIpamOrganizationAdminAccount") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentEnableRouteServerPropagationInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentEnableIpamOrganizationAdminAccountInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -35298,14 +35578,14 @@ func (m *awsEc2query_serializeOpEnableRouteServerPropagation) HandleSerialize(ct return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpEnableSerialConsoleAccess struct { +type awsEc2query_serializeOpEnableIpamPolicy struct { } -func (*awsEc2query_serializeOpEnableSerialConsoleAccess) ID() string { +func (*awsEc2query_serializeOpEnableIpamPolicy) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpEnableSerialConsoleAccess) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpEnableIpamPolicy) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -35317,7 +35597,7 @@ func (m *awsEc2query_serializeOpEnableSerialConsoleAccess) HandleSerialize(ctx c return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*EnableSerialConsoleAccessInput) + input, ok := in.Parameters.(*EnableIpamPolicyInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -35342,10 +35622,10 @@ func (m *awsEc2query_serializeOpEnableSerialConsoleAccess) HandleSerialize(ctx c bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("EnableSerialConsoleAccess") + body.Key("Action").String("EnableIpamPolicy") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentEnableSerialConsoleAccessInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentEnableIpamPolicyInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -35368,14 +35648,14 @@ func (m *awsEc2query_serializeOpEnableSerialConsoleAccess) HandleSerialize(ctx c return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpEnableSnapshotBlockPublicAccess struct { +type awsEc2query_serializeOpEnableReachabilityAnalyzerOrganizationSharing struct { } -func (*awsEc2query_serializeOpEnableSnapshotBlockPublicAccess) ID() string { +func (*awsEc2query_serializeOpEnableReachabilityAnalyzerOrganizationSharing) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpEnableSnapshotBlockPublicAccess) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpEnableReachabilityAnalyzerOrganizationSharing) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -35387,7 +35667,7 @@ func (m *awsEc2query_serializeOpEnableSnapshotBlockPublicAccess) HandleSerialize return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*EnableSnapshotBlockPublicAccessInput) + input, ok := in.Parameters.(*EnableReachabilityAnalyzerOrganizationSharingInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -35412,10 +35692,10 @@ func (m *awsEc2query_serializeOpEnableSnapshotBlockPublicAccess) HandleSerialize bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("EnableSnapshotBlockPublicAccess") + body.Key("Action").String("EnableReachabilityAnalyzerOrganizationSharing") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentEnableSnapshotBlockPublicAccessInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentEnableReachabilityAnalyzerOrganizationSharingInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -35438,14 +35718,14 @@ func (m *awsEc2query_serializeOpEnableSnapshotBlockPublicAccess) HandleSerialize return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpEnableTransitGatewayRouteTablePropagation struct { +type awsEc2query_serializeOpEnableRouteServerPropagation struct { } -func (*awsEc2query_serializeOpEnableTransitGatewayRouteTablePropagation) ID() string { +func (*awsEc2query_serializeOpEnableRouteServerPropagation) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpEnableTransitGatewayRouteTablePropagation) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpEnableRouteServerPropagation) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -35457,7 +35737,7 @@ func (m *awsEc2query_serializeOpEnableTransitGatewayRouteTablePropagation) Handl return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*EnableTransitGatewayRouteTablePropagationInput) + input, ok := in.Parameters.(*EnableRouteServerPropagationInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -35482,10 +35762,10 @@ func (m *awsEc2query_serializeOpEnableTransitGatewayRouteTablePropagation) Handl bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("EnableTransitGatewayRouteTablePropagation") + body.Key("Action").String("EnableRouteServerPropagation") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentEnableTransitGatewayRouteTablePropagationInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentEnableRouteServerPropagationInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -35508,14 +35788,14 @@ func (m *awsEc2query_serializeOpEnableTransitGatewayRouteTablePropagation) Handl return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpEnableVgwRoutePropagation struct { +type awsEc2query_serializeOpEnableSerialConsoleAccess struct { } -func (*awsEc2query_serializeOpEnableVgwRoutePropagation) ID() string { +func (*awsEc2query_serializeOpEnableSerialConsoleAccess) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpEnableVgwRoutePropagation) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpEnableSerialConsoleAccess) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -35527,7 +35807,7 @@ func (m *awsEc2query_serializeOpEnableVgwRoutePropagation) HandleSerialize(ctx c return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*EnableVgwRoutePropagationInput) + input, ok := in.Parameters.(*EnableSerialConsoleAccessInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -35552,10 +35832,10 @@ func (m *awsEc2query_serializeOpEnableVgwRoutePropagation) HandleSerialize(ctx c bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("EnableVgwRoutePropagation") + body.Key("Action").String("EnableSerialConsoleAccess") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentEnableVgwRoutePropagationInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentEnableSerialConsoleAccessInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -35578,14 +35858,14 @@ func (m *awsEc2query_serializeOpEnableVgwRoutePropagation) HandleSerialize(ctx c return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpEnableVolumeIO struct { +type awsEc2query_serializeOpEnableSnapshotBlockPublicAccess struct { } -func (*awsEc2query_serializeOpEnableVolumeIO) ID() string { +func (*awsEc2query_serializeOpEnableSnapshotBlockPublicAccess) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpEnableVolumeIO) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpEnableSnapshotBlockPublicAccess) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -35597,7 +35877,7 @@ func (m *awsEc2query_serializeOpEnableVolumeIO) HandleSerialize(ctx context.Cont return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*EnableVolumeIOInput) + input, ok := in.Parameters.(*EnableSnapshotBlockPublicAccessInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -35622,10 +35902,10 @@ func (m *awsEc2query_serializeOpEnableVolumeIO) HandleSerialize(ctx context.Cont bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("EnableVolumeIO") + body.Key("Action").String("EnableSnapshotBlockPublicAccess") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentEnableVolumeIOInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentEnableSnapshotBlockPublicAccessInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -35648,14 +35928,14 @@ func (m *awsEc2query_serializeOpEnableVolumeIO) HandleSerialize(ctx context.Cont return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpEnableVpcClassicLink struct { +type awsEc2query_serializeOpEnableTransitGatewayRouteTablePropagation struct { } -func (*awsEc2query_serializeOpEnableVpcClassicLink) ID() string { +func (*awsEc2query_serializeOpEnableTransitGatewayRouteTablePropagation) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpEnableVpcClassicLink) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpEnableTransitGatewayRouteTablePropagation) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -35667,7 +35947,7 @@ func (m *awsEc2query_serializeOpEnableVpcClassicLink) HandleSerialize(ctx contex return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*EnableVpcClassicLinkInput) + input, ok := in.Parameters.(*EnableTransitGatewayRouteTablePropagationInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -35692,10 +35972,10 @@ func (m *awsEc2query_serializeOpEnableVpcClassicLink) HandleSerialize(ctx contex bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("EnableVpcClassicLink") + body.Key("Action").String("EnableTransitGatewayRouteTablePropagation") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentEnableVpcClassicLinkInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentEnableTransitGatewayRouteTablePropagationInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -35718,14 +35998,14 @@ func (m *awsEc2query_serializeOpEnableVpcClassicLink) HandleSerialize(ctx contex return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpEnableVpcClassicLinkDnsSupport struct { +type awsEc2query_serializeOpEnableVgwRoutePropagation struct { } -func (*awsEc2query_serializeOpEnableVpcClassicLinkDnsSupport) ID() string { +func (*awsEc2query_serializeOpEnableVgwRoutePropagation) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpEnableVpcClassicLinkDnsSupport) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpEnableVgwRoutePropagation) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -35737,7 +36017,7 @@ func (m *awsEc2query_serializeOpEnableVpcClassicLinkDnsSupport) HandleSerialize( return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*EnableVpcClassicLinkDnsSupportInput) + input, ok := in.Parameters.(*EnableVgwRoutePropagationInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -35762,10 +36042,10 @@ func (m *awsEc2query_serializeOpEnableVpcClassicLinkDnsSupport) HandleSerialize( bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("EnableVpcClassicLinkDnsSupport") + body.Key("Action").String("EnableVgwRoutePropagation") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentEnableVpcClassicLinkDnsSupportInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentEnableVgwRoutePropagationInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -35788,14 +36068,14 @@ func (m *awsEc2query_serializeOpEnableVpcClassicLinkDnsSupport) HandleSerialize( return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpExportClientVpnClientCertificateRevocationList struct { +type awsEc2query_serializeOpEnableVolumeIO struct { } -func (*awsEc2query_serializeOpExportClientVpnClientCertificateRevocationList) ID() string { +func (*awsEc2query_serializeOpEnableVolumeIO) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpExportClientVpnClientCertificateRevocationList) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpEnableVolumeIO) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -35807,7 +36087,7 @@ func (m *awsEc2query_serializeOpExportClientVpnClientCertificateRevocationList) return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ExportClientVpnClientCertificateRevocationListInput) + input, ok := in.Parameters.(*EnableVolumeIOInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -35832,10 +36112,10 @@ func (m *awsEc2query_serializeOpExportClientVpnClientCertificateRevocationList) bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("ExportClientVpnClientCertificateRevocationList") + body.Key("Action").String("EnableVolumeIO") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentExportClientVpnClientCertificateRevocationListInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentEnableVolumeIOInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -35858,14 +36138,14 @@ func (m *awsEc2query_serializeOpExportClientVpnClientCertificateRevocationList) return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpExportClientVpnClientConfiguration struct { +type awsEc2query_serializeOpEnableVpcClassicLink struct { } -func (*awsEc2query_serializeOpExportClientVpnClientConfiguration) ID() string { +func (*awsEc2query_serializeOpEnableVpcClassicLink) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpExportClientVpnClientConfiguration) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpEnableVpcClassicLink) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -35877,7 +36157,7 @@ func (m *awsEc2query_serializeOpExportClientVpnClientConfiguration) HandleSerial return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ExportClientVpnClientConfigurationInput) + input, ok := in.Parameters.(*EnableVpcClassicLinkInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -35902,10 +36182,10 @@ func (m *awsEc2query_serializeOpExportClientVpnClientConfiguration) HandleSerial bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("ExportClientVpnClientConfiguration") + body.Key("Action").String("EnableVpcClassicLink") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentExportClientVpnClientConfigurationInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentEnableVpcClassicLinkInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -35928,14 +36208,14 @@ func (m *awsEc2query_serializeOpExportClientVpnClientConfiguration) HandleSerial return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpExportImage struct { +type awsEc2query_serializeOpEnableVpcClassicLinkDnsSupport struct { } -func (*awsEc2query_serializeOpExportImage) ID() string { +func (*awsEc2query_serializeOpEnableVpcClassicLinkDnsSupport) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpExportImage) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpEnableVpcClassicLinkDnsSupport) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -35947,7 +36227,7 @@ func (m *awsEc2query_serializeOpExportImage) HandleSerialize(ctx context.Context return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ExportImageInput) + input, ok := in.Parameters.(*EnableVpcClassicLinkDnsSupportInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -35972,10 +36252,10 @@ func (m *awsEc2query_serializeOpExportImage) HandleSerialize(ctx context.Context bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("ExportImage") + body.Key("Action").String("EnableVpcClassicLinkDnsSupport") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentExportImageInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentEnableVpcClassicLinkDnsSupportInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -35998,14 +36278,14 @@ func (m *awsEc2query_serializeOpExportImage) HandleSerialize(ctx context.Context return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpExportTransitGatewayRoutes struct { +type awsEc2query_serializeOpExportClientVpnClientCertificateRevocationList struct { } -func (*awsEc2query_serializeOpExportTransitGatewayRoutes) ID() string { +func (*awsEc2query_serializeOpExportClientVpnClientCertificateRevocationList) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpExportTransitGatewayRoutes) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpExportClientVpnClientCertificateRevocationList) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -36017,7 +36297,7 @@ func (m *awsEc2query_serializeOpExportTransitGatewayRoutes) HandleSerialize(ctx return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ExportTransitGatewayRoutesInput) + input, ok := in.Parameters.(*ExportClientVpnClientCertificateRevocationListInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -36042,10 +36322,10 @@ func (m *awsEc2query_serializeOpExportTransitGatewayRoutes) HandleSerialize(ctx bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("ExportTransitGatewayRoutes") + body.Key("Action").String("ExportClientVpnClientCertificateRevocationList") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentExportTransitGatewayRoutesInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentExportClientVpnClientCertificateRevocationListInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -36068,14 +36348,14 @@ func (m *awsEc2query_serializeOpExportTransitGatewayRoutes) HandleSerialize(ctx return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpExportVerifiedAccessInstanceClientConfiguration struct { +type awsEc2query_serializeOpExportClientVpnClientConfiguration struct { } -func (*awsEc2query_serializeOpExportVerifiedAccessInstanceClientConfiguration) ID() string { +func (*awsEc2query_serializeOpExportClientVpnClientConfiguration) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpExportVerifiedAccessInstanceClientConfiguration) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpExportClientVpnClientConfiguration) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -36087,7 +36367,7 @@ func (m *awsEc2query_serializeOpExportVerifiedAccessInstanceClientConfiguration) return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ExportVerifiedAccessInstanceClientConfigurationInput) + input, ok := in.Parameters.(*ExportClientVpnClientConfigurationInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -36112,10 +36392,10 @@ func (m *awsEc2query_serializeOpExportVerifiedAccessInstanceClientConfiguration) bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("ExportVerifiedAccessInstanceClientConfiguration") + body.Key("Action").String("ExportClientVpnClientConfiguration") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentExportVerifiedAccessInstanceClientConfigurationInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentExportClientVpnClientConfigurationInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -36138,14 +36418,14 @@ func (m *awsEc2query_serializeOpExportVerifiedAccessInstanceClientConfiguration) return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpGetActiveVpnTunnelStatus struct { +type awsEc2query_serializeOpExportImage struct { } -func (*awsEc2query_serializeOpGetActiveVpnTunnelStatus) ID() string { +func (*awsEc2query_serializeOpExportImage) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpGetActiveVpnTunnelStatus) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpExportImage) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -36157,7 +36437,7 @@ func (m *awsEc2query_serializeOpGetActiveVpnTunnelStatus) HandleSerialize(ctx co return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*GetActiveVpnTunnelStatusInput) + input, ok := in.Parameters.(*ExportImageInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -36182,10 +36462,10 @@ func (m *awsEc2query_serializeOpGetActiveVpnTunnelStatus) HandleSerialize(ctx co bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("GetActiveVpnTunnelStatus") + body.Key("Action").String("ExportImage") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentGetActiveVpnTunnelStatusInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentExportImageInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -36208,14 +36488,14 @@ func (m *awsEc2query_serializeOpGetActiveVpnTunnelStatus) HandleSerialize(ctx co return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpGetAllowedImagesSettings struct { +type awsEc2query_serializeOpExportTransitGatewayRoutes struct { } -func (*awsEc2query_serializeOpGetAllowedImagesSettings) ID() string { +func (*awsEc2query_serializeOpExportTransitGatewayRoutes) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpGetAllowedImagesSettings) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpExportTransitGatewayRoutes) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -36227,7 +36507,7 @@ func (m *awsEc2query_serializeOpGetAllowedImagesSettings) HandleSerialize(ctx co return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*GetAllowedImagesSettingsInput) + input, ok := in.Parameters.(*ExportTransitGatewayRoutesInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -36252,10 +36532,10 @@ func (m *awsEc2query_serializeOpGetAllowedImagesSettings) HandleSerialize(ctx co bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("GetAllowedImagesSettings") + body.Key("Action").String("ExportTransitGatewayRoutes") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentGetAllowedImagesSettingsInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentExportTransitGatewayRoutesInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -36278,14 +36558,14 @@ func (m *awsEc2query_serializeOpGetAllowedImagesSettings) HandleSerialize(ctx co return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpGetAssociatedEnclaveCertificateIamRoles struct { +type awsEc2query_serializeOpExportVerifiedAccessInstanceClientConfiguration struct { } -func (*awsEc2query_serializeOpGetAssociatedEnclaveCertificateIamRoles) ID() string { +func (*awsEc2query_serializeOpExportVerifiedAccessInstanceClientConfiguration) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpGetAssociatedEnclaveCertificateIamRoles) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpExportVerifiedAccessInstanceClientConfiguration) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -36297,7 +36577,7 @@ func (m *awsEc2query_serializeOpGetAssociatedEnclaveCertificateIamRoles) HandleS return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*GetAssociatedEnclaveCertificateIamRolesInput) + input, ok := in.Parameters.(*ExportVerifiedAccessInstanceClientConfigurationInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -36322,10 +36602,10 @@ func (m *awsEc2query_serializeOpGetAssociatedEnclaveCertificateIamRoles) HandleS bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("GetAssociatedEnclaveCertificateIamRoles") + body.Key("Action").String("ExportVerifiedAccessInstanceClientConfiguration") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentGetAssociatedEnclaveCertificateIamRolesInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentExportVerifiedAccessInstanceClientConfigurationInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -36348,14 +36628,14 @@ func (m *awsEc2query_serializeOpGetAssociatedEnclaveCertificateIamRoles) HandleS return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpGetAssociatedIpv6PoolCidrs struct { +type awsEc2query_serializeOpGetActiveVpnTunnelStatus struct { } -func (*awsEc2query_serializeOpGetAssociatedIpv6PoolCidrs) ID() string { +func (*awsEc2query_serializeOpGetActiveVpnTunnelStatus) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpGetAssociatedIpv6PoolCidrs) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpGetActiveVpnTunnelStatus) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -36367,7 +36647,7 @@ func (m *awsEc2query_serializeOpGetAssociatedIpv6PoolCidrs) HandleSerialize(ctx return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*GetAssociatedIpv6PoolCidrsInput) + input, ok := in.Parameters.(*GetActiveVpnTunnelStatusInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -36392,10 +36672,10 @@ func (m *awsEc2query_serializeOpGetAssociatedIpv6PoolCidrs) HandleSerialize(ctx bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("GetAssociatedIpv6PoolCidrs") + body.Key("Action").String("GetActiveVpnTunnelStatus") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentGetAssociatedIpv6PoolCidrsInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentGetActiveVpnTunnelStatusInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -36418,14 +36698,14 @@ func (m *awsEc2query_serializeOpGetAssociatedIpv6PoolCidrs) HandleSerialize(ctx return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpGetAwsNetworkPerformanceData struct { +type awsEc2query_serializeOpGetAllowedImagesSettings struct { } -func (*awsEc2query_serializeOpGetAwsNetworkPerformanceData) ID() string { +func (*awsEc2query_serializeOpGetAllowedImagesSettings) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpGetAwsNetworkPerformanceData) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpGetAllowedImagesSettings) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -36437,7 +36717,7 @@ func (m *awsEc2query_serializeOpGetAwsNetworkPerformanceData) HandleSerialize(ct return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*GetAwsNetworkPerformanceDataInput) + input, ok := in.Parameters.(*GetAllowedImagesSettingsInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -36462,10 +36742,10 @@ func (m *awsEc2query_serializeOpGetAwsNetworkPerformanceData) HandleSerialize(ct bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("GetAwsNetworkPerformanceData") + body.Key("Action").String("GetAllowedImagesSettings") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentGetAwsNetworkPerformanceDataInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentGetAllowedImagesSettingsInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -36488,14 +36768,14 @@ func (m *awsEc2query_serializeOpGetAwsNetworkPerformanceData) HandleSerialize(ct return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpGetCapacityManagerAttributes struct { +type awsEc2query_serializeOpGetAssociatedEnclaveCertificateIamRoles struct { } -func (*awsEc2query_serializeOpGetCapacityManagerAttributes) ID() string { +func (*awsEc2query_serializeOpGetAssociatedEnclaveCertificateIamRoles) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpGetCapacityManagerAttributes) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpGetAssociatedEnclaveCertificateIamRoles) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -36507,7 +36787,7 @@ func (m *awsEc2query_serializeOpGetCapacityManagerAttributes) HandleSerialize(ct return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*GetCapacityManagerAttributesInput) + input, ok := in.Parameters.(*GetAssociatedEnclaveCertificateIamRolesInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -36532,10 +36812,10 @@ func (m *awsEc2query_serializeOpGetCapacityManagerAttributes) HandleSerialize(ct bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("GetCapacityManagerAttributes") + body.Key("Action").String("GetAssociatedEnclaveCertificateIamRoles") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentGetCapacityManagerAttributesInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentGetAssociatedEnclaveCertificateIamRolesInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -36558,14 +36838,14 @@ func (m *awsEc2query_serializeOpGetCapacityManagerAttributes) HandleSerialize(ct return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpGetCapacityManagerMetricData struct { +type awsEc2query_serializeOpGetAssociatedIpv6PoolCidrs struct { } -func (*awsEc2query_serializeOpGetCapacityManagerMetricData) ID() string { +func (*awsEc2query_serializeOpGetAssociatedIpv6PoolCidrs) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpGetCapacityManagerMetricData) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpGetAssociatedIpv6PoolCidrs) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -36577,7 +36857,7 @@ func (m *awsEc2query_serializeOpGetCapacityManagerMetricData) HandleSerialize(ct return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*GetCapacityManagerMetricDataInput) + input, ok := in.Parameters.(*GetAssociatedIpv6PoolCidrsInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -36602,10 +36882,10 @@ func (m *awsEc2query_serializeOpGetCapacityManagerMetricData) HandleSerialize(ct bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("GetCapacityManagerMetricData") + body.Key("Action").String("GetAssociatedIpv6PoolCidrs") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentGetCapacityManagerMetricDataInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentGetAssociatedIpv6PoolCidrsInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -36628,14 +36908,14 @@ func (m *awsEc2query_serializeOpGetCapacityManagerMetricData) HandleSerialize(ct return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpGetCapacityManagerMetricDimensions struct { +type awsEc2query_serializeOpGetAwsNetworkPerformanceData struct { } -func (*awsEc2query_serializeOpGetCapacityManagerMetricDimensions) ID() string { +func (*awsEc2query_serializeOpGetAwsNetworkPerformanceData) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpGetCapacityManagerMetricDimensions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpGetAwsNetworkPerformanceData) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -36647,7 +36927,7 @@ func (m *awsEc2query_serializeOpGetCapacityManagerMetricDimensions) HandleSerial return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*GetCapacityManagerMetricDimensionsInput) + input, ok := in.Parameters.(*GetAwsNetworkPerformanceDataInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -36672,10 +36952,10 @@ func (m *awsEc2query_serializeOpGetCapacityManagerMetricDimensions) HandleSerial bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("GetCapacityManagerMetricDimensions") + body.Key("Action").String("GetAwsNetworkPerformanceData") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentGetCapacityManagerMetricDimensionsInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentGetAwsNetworkPerformanceDataInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -36698,14 +36978,14 @@ func (m *awsEc2query_serializeOpGetCapacityManagerMetricDimensions) HandleSerial return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpGetCapacityReservationUsage struct { +type awsEc2query_serializeOpGetCapacityManagerAttributes struct { } -func (*awsEc2query_serializeOpGetCapacityReservationUsage) ID() string { +func (*awsEc2query_serializeOpGetCapacityManagerAttributes) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpGetCapacityReservationUsage) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpGetCapacityManagerAttributes) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -36717,7 +36997,7 @@ func (m *awsEc2query_serializeOpGetCapacityReservationUsage) HandleSerialize(ctx return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*GetCapacityReservationUsageInput) + input, ok := in.Parameters.(*GetCapacityManagerAttributesInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -36742,10 +37022,10 @@ func (m *awsEc2query_serializeOpGetCapacityReservationUsage) HandleSerialize(ctx bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("GetCapacityReservationUsage") + body.Key("Action").String("GetCapacityManagerAttributes") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentGetCapacityReservationUsageInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentGetCapacityManagerAttributesInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -36768,14 +37048,14 @@ func (m *awsEc2query_serializeOpGetCapacityReservationUsage) HandleSerialize(ctx return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpGetCoipPoolUsage struct { +type awsEc2query_serializeOpGetCapacityManagerMetricData struct { } -func (*awsEc2query_serializeOpGetCoipPoolUsage) ID() string { +func (*awsEc2query_serializeOpGetCapacityManagerMetricData) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpGetCoipPoolUsage) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpGetCapacityManagerMetricData) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -36787,7 +37067,7 @@ func (m *awsEc2query_serializeOpGetCoipPoolUsage) HandleSerialize(ctx context.Co return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*GetCoipPoolUsageInput) + input, ok := in.Parameters.(*GetCapacityManagerMetricDataInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -36812,10 +37092,10 @@ func (m *awsEc2query_serializeOpGetCoipPoolUsage) HandleSerialize(ctx context.Co bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("GetCoipPoolUsage") + body.Key("Action").String("GetCapacityManagerMetricData") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentGetCoipPoolUsageInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentGetCapacityManagerMetricDataInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -36838,14 +37118,14 @@ func (m *awsEc2query_serializeOpGetCoipPoolUsage) HandleSerialize(ctx context.Co return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpGetConsoleOutput struct { +type awsEc2query_serializeOpGetCapacityManagerMetricDimensions struct { } -func (*awsEc2query_serializeOpGetConsoleOutput) ID() string { +func (*awsEc2query_serializeOpGetCapacityManagerMetricDimensions) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpGetConsoleOutput) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpGetCapacityManagerMetricDimensions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -36857,7 +37137,7 @@ func (m *awsEc2query_serializeOpGetConsoleOutput) HandleSerialize(ctx context.Co return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*GetConsoleOutputInput) + input, ok := in.Parameters.(*GetCapacityManagerMetricDimensionsInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -36882,10 +37162,10 @@ func (m *awsEc2query_serializeOpGetConsoleOutput) HandleSerialize(ctx context.Co bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("GetConsoleOutput") + body.Key("Action").String("GetCapacityManagerMetricDimensions") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentGetConsoleOutputInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentGetCapacityManagerMetricDimensionsInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -36908,14 +37188,14 @@ func (m *awsEc2query_serializeOpGetConsoleOutput) HandleSerialize(ctx context.Co return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpGetConsoleScreenshot struct { +type awsEc2query_serializeOpGetCapacityReservationUsage struct { } -func (*awsEc2query_serializeOpGetConsoleScreenshot) ID() string { +func (*awsEc2query_serializeOpGetCapacityReservationUsage) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpGetConsoleScreenshot) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpGetCapacityReservationUsage) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -36927,7 +37207,7 @@ func (m *awsEc2query_serializeOpGetConsoleScreenshot) HandleSerialize(ctx contex return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*GetConsoleScreenshotInput) + input, ok := in.Parameters.(*GetCapacityReservationUsageInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -36952,10 +37232,10 @@ func (m *awsEc2query_serializeOpGetConsoleScreenshot) HandleSerialize(ctx contex bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("GetConsoleScreenshot") + body.Key("Action").String("GetCapacityReservationUsage") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentGetConsoleScreenshotInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentGetCapacityReservationUsageInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -36978,14 +37258,14 @@ func (m *awsEc2query_serializeOpGetConsoleScreenshot) HandleSerialize(ctx contex return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpGetDeclarativePoliciesReportSummary struct { +type awsEc2query_serializeOpGetCoipPoolUsage struct { } -func (*awsEc2query_serializeOpGetDeclarativePoliciesReportSummary) ID() string { +func (*awsEc2query_serializeOpGetCoipPoolUsage) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpGetDeclarativePoliciesReportSummary) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpGetCoipPoolUsage) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -36997,7 +37277,7 @@ func (m *awsEc2query_serializeOpGetDeclarativePoliciesReportSummary) HandleSeria return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*GetDeclarativePoliciesReportSummaryInput) + input, ok := in.Parameters.(*GetCoipPoolUsageInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -37022,10 +37302,10 @@ func (m *awsEc2query_serializeOpGetDeclarativePoliciesReportSummary) HandleSeria bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("GetDeclarativePoliciesReportSummary") + body.Key("Action").String("GetCoipPoolUsage") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentGetDeclarativePoliciesReportSummaryInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentGetCoipPoolUsageInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -37048,14 +37328,14 @@ func (m *awsEc2query_serializeOpGetDeclarativePoliciesReportSummary) HandleSeria return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpGetDefaultCreditSpecification struct { +type awsEc2query_serializeOpGetConsoleOutput struct { } -func (*awsEc2query_serializeOpGetDefaultCreditSpecification) ID() string { +func (*awsEc2query_serializeOpGetConsoleOutput) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpGetDefaultCreditSpecification) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpGetConsoleOutput) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -37067,7 +37347,7 @@ func (m *awsEc2query_serializeOpGetDefaultCreditSpecification) HandleSerialize(c return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*GetDefaultCreditSpecificationInput) + input, ok := in.Parameters.(*GetConsoleOutputInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -37092,10 +37372,10 @@ func (m *awsEc2query_serializeOpGetDefaultCreditSpecification) HandleSerialize(c bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("GetDefaultCreditSpecification") + body.Key("Action").String("GetConsoleOutput") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentGetDefaultCreditSpecificationInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentGetConsoleOutputInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -37118,14 +37398,14 @@ func (m *awsEc2query_serializeOpGetDefaultCreditSpecification) HandleSerialize(c return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpGetEbsDefaultKmsKeyId struct { +type awsEc2query_serializeOpGetConsoleScreenshot struct { } -func (*awsEc2query_serializeOpGetEbsDefaultKmsKeyId) ID() string { +func (*awsEc2query_serializeOpGetConsoleScreenshot) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpGetEbsDefaultKmsKeyId) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpGetConsoleScreenshot) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -37137,7 +37417,7 @@ func (m *awsEc2query_serializeOpGetEbsDefaultKmsKeyId) HandleSerialize(ctx conte return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*GetEbsDefaultKmsKeyIdInput) + input, ok := in.Parameters.(*GetConsoleScreenshotInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -37162,10 +37442,10 @@ func (m *awsEc2query_serializeOpGetEbsDefaultKmsKeyId) HandleSerialize(ctx conte bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("GetEbsDefaultKmsKeyId") + body.Key("Action").String("GetConsoleScreenshot") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentGetEbsDefaultKmsKeyIdInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentGetConsoleScreenshotInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -37188,14 +37468,14 @@ func (m *awsEc2query_serializeOpGetEbsDefaultKmsKeyId) HandleSerialize(ctx conte return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpGetEbsEncryptionByDefault struct { +type awsEc2query_serializeOpGetDeclarativePoliciesReportSummary struct { } -func (*awsEc2query_serializeOpGetEbsEncryptionByDefault) ID() string { +func (*awsEc2query_serializeOpGetDeclarativePoliciesReportSummary) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpGetEbsEncryptionByDefault) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpGetDeclarativePoliciesReportSummary) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -37207,7 +37487,7 @@ func (m *awsEc2query_serializeOpGetEbsEncryptionByDefault) HandleSerialize(ctx c return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*GetEbsEncryptionByDefaultInput) + input, ok := in.Parameters.(*GetDeclarativePoliciesReportSummaryInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -37232,10 +37512,10 @@ func (m *awsEc2query_serializeOpGetEbsEncryptionByDefault) HandleSerialize(ctx c bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("GetEbsEncryptionByDefault") + body.Key("Action").String("GetDeclarativePoliciesReportSummary") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentGetEbsEncryptionByDefaultInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentGetDeclarativePoliciesReportSummaryInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -37258,14 +37538,14 @@ func (m *awsEc2query_serializeOpGetEbsEncryptionByDefault) HandleSerialize(ctx c return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpGetEnabledIpamPolicy struct { +type awsEc2query_serializeOpGetDefaultCreditSpecification struct { } -func (*awsEc2query_serializeOpGetEnabledIpamPolicy) ID() string { +func (*awsEc2query_serializeOpGetDefaultCreditSpecification) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpGetEnabledIpamPolicy) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpGetDefaultCreditSpecification) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -37277,7 +37557,7 @@ func (m *awsEc2query_serializeOpGetEnabledIpamPolicy) HandleSerialize(ctx contex return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*GetEnabledIpamPolicyInput) + input, ok := in.Parameters.(*GetDefaultCreditSpecificationInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -37302,10 +37582,10 @@ func (m *awsEc2query_serializeOpGetEnabledIpamPolicy) HandleSerialize(ctx contex bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("GetEnabledIpamPolicy") + body.Key("Action").String("GetDefaultCreditSpecification") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentGetEnabledIpamPolicyInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentGetDefaultCreditSpecificationInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -37328,14 +37608,14 @@ func (m *awsEc2query_serializeOpGetEnabledIpamPolicy) HandleSerialize(ctx contex return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpGetFlowLogsIntegrationTemplate struct { +type awsEc2query_serializeOpGetEbsDefaultKmsKeyId struct { } -func (*awsEc2query_serializeOpGetFlowLogsIntegrationTemplate) ID() string { +func (*awsEc2query_serializeOpGetEbsDefaultKmsKeyId) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpGetFlowLogsIntegrationTemplate) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpGetEbsDefaultKmsKeyId) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -37347,7 +37627,7 @@ func (m *awsEc2query_serializeOpGetFlowLogsIntegrationTemplate) HandleSerialize( return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*GetFlowLogsIntegrationTemplateInput) + input, ok := in.Parameters.(*GetEbsDefaultKmsKeyIdInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -37372,10 +37652,10 @@ func (m *awsEc2query_serializeOpGetFlowLogsIntegrationTemplate) HandleSerialize( bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("GetFlowLogsIntegrationTemplate") + body.Key("Action").String("GetEbsDefaultKmsKeyId") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentGetFlowLogsIntegrationTemplateInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentGetEbsDefaultKmsKeyIdInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -37398,14 +37678,14 @@ func (m *awsEc2query_serializeOpGetFlowLogsIntegrationTemplate) HandleSerialize( return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpGetGroupsForCapacityReservation struct { +type awsEc2query_serializeOpGetEbsEncryptionByDefault struct { } -func (*awsEc2query_serializeOpGetGroupsForCapacityReservation) ID() string { +func (*awsEc2query_serializeOpGetEbsEncryptionByDefault) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpGetGroupsForCapacityReservation) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpGetEbsEncryptionByDefault) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -37417,7 +37697,7 @@ func (m *awsEc2query_serializeOpGetGroupsForCapacityReservation) HandleSerialize return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*GetGroupsForCapacityReservationInput) + input, ok := in.Parameters.(*GetEbsEncryptionByDefaultInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -37442,10 +37722,10 @@ func (m *awsEc2query_serializeOpGetGroupsForCapacityReservation) HandleSerialize bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("GetGroupsForCapacityReservation") + body.Key("Action").String("GetEbsEncryptionByDefault") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentGetGroupsForCapacityReservationInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentGetEbsEncryptionByDefaultInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -37468,14 +37748,14 @@ func (m *awsEc2query_serializeOpGetGroupsForCapacityReservation) HandleSerialize return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpGetHostReservationPurchasePreview struct { +type awsEc2query_serializeOpGetEnabledIpamPolicy struct { } -func (*awsEc2query_serializeOpGetHostReservationPurchasePreview) ID() string { +func (*awsEc2query_serializeOpGetEnabledIpamPolicy) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpGetHostReservationPurchasePreview) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpGetEnabledIpamPolicy) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -37487,7 +37767,7 @@ func (m *awsEc2query_serializeOpGetHostReservationPurchasePreview) HandleSeriali return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*GetHostReservationPurchasePreviewInput) + input, ok := in.Parameters.(*GetEnabledIpamPolicyInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -37512,10 +37792,10 @@ func (m *awsEc2query_serializeOpGetHostReservationPurchasePreview) HandleSeriali bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("GetHostReservationPurchasePreview") + body.Key("Action").String("GetEnabledIpamPolicy") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentGetHostReservationPurchasePreviewInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentGetEnabledIpamPolicyInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -37538,14 +37818,14 @@ func (m *awsEc2query_serializeOpGetHostReservationPurchasePreview) HandleSeriali return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpGetImageAncestry struct { +type awsEc2query_serializeOpGetFlowLogsIntegrationTemplate struct { } -func (*awsEc2query_serializeOpGetImageAncestry) ID() string { +func (*awsEc2query_serializeOpGetFlowLogsIntegrationTemplate) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpGetImageAncestry) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpGetFlowLogsIntegrationTemplate) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -37557,7 +37837,7 @@ func (m *awsEc2query_serializeOpGetImageAncestry) HandleSerialize(ctx context.Co return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*GetImageAncestryInput) + input, ok := in.Parameters.(*GetFlowLogsIntegrationTemplateInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -37582,10 +37862,10 @@ func (m *awsEc2query_serializeOpGetImageAncestry) HandleSerialize(ctx context.Co bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("GetImageAncestry") + body.Key("Action").String("GetFlowLogsIntegrationTemplate") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentGetImageAncestryInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentGetFlowLogsIntegrationTemplateInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -37608,14 +37888,14 @@ func (m *awsEc2query_serializeOpGetImageAncestry) HandleSerialize(ctx context.Co return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpGetImageBlockPublicAccessState struct { +type awsEc2query_serializeOpGetGroupsForCapacityReservation struct { } -func (*awsEc2query_serializeOpGetImageBlockPublicAccessState) ID() string { +func (*awsEc2query_serializeOpGetGroupsForCapacityReservation) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpGetImageBlockPublicAccessState) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpGetGroupsForCapacityReservation) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -37627,7 +37907,7 @@ func (m *awsEc2query_serializeOpGetImageBlockPublicAccessState) HandleSerialize( return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*GetImageBlockPublicAccessStateInput) + input, ok := in.Parameters.(*GetGroupsForCapacityReservationInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -37652,10 +37932,10 @@ func (m *awsEc2query_serializeOpGetImageBlockPublicAccessState) HandleSerialize( bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("GetImageBlockPublicAccessState") + body.Key("Action").String("GetGroupsForCapacityReservation") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentGetImageBlockPublicAccessStateInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentGetGroupsForCapacityReservationInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -37678,14 +37958,14 @@ func (m *awsEc2query_serializeOpGetImageBlockPublicAccessState) HandleSerialize( return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpGetInstanceMetadataDefaults struct { +type awsEc2query_serializeOpGetHostReservationPurchasePreview struct { } -func (*awsEc2query_serializeOpGetInstanceMetadataDefaults) ID() string { +func (*awsEc2query_serializeOpGetHostReservationPurchasePreview) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpGetInstanceMetadataDefaults) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpGetHostReservationPurchasePreview) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -37697,7 +37977,7 @@ func (m *awsEc2query_serializeOpGetInstanceMetadataDefaults) HandleSerialize(ctx return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*GetInstanceMetadataDefaultsInput) + input, ok := in.Parameters.(*GetHostReservationPurchasePreviewInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -37722,10 +38002,10 @@ func (m *awsEc2query_serializeOpGetInstanceMetadataDefaults) HandleSerialize(ctx bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("GetInstanceMetadataDefaults") + body.Key("Action").String("GetHostReservationPurchasePreview") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentGetInstanceMetadataDefaultsInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentGetHostReservationPurchasePreviewInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -37748,14 +38028,14 @@ func (m *awsEc2query_serializeOpGetInstanceMetadataDefaults) HandleSerialize(ctx return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpGetInstanceTpmEkPub struct { +type awsEc2query_serializeOpGetImageAncestry struct { } -func (*awsEc2query_serializeOpGetInstanceTpmEkPub) ID() string { +func (*awsEc2query_serializeOpGetImageAncestry) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpGetInstanceTpmEkPub) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpGetImageAncestry) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -37767,7 +38047,7 @@ func (m *awsEc2query_serializeOpGetInstanceTpmEkPub) HandleSerialize(ctx context return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*GetInstanceTpmEkPubInput) + input, ok := in.Parameters.(*GetImageAncestryInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -37792,10 +38072,10 @@ func (m *awsEc2query_serializeOpGetInstanceTpmEkPub) HandleSerialize(ctx context bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("GetInstanceTpmEkPub") + body.Key("Action").String("GetImageAncestry") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentGetInstanceTpmEkPubInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentGetImageAncestryInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -37818,14 +38098,14 @@ func (m *awsEc2query_serializeOpGetInstanceTpmEkPub) HandleSerialize(ctx context return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpGetInstanceTypesFromInstanceRequirements struct { +type awsEc2query_serializeOpGetImageBlockPublicAccessState struct { } -func (*awsEc2query_serializeOpGetInstanceTypesFromInstanceRequirements) ID() string { +func (*awsEc2query_serializeOpGetImageBlockPublicAccessState) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpGetInstanceTypesFromInstanceRequirements) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpGetImageBlockPublicAccessState) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -37837,7 +38117,7 @@ func (m *awsEc2query_serializeOpGetInstanceTypesFromInstanceRequirements) Handle return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*GetInstanceTypesFromInstanceRequirementsInput) + input, ok := in.Parameters.(*GetImageBlockPublicAccessStateInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -37862,10 +38142,10 @@ func (m *awsEc2query_serializeOpGetInstanceTypesFromInstanceRequirements) Handle bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("GetInstanceTypesFromInstanceRequirements") + body.Key("Action").String("GetImageBlockPublicAccessState") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentGetInstanceTypesFromInstanceRequirementsInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentGetImageBlockPublicAccessStateInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -37888,14 +38168,14 @@ func (m *awsEc2query_serializeOpGetInstanceTypesFromInstanceRequirements) Handle return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpGetInstanceUefiData struct { +type awsEc2query_serializeOpGetInstanceMetadataDefaults struct { } -func (*awsEc2query_serializeOpGetInstanceUefiData) ID() string { +func (*awsEc2query_serializeOpGetInstanceMetadataDefaults) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpGetInstanceUefiData) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpGetInstanceMetadataDefaults) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -37907,7 +38187,7 @@ func (m *awsEc2query_serializeOpGetInstanceUefiData) HandleSerialize(ctx context return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*GetInstanceUefiDataInput) + input, ok := in.Parameters.(*GetInstanceMetadataDefaultsInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -37932,10 +38212,10 @@ func (m *awsEc2query_serializeOpGetInstanceUefiData) HandleSerialize(ctx context bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("GetInstanceUefiData") + body.Key("Action").String("GetInstanceMetadataDefaults") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentGetInstanceUefiDataInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentGetInstanceMetadataDefaultsInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -37958,14 +38238,14 @@ func (m *awsEc2query_serializeOpGetInstanceUefiData) HandleSerialize(ctx context return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpGetIpamAddressHistory struct { +type awsEc2query_serializeOpGetInstanceTpmEkPub struct { } -func (*awsEc2query_serializeOpGetIpamAddressHistory) ID() string { +func (*awsEc2query_serializeOpGetInstanceTpmEkPub) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpGetIpamAddressHistory) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpGetInstanceTpmEkPub) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -37977,7 +38257,7 @@ func (m *awsEc2query_serializeOpGetIpamAddressHistory) HandleSerialize(ctx conte return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*GetIpamAddressHistoryInput) + input, ok := in.Parameters.(*GetInstanceTpmEkPubInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -38002,10 +38282,10 @@ func (m *awsEc2query_serializeOpGetIpamAddressHistory) HandleSerialize(ctx conte bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("GetIpamAddressHistory") + body.Key("Action").String("GetInstanceTpmEkPub") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentGetIpamAddressHistoryInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentGetInstanceTpmEkPubInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -38028,14 +38308,14 @@ func (m *awsEc2query_serializeOpGetIpamAddressHistory) HandleSerialize(ctx conte return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpGetIpamDiscoveredAccounts struct { +type awsEc2query_serializeOpGetInstanceTypesFromInstanceRequirements struct { } -func (*awsEc2query_serializeOpGetIpamDiscoveredAccounts) ID() string { +func (*awsEc2query_serializeOpGetInstanceTypesFromInstanceRequirements) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpGetIpamDiscoveredAccounts) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpGetInstanceTypesFromInstanceRequirements) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -38047,7 +38327,7 @@ func (m *awsEc2query_serializeOpGetIpamDiscoveredAccounts) HandleSerialize(ctx c return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*GetIpamDiscoveredAccountsInput) + input, ok := in.Parameters.(*GetInstanceTypesFromInstanceRequirementsInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -38072,10 +38352,10 @@ func (m *awsEc2query_serializeOpGetIpamDiscoveredAccounts) HandleSerialize(ctx c bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("GetIpamDiscoveredAccounts") + body.Key("Action").String("GetInstanceTypesFromInstanceRequirements") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentGetIpamDiscoveredAccountsInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentGetInstanceTypesFromInstanceRequirementsInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -38098,14 +38378,14 @@ func (m *awsEc2query_serializeOpGetIpamDiscoveredAccounts) HandleSerialize(ctx c return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpGetIpamDiscoveredPublicAddresses struct { +type awsEc2query_serializeOpGetInstanceUefiData struct { } -func (*awsEc2query_serializeOpGetIpamDiscoveredPublicAddresses) ID() string { +func (*awsEc2query_serializeOpGetInstanceUefiData) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpGetIpamDiscoveredPublicAddresses) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpGetInstanceUefiData) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -38117,7 +38397,7 @@ func (m *awsEc2query_serializeOpGetIpamDiscoveredPublicAddresses) HandleSerializ return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*GetIpamDiscoveredPublicAddressesInput) + input, ok := in.Parameters.(*GetInstanceUefiDataInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -38142,10 +38422,10 @@ func (m *awsEc2query_serializeOpGetIpamDiscoveredPublicAddresses) HandleSerializ bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("GetIpamDiscoveredPublicAddresses") + body.Key("Action").String("GetInstanceUefiData") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentGetIpamDiscoveredPublicAddressesInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentGetInstanceUefiDataInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -38168,14 +38448,14 @@ func (m *awsEc2query_serializeOpGetIpamDiscoveredPublicAddresses) HandleSerializ return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpGetIpamDiscoveredResourceCidrs struct { +type awsEc2query_serializeOpGetIpamAddressHistory struct { } -func (*awsEc2query_serializeOpGetIpamDiscoveredResourceCidrs) ID() string { +func (*awsEc2query_serializeOpGetIpamAddressHistory) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpGetIpamDiscoveredResourceCidrs) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpGetIpamAddressHistory) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -38187,7 +38467,7 @@ func (m *awsEc2query_serializeOpGetIpamDiscoveredResourceCidrs) HandleSerialize( return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*GetIpamDiscoveredResourceCidrsInput) + input, ok := in.Parameters.(*GetIpamAddressHistoryInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -38212,10 +38492,10 @@ func (m *awsEc2query_serializeOpGetIpamDiscoveredResourceCidrs) HandleSerialize( bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("GetIpamDiscoveredResourceCidrs") + body.Key("Action").String("GetIpamAddressHistory") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentGetIpamDiscoveredResourceCidrsInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentGetIpamAddressHistoryInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -38238,14 +38518,14 @@ func (m *awsEc2query_serializeOpGetIpamDiscoveredResourceCidrs) HandleSerialize( return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpGetIpamPolicyAllocationRules struct { +type awsEc2query_serializeOpGetIpamDiscoveredAccounts struct { } -func (*awsEc2query_serializeOpGetIpamPolicyAllocationRules) ID() string { +func (*awsEc2query_serializeOpGetIpamDiscoveredAccounts) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpGetIpamPolicyAllocationRules) 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, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -38257,7 +38537,7 @@ func (m *awsEc2query_serializeOpGetIpamPolicyAllocationRules) HandleSerialize(ct return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*GetIpamPolicyAllocationRulesInput) + input, ok := in.Parameters.(*GetIpamDiscoveredAccountsInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -38282,10 +38562,10 @@ func (m *awsEc2query_serializeOpGetIpamPolicyAllocationRules) HandleSerialize(ct bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("GetIpamPolicyAllocationRules") + body.Key("Action").String("GetIpamDiscoveredAccounts") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentGetIpamPolicyAllocationRulesInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentGetIpamDiscoveredAccountsInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -38308,14 +38588,14 @@ func (m *awsEc2query_serializeOpGetIpamPolicyAllocationRules) HandleSerialize(ct return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpGetIpamPolicyOrganizationTargets struct { +type awsEc2query_serializeOpGetIpamDiscoveredPublicAddresses struct { } -func (*awsEc2query_serializeOpGetIpamPolicyOrganizationTargets) ID() string { +func (*awsEc2query_serializeOpGetIpamDiscoveredPublicAddresses) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpGetIpamPolicyOrganizationTargets) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpGetIpamDiscoveredPublicAddresses) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -38327,7 +38607,7 @@ func (m *awsEc2query_serializeOpGetIpamPolicyOrganizationTargets) HandleSerializ return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*GetIpamPolicyOrganizationTargetsInput) + input, ok := in.Parameters.(*GetIpamDiscoveredPublicAddressesInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -38352,10 +38632,10 @@ func (m *awsEc2query_serializeOpGetIpamPolicyOrganizationTargets) HandleSerializ bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("GetIpamPolicyOrganizationTargets") + body.Key("Action").String("GetIpamDiscoveredPublicAddresses") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentGetIpamPolicyOrganizationTargetsInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentGetIpamDiscoveredPublicAddressesInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -38378,14 +38658,14 @@ func (m *awsEc2query_serializeOpGetIpamPolicyOrganizationTargets) HandleSerializ return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpGetIpamPoolAllocations struct { +type awsEc2query_serializeOpGetIpamDiscoveredResourceCidrs struct { } -func (*awsEc2query_serializeOpGetIpamPoolAllocations) ID() string { +func (*awsEc2query_serializeOpGetIpamDiscoveredResourceCidrs) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpGetIpamPoolAllocations) 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, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -38397,7 +38677,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.(*GetIpamDiscoveredResourceCidrsInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -38422,10 +38702,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("GetIpamDiscoveredResourceCidrs") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentGetIpamPoolAllocationsInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentGetIpamDiscoveredResourceCidrsInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -38448,14 +38728,14 @@ func (m *awsEc2query_serializeOpGetIpamPoolAllocations) HandleSerialize(ctx cont return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpGetIpamPoolCidrs struct { +type awsEc2query_serializeOpGetIpamPolicyAllocationRules struct { } -func (*awsEc2query_serializeOpGetIpamPoolCidrs) ID() string { +func (*awsEc2query_serializeOpGetIpamPolicyAllocationRules) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpGetIpamPoolCidrs) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpGetIpamPolicyAllocationRules) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -38467,7 +38747,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.(*GetIpamPolicyAllocationRulesInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -38492,10 +38772,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("GetIpamPolicyAllocationRules") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentGetIpamPoolCidrsInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentGetIpamPolicyAllocationRulesInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -38518,14 +38798,14 @@ func (m *awsEc2query_serializeOpGetIpamPoolCidrs) HandleSerialize(ctx context.Co return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpGetIpamPrefixListResolverRules struct { +type awsEc2query_serializeOpGetIpamPolicyOrganizationTargets struct { } -func (*awsEc2query_serializeOpGetIpamPrefixListResolverRules) ID() string { +func (*awsEc2query_serializeOpGetIpamPolicyOrganizationTargets) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpGetIpamPrefixListResolverRules) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpGetIpamPolicyOrganizationTargets) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -38537,7 +38817,7 @@ func (m *awsEc2query_serializeOpGetIpamPrefixListResolverRules) HandleSerialize( return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*GetIpamPrefixListResolverRulesInput) + input, ok := in.Parameters.(*GetIpamPolicyOrganizationTargetsInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -38562,10 +38842,10 @@ func (m *awsEc2query_serializeOpGetIpamPrefixListResolverRules) HandleSerialize( bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("GetIpamPrefixListResolverRules") + body.Key("Action").String("GetIpamPolicyOrganizationTargets") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentGetIpamPrefixListResolverRulesInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentGetIpamPolicyOrganizationTargetsInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -38588,14 +38868,14 @@ func (m *awsEc2query_serializeOpGetIpamPrefixListResolverRules) HandleSerialize( return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpGetIpamPrefixListResolverVersionEntries struct { +type awsEc2query_serializeOpGetIpamPoolAllocations struct { } -func (*awsEc2query_serializeOpGetIpamPrefixListResolverVersionEntries) ID() string { +func (*awsEc2query_serializeOpGetIpamPoolAllocations) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpGetIpamPrefixListResolverVersionEntries) 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, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -38607,7 +38887,7 @@ func (m *awsEc2query_serializeOpGetIpamPrefixListResolverVersionEntries) HandleS return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*GetIpamPrefixListResolverVersionEntriesInput) + input, ok := in.Parameters.(*GetIpamPoolAllocationsInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -38632,10 +38912,10 @@ func (m *awsEc2query_serializeOpGetIpamPrefixListResolverVersionEntries) HandleS bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("GetIpamPrefixListResolverVersionEntries") + body.Key("Action").String("GetIpamPoolAllocations") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentGetIpamPrefixListResolverVersionEntriesInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentGetIpamPoolAllocationsInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -38658,14 +38938,14 @@ func (m *awsEc2query_serializeOpGetIpamPrefixListResolverVersionEntries) HandleS return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpGetIpamPrefixListResolverVersions struct { +type awsEc2query_serializeOpGetIpamPoolCidrs struct { } -func (*awsEc2query_serializeOpGetIpamPrefixListResolverVersions) ID() string { +func (*awsEc2query_serializeOpGetIpamPoolCidrs) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpGetIpamPrefixListResolverVersions) 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, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -38677,7 +38957,7 @@ func (m *awsEc2query_serializeOpGetIpamPrefixListResolverVersions) HandleSeriali return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*GetIpamPrefixListResolverVersionsInput) + input, ok := in.Parameters.(*GetIpamPoolCidrsInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -38702,10 +38982,10 @@ func (m *awsEc2query_serializeOpGetIpamPrefixListResolverVersions) HandleSeriali bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("GetIpamPrefixListResolverVersions") + body.Key("Action").String("GetIpamPoolCidrs") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentGetIpamPrefixListResolverVersionsInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentGetIpamPoolCidrsInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -38728,14 +39008,14 @@ func (m *awsEc2query_serializeOpGetIpamPrefixListResolverVersions) HandleSeriali return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpGetIpamResourceCidrs struct { +type awsEc2query_serializeOpGetIpamPrefixListResolverRules struct { } -func (*awsEc2query_serializeOpGetIpamResourceCidrs) ID() string { +func (*awsEc2query_serializeOpGetIpamPrefixListResolverRules) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpGetIpamResourceCidrs) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpGetIpamPrefixListResolverRules) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -38747,7 +39027,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.(*GetIpamPrefixListResolverRulesInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -38772,10 +39052,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("GetIpamPrefixListResolverRules") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentGetIpamResourceCidrsInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentGetIpamPrefixListResolverRulesInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -38798,14 +39078,14 @@ func (m *awsEc2query_serializeOpGetIpamResourceCidrs) HandleSerialize(ctx contex return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpGetLaunchTemplateData struct { +type awsEc2query_serializeOpGetIpamPrefixListResolverVersionEntries struct { } -func (*awsEc2query_serializeOpGetLaunchTemplateData) ID() string { +func (*awsEc2query_serializeOpGetIpamPrefixListResolverVersionEntries) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpGetLaunchTemplateData) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpGetIpamPrefixListResolverVersionEntries) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -38817,7 +39097,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.(*GetIpamPrefixListResolverVersionEntriesInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -38842,10 +39122,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("GetIpamPrefixListResolverVersionEntries") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentGetLaunchTemplateDataInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentGetIpamPrefixListResolverVersionEntriesInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -38868,14 +39148,14 @@ func (m *awsEc2query_serializeOpGetLaunchTemplateData) HandleSerialize(ctx conte return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpGetManagedPrefixListAssociations struct { +type awsEc2query_serializeOpGetIpamPrefixListResolverVersions struct { } -func (*awsEc2query_serializeOpGetManagedPrefixListAssociations) ID() string { +func (*awsEc2query_serializeOpGetIpamPrefixListResolverVersions) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpGetManagedPrefixListAssociations) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpGetIpamPrefixListResolverVersions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -38887,7 +39167,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.(*GetIpamPrefixListResolverVersionsInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -38912,10 +39192,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("GetIpamPrefixListResolverVersions") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentGetManagedPrefixListAssociationsInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentGetIpamPrefixListResolverVersionsInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -38938,14 +39218,14 @@ func (m *awsEc2query_serializeOpGetManagedPrefixListAssociations) HandleSerializ return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpGetManagedPrefixListEntries struct { +type awsEc2query_serializeOpGetIpamResourceCidrs struct { } -func (*awsEc2query_serializeOpGetManagedPrefixListEntries) ID() string { +func (*awsEc2query_serializeOpGetIpamResourceCidrs) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpGetManagedPrefixListEntries) 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, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -38957,7 +39237,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.(*GetIpamResourceCidrsInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -38982,10 +39262,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("GetIpamResourceCidrs") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentGetManagedPrefixListEntriesInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentGetIpamResourceCidrsInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -39008,14 +39288,14 @@ func (m *awsEc2query_serializeOpGetManagedPrefixListEntries) HandleSerialize(ctx return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpGetNetworkInsightsAccessScopeAnalysisFindings struct { +type awsEc2query_serializeOpGetLaunchTemplateData struct { } -func (*awsEc2query_serializeOpGetNetworkInsightsAccessScopeAnalysisFindings) ID() string { +func (*awsEc2query_serializeOpGetLaunchTemplateData) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpGetNetworkInsightsAccessScopeAnalysisFindings) 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, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -39027,7 +39307,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.(*GetLaunchTemplateDataInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -39052,10 +39332,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("GetLaunchTemplateData") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentGetNetworkInsightsAccessScopeAnalysisFindingsInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentGetLaunchTemplateDataInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -39078,14 +39358,14 @@ func (m *awsEc2query_serializeOpGetNetworkInsightsAccessScopeAnalysisFindings) H return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpGetNetworkInsightsAccessScopeContent struct { +type awsEc2query_serializeOpGetManagedPrefixListAssociations struct { } -func (*awsEc2query_serializeOpGetNetworkInsightsAccessScopeContent) ID() string { +func (*awsEc2query_serializeOpGetManagedPrefixListAssociations) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpGetNetworkInsightsAccessScopeContent) 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, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -39097,7 +39377,7 @@ 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.(*GetManagedPrefixListAssociationsInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -39122,10 +39402,10 @@ func (m *awsEc2query_serializeOpGetNetworkInsightsAccessScopeContent) HandleSeri bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("GetNetworkInsightsAccessScopeContent") + body.Key("Action").String("GetManagedPrefixListAssociations") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentGetNetworkInsightsAccessScopeContentInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentGetManagedPrefixListAssociationsInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -39148,14 +39428,14 @@ func (m *awsEc2query_serializeOpGetNetworkInsightsAccessScopeContent) HandleSeri return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpGetPasswordData struct { +type awsEc2query_serializeOpGetManagedPrefixListEntries struct { } -func (*awsEc2query_serializeOpGetPasswordData) ID() string { +func (*awsEc2query_serializeOpGetManagedPrefixListEntries) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpGetPasswordData) 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, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -39167,7 +39447,7 @@ func (m *awsEc2query_serializeOpGetPasswordData) HandleSerialize(ctx context.Con return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*GetPasswordDataInput) + input, ok := in.Parameters.(*GetManagedPrefixListEntriesInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -39192,10 +39472,10 @@ func (m *awsEc2query_serializeOpGetPasswordData) HandleSerialize(ctx context.Con bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("GetPasswordData") + body.Key("Action").String("GetManagedPrefixListEntries") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentGetPasswordDataInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentGetManagedPrefixListEntriesInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -39218,14 +39498,14 @@ func (m *awsEc2query_serializeOpGetPasswordData) HandleSerialize(ctx context.Con return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpGetReservedInstancesExchangeQuote struct { +type awsEc2query_serializeOpGetNetworkInsightsAccessScopeAnalysisFindings struct { } -func (*awsEc2query_serializeOpGetReservedInstancesExchangeQuote) ID() string { +func (*awsEc2query_serializeOpGetNetworkInsightsAccessScopeAnalysisFindings) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpGetReservedInstancesExchangeQuote) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpGetNetworkInsightsAccessScopeAnalysisFindings) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -39237,7 +39517,7 @@ func (m *awsEc2query_serializeOpGetReservedInstancesExchangeQuote) HandleSeriali return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*GetReservedInstancesExchangeQuoteInput) + input, ok := in.Parameters.(*GetNetworkInsightsAccessScopeAnalysisFindingsInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -39262,10 +39542,10 @@ func (m *awsEc2query_serializeOpGetReservedInstancesExchangeQuote) HandleSeriali bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("GetReservedInstancesExchangeQuote") + body.Key("Action").String("GetNetworkInsightsAccessScopeAnalysisFindings") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentGetReservedInstancesExchangeQuoteInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentGetNetworkInsightsAccessScopeAnalysisFindingsInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -39288,14 +39568,14 @@ func (m *awsEc2query_serializeOpGetReservedInstancesExchangeQuote) HandleSeriali return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpGetRouteServerAssociations struct { +type awsEc2query_serializeOpGetNetworkInsightsAccessScopeContent struct { } -func (*awsEc2query_serializeOpGetRouteServerAssociations) ID() string { +func (*awsEc2query_serializeOpGetNetworkInsightsAccessScopeContent) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpGetRouteServerAssociations) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpGetNetworkInsightsAccessScopeContent) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -39307,7 +39587,7 @@ func (m *awsEc2query_serializeOpGetRouteServerAssociations) HandleSerialize(ctx return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*GetRouteServerAssociationsInput) + input, ok := in.Parameters.(*GetNetworkInsightsAccessScopeContentInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -39332,10 +39612,10 @@ func (m *awsEc2query_serializeOpGetRouteServerAssociations) HandleSerialize(ctx bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("GetRouteServerAssociations") + body.Key("Action").String("GetNetworkInsightsAccessScopeContent") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentGetRouteServerAssociationsInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentGetNetworkInsightsAccessScopeContentInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -39358,14 +39638,14 @@ func (m *awsEc2query_serializeOpGetRouteServerAssociations) HandleSerialize(ctx return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpGetRouteServerPropagations struct { +type awsEc2query_serializeOpGetPasswordData struct { } -func (*awsEc2query_serializeOpGetRouteServerPropagations) ID() string { +func (*awsEc2query_serializeOpGetPasswordData) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpGetRouteServerPropagations) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpGetPasswordData) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -39377,7 +39657,7 @@ func (m *awsEc2query_serializeOpGetRouteServerPropagations) HandleSerialize(ctx return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*GetRouteServerPropagationsInput) + input, ok := in.Parameters.(*GetPasswordDataInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -39402,10 +39682,10 @@ func (m *awsEc2query_serializeOpGetRouteServerPropagations) HandleSerialize(ctx bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("GetRouteServerPropagations") + body.Key("Action").String("GetPasswordData") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentGetRouteServerPropagationsInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentGetPasswordDataInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -39428,14 +39708,14 @@ func (m *awsEc2query_serializeOpGetRouteServerPropagations) HandleSerialize(ctx return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpGetRouteServerRoutingDatabase struct { +type awsEc2query_serializeOpGetReservedInstancesExchangeQuote struct { } -func (*awsEc2query_serializeOpGetRouteServerRoutingDatabase) ID() string { +func (*awsEc2query_serializeOpGetReservedInstancesExchangeQuote) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpGetRouteServerRoutingDatabase) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpGetReservedInstancesExchangeQuote) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -39447,7 +39727,7 @@ func (m *awsEc2query_serializeOpGetRouteServerRoutingDatabase) HandleSerialize(c return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*GetRouteServerRoutingDatabaseInput) + input, ok := in.Parameters.(*GetReservedInstancesExchangeQuoteInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -39472,10 +39752,10 @@ func (m *awsEc2query_serializeOpGetRouteServerRoutingDatabase) HandleSerialize(c bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("GetRouteServerRoutingDatabase") + body.Key("Action").String("GetReservedInstancesExchangeQuote") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentGetRouteServerRoutingDatabaseInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentGetReservedInstancesExchangeQuoteInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -39498,14 +39778,14 @@ func (m *awsEc2query_serializeOpGetRouteServerRoutingDatabase) HandleSerialize(c return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpGetSecurityGroupsForVpc struct { +type awsEc2query_serializeOpGetRouteServerAssociations struct { } -func (*awsEc2query_serializeOpGetSecurityGroupsForVpc) ID() string { +func (*awsEc2query_serializeOpGetRouteServerAssociations) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpGetSecurityGroupsForVpc) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpGetRouteServerAssociations) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -39517,7 +39797,7 @@ func (m *awsEc2query_serializeOpGetSecurityGroupsForVpc) HandleSerialize(ctx con return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*GetSecurityGroupsForVpcInput) + input, ok := in.Parameters.(*GetRouteServerAssociationsInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -39542,10 +39822,10 @@ func (m *awsEc2query_serializeOpGetSecurityGroupsForVpc) HandleSerialize(ctx con bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("GetSecurityGroupsForVpc") + body.Key("Action").String("GetRouteServerAssociations") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentGetSecurityGroupsForVpcInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentGetRouteServerAssociationsInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -39568,14 +39848,14 @@ func (m *awsEc2query_serializeOpGetSecurityGroupsForVpc) HandleSerialize(ctx con return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpGetSerialConsoleAccessStatus struct { +type awsEc2query_serializeOpGetRouteServerPropagations struct { } -func (*awsEc2query_serializeOpGetSerialConsoleAccessStatus) ID() string { +func (*awsEc2query_serializeOpGetRouteServerPropagations) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpGetSerialConsoleAccessStatus) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpGetRouteServerPropagations) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -39587,7 +39867,7 @@ func (m *awsEc2query_serializeOpGetSerialConsoleAccessStatus) HandleSerialize(ct return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*GetSerialConsoleAccessStatusInput) + input, ok := in.Parameters.(*GetRouteServerPropagationsInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -39612,10 +39892,10 @@ func (m *awsEc2query_serializeOpGetSerialConsoleAccessStatus) HandleSerialize(ct bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("GetSerialConsoleAccessStatus") + body.Key("Action").String("GetRouteServerPropagations") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentGetSerialConsoleAccessStatusInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentGetRouteServerPropagationsInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -39638,14 +39918,14 @@ func (m *awsEc2query_serializeOpGetSerialConsoleAccessStatus) HandleSerialize(ct return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpGetSnapshotBlockPublicAccessState struct { +type awsEc2query_serializeOpGetRouteServerRoutingDatabase struct { } -func (*awsEc2query_serializeOpGetSnapshotBlockPublicAccessState) ID() string { +func (*awsEc2query_serializeOpGetRouteServerRoutingDatabase) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpGetSnapshotBlockPublicAccessState) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpGetRouteServerRoutingDatabase) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -39657,7 +39937,7 @@ func (m *awsEc2query_serializeOpGetSnapshotBlockPublicAccessState) HandleSeriali return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*GetSnapshotBlockPublicAccessStateInput) + input, ok := in.Parameters.(*GetRouteServerRoutingDatabaseInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -39682,10 +39962,10 @@ func (m *awsEc2query_serializeOpGetSnapshotBlockPublicAccessState) HandleSeriali bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("GetSnapshotBlockPublicAccessState") + body.Key("Action").String("GetRouteServerRoutingDatabase") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentGetSnapshotBlockPublicAccessStateInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentGetRouteServerRoutingDatabaseInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -39708,14 +39988,14 @@ func (m *awsEc2query_serializeOpGetSnapshotBlockPublicAccessState) HandleSeriali return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpGetSpotPlacementScores struct { +type awsEc2query_serializeOpGetSecurityGroupsForVpc struct { } -func (*awsEc2query_serializeOpGetSpotPlacementScores) ID() string { +func (*awsEc2query_serializeOpGetSecurityGroupsForVpc) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpGetSpotPlacementScores) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpGetSecurityGroupsForVpc) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -39727,7 +40007,7 @@ func (m *awsEc2query_serializeOpGetSpotPlacementScores) HandleSerialize(ctx cont return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*GetSpotPlacementScoresInput) + input, ok := in.Parameters.(*GetSecurityGroupsForVpcInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -39752,10 +40032,10 @@ func (m *awsEc2query_serializeOpGetSpotPlacementScores) HandleSerialize(ctx cont bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("GetSpotPlacementScores") + body.Key("Action").String("GetSecurityGroupsForVpc") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentGetSpotPlacementScoresInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentGetSecurityGroupsForVpcInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -39778,14 +40058,14 @@ func (m *awsEc2query_serializeOpGetSpotPlacementScores) HandleSerialize(ctx cont return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpGetSubnetCidrReservations struct { +type awsEc2query_serializeOpGetSerialConsoleAccessStatus struct { } -func (*awsEc2query_serializeOpGetSubnetCidrReservations) ID() string { +func (*awsEc2query_serializeOpGetSerialConsoleAccessStatus) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpGetSubnetCidrReservations) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpGetSerialConsoleAccessStatus) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -39797,7 +40077,7 @@ func (m *awsEc2query_serializeOpGetSubnetCidrReservations) HandleSerialize(ctx c return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*GetSubnetCidrReservationsInput) + input, ok := in.Parameters.(*GetSerialConsoleAccessStatusInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -39822,10 +40102,10 @@ func (m *awsEc2query_serializeOpGetSubnetCidrReservations) HandleSerialize(ctx c bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("GetSubnetCidrReservations") + body.Key("Action").String("GetSerialConsoleAccessStatus") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentGetSubnetCidrReservationsInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentGetSerialConsoleAccessStatusInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -39848,14 +40128,14 @@ func (m *awsEc2query_serializeOpGetSubnetCidrReservations) HandleSerialize(ctx c return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpGetTransitGatewayAttachmentPropagations struct { +type awsEc2query_serializeOpGetSnapshotBlockPublicAccessState struct { } -func (*awsEc2query_serializeOpGetTransitGatewayAttachmentPropagations) ID() string { +func (*awsEc2query_serializeOpGetSnapshotBlockPublicAccessState) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpGetTransitGatewayAttachmentPropagations) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpGetSnapshotBlockPublicAccessState) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -39867,7 +40147,7 @@ func (m *awsEc2query_serializeOpGetTransitGatewayAttachmentPropagations) HandleS return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*GetTransitGatewayAttachmentPropagationsInput) + input, ok := in.Parameters.(*GetSnapshotBlockPublicAccessStateInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -39892,10 +40172,10 @@ func (m *awsEc2query_serializeOpGetTransitGatewayAttachmentPropagations) HandleS bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("GetTransitGatewayAttachmentPropagations") + body.Key("Action").String("GetSnapshotBlockPublicAccessState") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentGetTransitGatewayAttachmentPropagationsInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentGetSnapshotBlockPublicAccessStateInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -39918,14 +40198,14 @@ func (m *awsEc2query_serializeOpGetTransitGatewayAttachmentPropagations) HandleS return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpGetTransitGatewayMeteringPolicyEntries struct { +type awsEc2query_serializeOpGetSpotPlacementScores struct { } -func (*awsEc2query_serializeOpGetTransitGatewayMeteringPolicyEntries) ID() string { +func (*awsEc2query_serializeOpGetSpotPlacementScores) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpGetTransitGatewayMeteringPolicyEntries) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpGetSpotPlacementScores) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -39937,7 +40217,7 @@ func (m *awsEc2query_serializeOpGetTransitGatewayMeteringPolicyEntries) HandleSe return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*GetTransitGatewayMeteringPolicyEntriesInput) + input, ok := in.Parameters.(*GetSpotPlacementScoresInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -39962,10 +40242,10 @@ func (m *awsEc2query_serializeOpGetTransitGatewayMeteringPolicyEntries) HandleSe bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("GetTransitGatewayMeteringPolicyEntries") + body.Key("Action").String("GetSpotPlacementScores") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentGetTransitGatewayMeteringPolicyEntriesInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentGetSpotPlacementScoresInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -39988,14 +40268,14 @@ func (m *awsEc2query_serializeOpGetTransitGatewayMeteringPolicyEntries) HandleSe return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpGetTransitGatewayMulticastDomainAssociations struct { +type awsEc2query_serializeOpGetSubnetCidrReservations struct { } -func (*awsEc2query_serializeOpGetTransitGatewayMulticastDomainAssociations) ID() string { +func (*awsEc2query_serializeOpGetSubnetCidrReservations) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpGetTransitGatewayMulticastDomainAssociations) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpGetSubnetCidrReservations) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -40007,7 +40287,7 @@ func (m *awsEc2query_serializeOpGetTransitGatewayMulticastDomainAssociations) Ha return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*GetTransitGatewayMulticastDomainAssociationsInput) + input, ok := in.Parameters.(*GetSubnetCidrReservationsInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -40032,10 +40312,10 @@ func (m *awsEc2query_serializeOpGetTransitGatewayMulticastDomainAssociations) Ha bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("GetTransitGatewayMulticastDomainAssociations") + body.Key("Action").String("GetSubnetCidrReservations") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentGetTransitGatewayMulticastDomainAssociationsInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentGetSubnetCidrReservationsInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -40058,14 +40338,14 @@ func (m *awsEc2query_serializeOpGetTransitGatewayMulticastDomainAssociations) Ha return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpGetTransitGatewayPolicyTableAssociations struct { +type awsEc2query_serializeOpGetTransitGatewayAttachmentPropagations struct { } -func (*awsEc2query_serializeOpGetTransitGatewayPolicyTableAssociations) ID() string { +func (*awsEc2query_serializeOpGetTransitGatewayAttachmentPropagations) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpGetTransitGatewayPolicyTableAssociations) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpGetTransitGatewayAttachmentPropagations) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -40077,7 +40357,7 @@ func (m *awsEc2query_serializeOpGetTransitGatewayPolicyTableAssociations) Handle return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*GetTransitGatewayPolicyTableAssociationsInput) + input, ok := in.Parameters.(*GetTransitGatewayAttachmentPropagationsInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -40102,10 +40382,10 @@ func (m *awsEc2query_serializeOpGetTransitGatewayPolicyTableAssociations) Handle bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("GetTransitGatewayPolicyTableAssociations") + body.Key("Action").String("GetTransitGatewayAttachmentPropagations") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentGetTransitGatewayPolicyTableAssociationsInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentGetTransitGatewayAttachmentPropagationsInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -40128,14 +40408,14 @@ func (m *awsEc2query_serializeOpGetTransitGatewayPolicyTableAssociations) Handle return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpGetTransitGatewayPolicyTableEntries struct { +type awsEc2query_serializeOpGetTransitGatewayMeteringPolicyEntries struct { } -func (*awsEc2query_serializeOpGetTransitGatewayPolicyTableEntries) ID() string { +func (*awsEc2query_serializeOpGetTransitGatewayMeteringPolicyEntries) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpGetTransitGatewayPolicyTableEntries) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpGetTransitGatewayMeteringPolicyEntries) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -40147,7 +40427,7 @@ func (m *awsEc2query_serializeOpGetTransitGatewayPolicyTableEntries) HandleSeria return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*GetTransitGatewayPolicyTableEntriesInput) + input, ok := in.Parameters.(*GetTransitGatewayMeteringPolicyEntriesInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -40172,10 +40452,10 @@ func (m *awsEc2query_serializeOpGetTransitGatewayPolicyTableEntries) HandleSeria bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("GetTransitGatewayPolicyTableEntries") + body.Key("Action").String("GetTransitGatewayMeteringPolicyEntries") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentGetTransitGatewayPolicyTableEntriesInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentGetTransitGatewayMeteringPolicyEntriesInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -40198,14 +40478,14 @@ func (m *awsEc2query_serializeOpGetTransitGatewayPolicyTableEntries) HandleSeria return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpGetTransitGatewayPrefixListReferences struct { +type awsEc2query_serializeOpGetTransitGatewayMulticastDomainAssociations struct { } -func (*awsEc2query_serializeOpGetTransitGatewayPrefixListReferences) ID() string { +func (*awsEc2query_serializeOpGetTransitGatewayMulticastDomainAssociations) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpGetTransitGatewayPrefixListReferences) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpGetTransitGatewayMulticastDomainAssociations) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -40217,7 +40497,7 @@ func (m *awsEc2query_serializeOpGetTransitGatewayPrefixListReferences) HandleSer return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*GetTransitGatewayPrefixListReferencesInput) + input, ok := in.Parameters.(*GetTransitGatewayMulticastDomainAssociationsInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -40242,10 +40522,10 @@ func (m *awsEc2query_serializeOpGetTransitGatewayPrefixListReferences) HandleSer bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("GetTransitGatewayPrefixListReferences") + body.Key("Action").String("GetTransitGatewayMulticastDomainAssociations") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentGetTransitGatewayPrefixListReferencesInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentGetTransitGatewayMulticastDomainAssociationsInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -40268,14 +40548,14 @@ func (m *awsEc2query_serializeOpGetTransitGatewayPrefixListReferences) HandleSer return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpGetTransitGatewayRouteTableAssociations struct { +type awsEc2query_serializeOpGetTransitGatewayPolicyTableAssociations struct { } -func (*awsEc2query_serializeOpGetTransitGatewayRouteTableAssociations) ID() string { +func (*awsEc2query_serializeOpGetTransitGatewayPolicyTableAssociations) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpGetTransitGatewayRouteTableAssociations) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpGetTransitGatewayPolicyTableAssociations) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -40287,7 +40567,7 @@ func (m *awsEc2query_serializeOpGetTransitGatewayRouteTableAssociations) HandleS return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*GetTransitGatewayRouteTableAssociationsInput) + input, ok := in.Parameters.(*GetTransitGatewayPolicyTableAssociationsInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -40312,10 +40592,10 @@ func (m *awsEc2query_serializeOpGetTransitGatewayRouteTableAssociations) HandleS bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("GetTransitGatewayRouteTableAssociations") + body.Key("Action").String("GetTransitGatewayPolicyTableAssociations") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentGetTransitGatewayRouteTableAssociationsInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentGetTransitGatewayPolicyTableAssociationsInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -40338,14 +40618,14 @@ func (m *awsEc2query_serializeOpGetTransitGatewayRouteTableAssociations) HandleS return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpGetTransitGatewayRouteTablePropagations struct { +type awsEc2query_serializeOpGetTransitGatewayPolicyTableEntries struct { } -func (*awsEc2query_serializeOpGetTransitGatewayRouteTablePropagations) ID() string { +func (*awsEc2query_serializeOpGetTransitGatewayPolicyTableEntries) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpGetTransitGatewayRouteTablePropagations) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpGetTransitGatewayPolicyTableEntries) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -40357,7 +40637,7 @@ func (m *awsEc2query_serializeOpGetTransitGatewayRouteTablePropagations) HandleS return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*GetTransitGatewayRouteTablePropagationsInput) + input, ok := in.Parameters.(*GetTransitGatewayPolicyTableEntriesInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -40382,10 +40662,10 @@ func (m *awsEc2query_serializeOpGetTransitGatewayRouteTablePropagations) HandleS bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("GetTransitGatewayRouteTablePropagations") + body.Key("Action").String("GetTransitGatewayPolicyTableEntries") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentGetTransitGatewayRouteTablePropagationsInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentGetTransitGatewayPolicyTableEntriesInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -40408,14 +40688,14 @@ func (m *awsEc2query_serializeOpGetTransitGatewayRouteTablePropagations) HandleS return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpGetVerifiedAccessEndpointPolicy struct { +type awsEc2query_serializeOpGetTransitGatewayPrefixListReferences struct { } -func (*awsEc2query_serializeOpGetVerifiedAccessEndpointPolicy) ID() string { +func (*awsEc2query_serializeOpGetTransitGatewayPrefixListReferences) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpGetVerifiedAccessEndpointPolicy) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpGetTransitGatewayPrefixListReferences) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -40427,7 +40707,7 @@ func (m *awsEc2query_serializeOpGetVerifiedAccessEndpointPolicy) HandleSerialize return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*GetVerifiedAccessEndpointPolicyInput) + input, ok := in.Parameters.(*GetTransitGatewayPrefixListReferencesInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -40452,10 +40732,10 @@ func (m *awsEc2query_serializeOpGetVerifiedAccessEndpointPolicy) HandleSerialize bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("GetVerifiedAccessEndpointPolicy") + body.Key("Action").String("GetTransitGatewayPrefixListReferences") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentGetVerifiedAccessEndpointPolicyInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentGetTransitGatewayPrefixListReferencesInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -40478,14 +40758,14 @@ func (m *awsEc2query_serializeOpGetVerifiedAccessEndpointPolicy) HandleSerialize return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpGetVerifiedAccessEndpointTargets struct { +type awsEc2query_serializeOpGetTransitGatewayRouteTableAssociations struct { } -func (*awsEc2query_serializeOpGetVerifiedAccessEndpointTargets) ID() string { +func (*awsEc2query_serializeOpGetTransitGatewayRouteTableAssociations) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpGetVerifiedAccessEndpointTargets) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpGetTransitGatewayRouteTableAssociations) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -40497,7 +40777,7 @@ func (m *awsEc2query_serializeOpGetVerifiedAccessEndpointTargets) HandleSerializ return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*GetVerifiedAccessEndpointTargetsInput) + input, ok := in.Parameters.(*GetTransitGatewayRouteTableAssociationsInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -40522,10 +40802,10 @@ func (m *awsEc2query_serializeOpGetVerifiedAccessEndpointTargets) HandleSerializ bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("GetVerifiedAccessEndpointTargets") + body.Key("Action").String("GetTransitGatewayRouteTableAssociations") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentGetVerifiedAccessEndpointTargetsInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentGetTransitGatewayRouteTableAssociationsInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -40548,14 +40828,14 @@ func (m *awsEc2query_serializeOpGetVerifiedAccessEndpointTargets) HandleSerializ return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpGetVerifiedAccessGroupPolicy struct { +type awsEc2query_serializeOpGetTransitGatewayRouteTablePropagations struct { } -func (*awsEc2query_serializeOpGetVerifiedAccessGroupPolicy) ID() string { +func (*awsEc2query_serializeOpGetTransitGatewayRouteTablePropagations) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpGetVerifiedAccessGroupPolicy) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpGetTransitGatewayRouteTablePropagations) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -40567,7 +40847,7 @@ func (m *awsEc2query_serializeOpGetVerifiedAccessGroupPolicy) HandleSerialize(ct return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*GetVerifiedAccessGroupPolicyInput) + input, ok := in.Parameters.(*GetTransitGatewayRouteTablePropagationsInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -40592,10 +40872,10 @@ func (m *awsEc2query_serializeOpGetVerifiedAccessGroupPolicy) HandleSerialize(ct bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("GetVerifiedAccessGroupPolicy") + body.Key("Action").String("GetTransitGatewayRouteTablePropagations") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentGetVerifiedAccessGroupPolicyInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentGetTransitGatewayRouteTablePropagationsInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -40618,14 +40898,14 @@ func (m *awsEc2query_serializeOpGetVerifiedAccessGroupPolicy) HandleSerialize(ct return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpGetVpcResourcesBlockingEncryptionEnforcement struct { +type awsEc2query_serializeOpGetVerifiedAccessEndpointPolicy struct { } -func (*awsEc2query_serializeOpGetVpcResourcesBlockingEncryptionEnforcement) ID() string { +func (*awsEc2query_serializeOpGetVerifiedAccessEndpointPolicy) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpGetVpcResourcesBlockingEncryptionEnforcement) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpGetVerifiedAccessEndpointPolicy) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -40637,7 +40917,7 @@ func (m *awsEc2query_serializeOpGetVpcResourcesBlockingEncryptionEnforcement) Ha return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*GetVpcResourcesBlockingEncryptionEnforcementInput) + input, ok := in.Parameters.(*GetVerifiedAccessEndpointPolicyInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -40662,10 +40942,10 @@ func (m *awsEc2query_serializeOpGetVpcResourcesBlockingEncryptionEnforcement) Ha bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("GetVpcResourcesBlockingEncryptionEnforcement") + body.Key("Action").String("GetVerifiedAccessEndpointPolicy") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentGetVpcResourcesBlockingEncryptionEnforcementInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentGetVerifiedAccessEndpointPolicyInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -40688,14 +40968,14 @@ func (m *awsEc2query_serializeOpGetVpcResourcesBlockingEncryptionEnforcement) Ha return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpGetVpnConnectionDeviceSampleConfiguration struct { +type awsEc2query_serializeOpGetVerifiedAccessEndpointTargets struct { } -func (*awsEc2query_serializeOpGetVpnConnectionDeviceSampleConfiguration) ID() string { +func (*awsEc2query_serializeOpGetVerifiedAccessEndpointTargets) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpGetVpnConnectionDeviceSampleConfiguration) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpGetVerifiedAccessEndpointTargets) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -40707,7 +40987,7 @@ func (m *awsEc2query_serializeOpGetVpnConnectionDeviceSampleConfiguration) Handl return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*GetVpnConnectionDeviceSampleConfigurationInput) + input, ok := in.Parameters.(*GetVerifiedAccessEndpointTargetsInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -40732,10 +41012,10 @@ func (m *awsEc2query_serializeOpGetVpnConnectionDeviceSampleConfiguration) Handl bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("GetVpnConnectionDeviceSampleConfiguration") + body.Key("Action").String("GetVerifiedAccessEndpointTargets") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentGetVpnConnectionDeviceSampleConfigurationInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentGetVerifiedAccessEndpointTargetsInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -40758,14 +41038,14 @@ func (m *awsEc2query_serializeOpGetVpnConnectionDeviceSampleConfiguration) Handl return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpGetVpnConnectionDeviceTypes struct { +type awsEc2query_serializeOpGetVerifiedAccessGroupPolicy struct { } -func (*awsEc2query_serializeOpGetVpnConnectionDeviceTypes) ID() string { +func (*awsEc2query_serializeOpGetVerifiedAccessGroupPolicy) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpGetVpnConnectionDeviceTypes) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpGetVerifiedAccessGroupPolicy) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -40777,7 +41057,7 @@ func (m *awsEc2query_serializeOpGetVpnConnectionDeviceTypes) HandleSerialize(ctx return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*GetVpnConnectionDeviceTypesInput) + input, ok := in.Parameters.(*GetVerifiedAccessGroupPolicyInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -40802,10 +41082,10 @@ func (m *awsEc2query_serializeOpGetVpnConnectionDeviceTypes) HandleSerialize(ctx bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("GetVpnConnectionDeviceTypes") + body.Key("Action").String("GetVerifiedAccessGroupPolicy") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentGetVpnConnectionDeviceTypesInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentGetVerifiedAccessGroupPolicyInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -40828,14 +41108,14 @@ func (m *awsEc2query_serializeOpGetVpnConnectionDeviceTypes) HandleSerialize(ctx return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpGetVpnTunnelReplacementStatus struct { +type awsEc2query_serializeOpGetVpcResourcesBlockingEncryptionEnforcement struct { } -func (*awsEc2query_serializeOpGetVpnTunnelReplacementStatus) ID() string { +func (*awsEc2query_serializeOpGetVpcResourcesBlockingEncryptionEnforcement) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpGetVpnTunnelReplacementStatus) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpGetVpcResourcesBlockingEncryptionEnforcement) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -40847,7 +41127,7 @@ func (m *awsEc2query_serializeOpGetVpnTunnelReplacementStatus) HandleSerialize(c return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*GetVpnTunnelReplacementStatusInput) + input, ok := in.Parameters.(*GetVpcResourcesBlockingEncryptionEnforcementInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -40872,10 +41152,10 @@ func (m *awsEc2query_serializeOpGetVpnTunnelReplacementStatus) HandleSerialize(c bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("GetVpnTunnelReplacementStatus") + body.Key("Action").String("GetVpcResourcesBlockingEncryptionEnforcement") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentGetVpnTunnelReplacementStatusInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentGetVpcResourcesBlockingEncryptionEnforcementInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -40898,14 +41178,14 @@ func (m *awsEc2query_serializeOpGetVpnTunnelReplacementStatus) HandleSerialize(c return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpImportClientVpnClientCertificateRevocationList struct { +type awsEc2query_serializeOpGetVpnConnectionDeviceSampleConfiguration struct { } -func (*awsEc2query_serializeOpImportClientVpnClientCertificateRevocationList) ID() string { +func (*awsEc2query_serializeOpGetVpnConnectionDeviceSampleConfiguration) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpImportClientVpnClientCertificateRevocationList) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpGetVpnConnectionDeviceSampleConfiguration) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -40917,7 +41197,7 @@ func (m *awsEc2query_serializeOpImportClientVpnClientCertificateRevocationList) return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ImportClientVpnClientCertificateRevocationListInput) + input, ok := in.Parameters.(*GetVpnConnectionDeviceSampleConfigurationInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -40942,10 +41222,10 @@ func (m *awsEc2query_serializeOpImportClientVpnClientCertificateRevocationList) bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("ImportClientVpnClientCertificateRevocationList") + body.Key("Action").String("GetVpnConnectionDeviceSampleConfiguration") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentImportClientVpnClientCertificateRevocationListInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentGetVpnConnectionDeviceSampleConfigurationInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -40968,14 +41248,14 @@ func (m *awsEc2query_serializeOpImportClientVpnClientCertificateRevocationList) return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpImportImage struct { +type awsEc2query_serializeOpGetVpnConnectionDeviceTypes struct { } -func (*awsEc2query_serializeOpImportImage) ID() string { +func (*awsEc2query_serializeOpGetVpnConnectionDeviceTypes) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpImportImage) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpGetVpnConnectionDeviceTypes) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -40987,7 +41267,7 @@ func (m *awsEc2query_serializeOpImportImage) HandleSerialize(ctx context.Context return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ImportImageInput) + input, ok := in.Parameters.(*GetVpnConnectionDeviceTypesInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -41012,10 +41292,10 @@ func (m *awsEc2query_serializeOpImportImage) HandleSerialize(ctx context.Context bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("ImportImage") + body.Key("Action").String("GetVpnConnectionDeviceTypes") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentImportImageInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentGetVpnConnectionDeviceTypesInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -41038,14 +41318,14 @@ func (m *awsEc2query_serializeOpImportImage) HandleSerialize(ctx context.Context return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpImportInstance struct { +type awsEc2query_serializeOpGetVpnTunnelReplacementStatus struct { } -func (*awsEc2query_serializeOpImportInstance) ID() string { +func (*awsEc2query_serializeOpGetVpnTunnelReplacementStatus) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpImportInstance) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpGetVpnTunnelReplacementStatus) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -41057,7 +41337,7 @@ func (m *awsEc2query_serializeOpImportInstance) HandleSerialize(ctx context.Cont return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ImportInstanceInput) + input, ok := in.Parameters.(*GetVpnTunnelReplacementStatusInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -41082,10 +41362,10 @@ func (m *awsEc2query_serializeOpImportInstance) HandleSerialize(ctx context.Cont bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("ImportInstance") + body.Key("Action").String("GetVpnTunnelReplacementStatus") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentImportInstanceInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentGetVpnTunnelReplacementStatusInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -41108,14 +41388,14 @@ func (m *awsEc2query_serializeOpImportInstance) HandleSerialize(ctx context.Cont return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpImportKeyPair struct { +type awsEc2query_serializeOpImportClientVpnClientCertificateRevocationList struct { } -func (*awsEc2query_serializeOpImportKeyPair) ID() string { +func (*awsEc2query_serializeOpImportClientVpnClientCertificateRevocationList) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpImportKeyPair) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpImportClientVpnClientCertificateRevocationList) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -41127,7 +41407,7 @@ func (m *awsEc2query_serializeOpImportKeyPair) HandleSerialize(ctx context.Conte return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ImportKeyPairInput) + input, ok := in.Parameters.(*ImportClientVpnClientCertificateRevocationListInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -41152,10 +41432,10 @@ func (m *awsEc2query_serializeOpImportKeyPair) HandleSerialize(ctx context.Conte bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("ImportKeyPair") + body.Key("Action").String("ImportClientVpnClientCertificateRevocationList") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentImportKeyPairInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentImportClientVpnClientCertificateRevocationListInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -41178,14 +41458,14 @@ func (m *awsEc2query_serializeOpImportKeyPair) HandleSerialize(ctx context.Conte return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpImportSnapshot struct { +type awsEc2query_serializeOpImportImage struct { } -func (*awsEc2query_serializeOpImportSnapshot) ID() string { +func (*awsEc2query_serializeOpImportImage) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpImportSnapshot) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpImportImage) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -41197,7 +41477,7 @@ func (m *awsEc2query_serializeOpImportSnapshot) HandleSerialize(ctx context.Cont return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ImportSnapshotInput) + input, ok := in.Parameters.(*ImportImageInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -41222,10 +41502,10 @@ func (m *awsEc2query_serializeOpImportSnapshot) HandleSerialize(ctx context.Cont bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("ImportSnapshot") + body.Key("Action").String("ImportImage") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentImportSnapshotInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentImportImageInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -41248,14 +41528,14 @@ func (m *awsEc2query_serializeOpImportSnapshot) HandleSerialize(ctx context.Cont return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpImportVolume struct { +type awsEc2query_serializeOpImportInstance struct { } -func (*awsEc2query_serializeOpImportVolume) ID() string { +func (*awsEc2query_serializeOpImportInstance) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpImportVolume) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpImportInstance) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -41267,7 +41547,7 @@ func (m *awsEc2query_serializeOpImportVolume) HandleSerialize(ctx context.Contex return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ImportVolumeInput) + input, ok := in.Parameters.(*ImportInstanceInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -41292,10 +41572,10 @@ func (m *awsEc2query_serializeOpImportVolume) HandleSerialize(ctx context.Contex bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("ImportVolume") + body.Key("Action").String("ImportInstance") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentImportVolumeInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentImportInstanceInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -41318,14 +41598,14 @@ func (m *awsEc2query_serializeOpImportVolume) HandleSerialize(ctx context.Contex return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpListImagesInRecycleBin struct { +type awsEc2query_serializeOpImportKeyPair struct { } -func (*awsEc2query_serializeOpListImagesInRecycleBin) ID() string { +func (*awsEc2query_serializeOpImportKeyPair) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpListImagesInRecycleBin) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpImportKeyPair) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -41337,7 +41617,7 @@ func (m *awsEc2query_serializeOpListImagesInRecycleBin) HandleSerialize(ctx cont return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ListImagesInRecycleBinInput) + input, ok := in.Parameters.(*ImportKeyPairInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -41362,10 +41642,10 @@ func (m *awsEc2query_serializeOpListImagesInRecycleBin) HandleSerialize(ctx cont bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("ListImagesInRecycleBin") + body.Key("Action").String("ImportKeyPair") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentListImagesInRecycleBinInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentImportKeyPairInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -41388,14 +41668,14 @@ func (m *awsEc2query_serializeOpListImagesInRecycleBin) HandleSerialize(ctx cont return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpListSnapshotsInRecycleBin struct { +type awsEc2query_serializeOpImportSnapshot struct { } -func (*awsEc2query_serializeOpListSnapshotsInRecycleBin) ID() string { +func (*awsEc2query_serializeOpImportSnapshot) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpListSnapshotsInRecycleBin) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpImportSnapshot) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -41407,7 +41687,7 @@ func (m *awsEc2query_serializeOpListSnapshotsInRecycleBin) HandleSerialize(ctx c return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ListSnapshotsInRecycleBinInput) + input, ok := in.Parameters.(*ImportSnapshotInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -41432,10 +41712,10 @@ func (m *awsEc2query_serializeOpListSnapshotsInRecycleBin) HandleSerialize(ctx c bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("ListSnapshotsInRecycleBin") + body.Key("Action").String("ImportSnapshot") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentListSnapshotsInRecycleBinInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentImportSnapshotInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -41458,14 +41738,14 @@ func (m *awsEc2query_serializeOpListSnapshotsInRecycleBin) HandleSerialize(ctx c return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpListVolumesInRecycleBin struct { +type awsEc2query_serializeOpImportVolume struct { } -func (*awsEc2query_serializeOpListVolumesInRecycleBin) ID() string { +func (*awsEc2query_serializeOpImportVolume) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpListVolumesInRecycleBin) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpImportVolume) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -41477,7 +41757,7 @@ func (m *awsEc2query_serializeOpListVolumesInRecycleBin) HandleSerialize(ctx con return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ListVolumesInRecycleBinInput) + input, ok := in.Parameters.(*ImportVolumeInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -41502,10 +41782,10 @@ func (m *awsEc2query_serializeOpListVolumesInRecycleBin) HandleSerialize(ctx con bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("ListVolumesInRecycleBin") + body.Key("Action").String("ImportVolume") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentListVolumesInRecycleBinInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentImportVolumeInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -41528,14 +41808,14 @@ func (m *awsEc2query_serializeOpListVolumesInRecycleBin) HandleSerialize(ctx con return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpLockSnapshot struct { +type awsEc2query_serializeOpListImagesInRecycleBin struct { } -func (*awsEc2query_serializeOpLockSnapshot) ID() string { +func (*awsEc2query_serializeOpListImagesInRecycleBin) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpLockSnapshot) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpListImagesInRecycleBin) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -41547,7 +41827,7 @@ func (m *awsEc2query_serializeOpLockSnapshot) HandleSerialize(ctx context.Contex return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*LockSnapshotInput) + input, ok := in.Parameters.(*ListImagesInRecycleBinInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -41572,10 +41852,10 @@ func (m *awsEc2query_serializeOpLockSnapshot) HandleSerialize(ctx context.Contex bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("LockSnapshot") + body.Key("Action").String("ListImagesInRecycleBin") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentLockSnapshotInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentListImagesInRecycleBinInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -41598,14 +41878,14 @@ func (m *awsEc2query_serializeOpLockSnapshot) HandleSerialize(ctx context.Contex return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpModifyAddressAttribute struct { +type awsEc2query_serializeOpListSnapshotsInRecycleBin struct { } -func (*awsEc2query_serializeOpModifyAddressAttribute) ID() string { +func (*awsEc2query_serializeOpListSnapshotsInRecycleBin) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpModifyAddressAttribute) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpListSnapshotsInRecycleBin) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -41617,7 +41897,7 @@ func (m *awsEc2query_serializeOpModifyAddressAttribute) HandleSerialize(ctx cont return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ModifyAddressAttributeInput) + input, ok := in.Parameters.(*ListSnapshotsInRecycleBinInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -41642,10 +41922,10 @@ func (m *awsEc2query_serializeOpModifyAddressAttribute) HandleSerialize(ctx cont bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("ModifyAddressAttribute") + body.Key("Action").String("ListSnapshotsInRecycleBin") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentModifyAddressAttributeInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentListSnapshotsInRecycleBinInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -41668,14 +41948,14 @@ func (m *awsEc2query_serializeOpModifyAddressAttribute) HandleSerialize(ctx cont return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpModifyAvailabilityZoneGroup struct { +type awsEc2query_serializeOpListVolumesInRecycleBin struct { } -func (*awsEc2query_serializeOpModifyAvailabilityZoneGroup) ID() string { +func (*awsEc2query_serializeOpListVolumesInRecycleBin) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpModifyAvailabilityZoneGroup) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpListVolumesInRecycleBin) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -41687,7 +41967,7 @@ func (m *awsEc2query_serializeOpModifyAvailabilityZoneGroup) HandleSerialize(ctx return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ModifyAvailabilityZoneGroupInput) + input, ok := in.Parameters.(*ListVolumesInRecycleBinInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -41712,10 +41992,10 @@ func (m *awsEc2query_serializeOpModifyAvailabilityZoneGroup) HandleSerialize(ctx bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("ModifyAvailabilityZoneGroup") + body.Key("Action").String("ListVolumesInRecycleBin") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentModifyAvailabilityZoneGroupInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentListVolumesInRecycleBinInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -41738,14 +42018,14 @@ func (m *awsEc2query_serializeOpModifyAvailabilityZoneGroup) HandleSerialize(ctx return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpModifyCapacityReservation struct { +type awsEc2query_serializeOpLockSnapshot struct { } -func (*awsEc2query_serializeOpModifyCapacityReservation) ID() string { +func (*awsEc2query_serializeOpLockSnapshot) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpModifyCapacityReservation) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpLockSnapshot) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -41757,7 +42037,7 @@ func (m *awsEc2query_serializeOpModifyCapacityReservation) HandleSerialize(ctx c return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ModifyCapacityReservationInput) + input, ok := in.Parameters.(*LockSnapshotInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -41782,10 +42062,10 @@ func (m *awsEc2query_serializeOpModifyCapacityReservation) HandleSerialize(ctx c bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("ModifyCapacityReservation") + body.Key("Action").String("LockSnapshot") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentModifyCapacityReservationInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentLockSnapshotInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -41808,14 +42088,14 @@ func (m *awsEc2query_serializeOpModifyCapacityReservation) HandleSerialize(ctx c return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpModifyCapacityReservationFleet struct { +type awsEc2query_serializeOpModifyAddressAttribute struct { } -func (*awsEc2query_serializeOpModifyCapacityReservationFleet) ID() string { +func (*awsEc2query_serializeOpModifyAddressAttribute) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpModifyCapacityReservationFleet) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpModifyAddressAttribute) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -41827,7 +42107,7 @@ func (m *awsEc2query_serializeOpModifyCapacityReservationFleet) HandleSerialize( return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ModifyCapacityReservationFleetInput) + input, ok := in.Parameters.(*ModifyAddressAttributeInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -41852,10 +42132,10 @@ func (m *awsEc2query_serializeOpModifyCapacityReservationFleet) HandleSerialize( bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("ModifyCapacityReservationFleet") + body.Key("Action").String("ModifyAddressAttribute") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentModifyCapacityReservationFleetInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentModifyAddressAttributeInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -41878,14 +42158,14 @@ func (m *awsEc2query_serializeOpModifyCapacityReservationFleet) HandleSerialize( return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpModifyClientVpnEndpoint struct { +type awsEc2query_serializeOpModifyAvailabilityZoneGroup struct { } -func (*awsEc2query_serializeOpModifyClientVpnEndpoint) ID() string { +func (*awsEc2query_serializeOpModifyAvailabilityZoneGroup) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpModifyClientVpnEndpoint) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpModifyAvailabilityZoneGroup) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -41897,7 +42177,7 @@ func (m *awsEc2query_serializeOpModifyClientVpnEndpoint) HandleSerialize(ctx con return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ModifyClientVpnEndpointInput) + input, ok := in.Parameters.(*ModifyAvailabilityZoneGroupInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -41922,10 +42202,10 @@ func (m *awsEc2query_serializeOpModifyClientVpnEndpoint) HandleSerialize(ctx con bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("ModifyClientVpnEndpoint") + body.Key("Action").String("ModifyAvailabilityZoneGroup") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentModifyClientVpnEndpointInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentModifyAvailabilityZoneGroupInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -41948,14 +42228,14 @@ func (m *awsEc2query_serializeOpModifyClientVpnEndpoint) HandleSerialize(ctx con return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpModifyDefaultCreditSpecification struct { +type awsEc2query_serializeOpModifyCapacityReservation struct { } -func (*awsEc2query_serializeOpModifyDefaultCreditSpecification) ID() string { +func (*awsEc2query_serializeOpModifyCapacityReservation) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpModifyDefaultCreditSpecification) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpModifyCapacityReservation) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -41967,7 +42247,7 @@ func (m *awsEc2query_serializeOpModifyDefaultCreditSpecification) HandleSerializ return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ModifyDefaultCreditSpecificationInput) + input, ok := in.Parameters.(*ModifyCapacityReservationInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -41992,10 +42272,10 @@ func (m *awsEc2query_serializeOpModifyDefaultCreditSpecification) HandleSerializ bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("ModifyDefaultCreditSpecification") + body.Key("Action").String("ModifyCapacityReservation") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentModifyDefaultCreditSpecificationInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentModifyCapacityReservationInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -42018,14 +42298,14 @@ func (m *awsEc2query_serializeOpModifyDefaultCreditSpecification) HandleSerializ return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpModifyEbsDefaultKmsKeyId struct { +type awsEc2query_serializeOpModifyCapacityReservationFleet struct { } -func (*awsEc2query_serializeOpModifyEbsDefaultKmsKeyId) ID() string { +func (*awsEc2query_serializeOpModifyCapacityReservationFleet) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpModifyEbsDefaultKmsKeyId) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpModifyCapacityReservationFleet) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -42037,7 +42317,7 @@ func (m *awsEc2query_serializeOpModifyEbsDefaultKmsKeyId) HandleSerialize(ctx co return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ModifyEbsDefaultKmsKeyIdInput) + input, ok := in.Parameters.(*ModifyCapacityReservationFleetInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -42062,10 +42342,10 @@ func (m *awsEc2query_serializeOpModifyEbsDefaultKmsKeyId) HandleSerialize(ctx co bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("ModifyEbsDefaultKmsKeyId") + body.Key("Action").String("ModifyCapacityReservationFleet") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentModifyEbsDefaultKmsKeyIdInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentModifyCapacityReservationFleetInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -42088,14 +42368,14 @@ func (m *awsEc2query_serializeOpModifyEbsDefaultKmsKeyId) HandleSerialize(ctx co return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpModifyFleet struct { +type awsEc2query_serializeOpModifyClientVpnEndpoint struct { } -func (*awsEc2query_serializeOpModifyFleet) ID() string { +func (*awsEc2query_serializeOpModifyClientVpnEndpoint) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpModifyFleet) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpModifyClientVpnEndpoint) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -42107,7 +42387,7 @@ func (m *awsEc2query_serializeOpModifyFleet) HandleSerialize(ctx context.Context return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ModifyFleetInput) + input, ok := in.Parameters.(*ModifyClientVpnEndpointInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -42132,10 +42412,10 @@ func (m *awsEc2query_serializeOpModifyFleet) HandleSerialize(ctx context.Context bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("ModifyFleet") + body.Key("Action").String("ModifyClientVpnEndpoint") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentModifyFleetInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentModifyClientVpnEndpointInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -42158,14 +42438,14 @@ func (m *awsEc2query_serializeOpModifyFleet) HandleSerialize(ctx context.Context return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpModifyFpgaImageAttribute struct { +type awsEc2query_serializeOpModifyDefaultCreditSpecification struct { } -func (*awsEc2query_serializeOpModifyFpgaImageAttribute) ID() string { +func (*awsEc2query_serializeOpModifyDefaultCreditSpecification) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpModifyFpgaImageAttribute) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpModifyDefaultCreditSpecification) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -42177,7 +42457,7 @@ func (m *awsEc2query_serializeOpModifyFpgaImageAttribute) HandleSerialize(ctx co return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ModifyFpgaImageAttributeInput) + input, ok := in.Parameters.(*ModifyDefaultCreditSpecificationInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -42202,10 +42482,10 @@ func (m *awsEc2query_serializeOpModifyFpgaImageAttribute) HandleSerialize(ctx co bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("ModifyFpgaImageAttribute") + body.Key("Action").String("ModifyDefaultCreditSpecification") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentModifyFpgaImageAttributeInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentModifyDefaultCreditSpecificationInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -42228,14 +42508,14 @@ func (m *awsEc2query_serializeOpModifyFpgaImageAttribute) HandleSerialize(ctx co return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpModifyHosts struct { +type awsEc2query_serializeOpModifyEbsDefaultKmsKeyId struct { } -func (*awsEc2query_serializeOpModifyHosts) ID() string { +func (*awsEc2query_serializeOpModifyEbsDefaultKmsKeyId) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpModifyHosts) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpModifyEbsDefaultKmsKeyId) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -42247,7 +42527,7 @@ func (m *awsEc2query_serializeOpModifyHosts) HandleSerialize(ctx context.Context return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ModifyHostsInput) + input, ok := in.Parameters.(*ModifyEbsDefaultKmsKeyIdInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -42272,10 +42552,10 @@ func (m *awsEc2query_serializeOpModifyHosts) HandleSerialize(ctx context.Context bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("ModifyHosts") + body.Key("Action").String("ModifyEbsDefaultKmsKeyId") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentModifyHostsInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentModifyEbsDefaultKmsKeyIdInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -42298,14 +42578,14 @@ func (m *awsEc2query_serializeOpModifyHosts) HandleSerialize(ctx context.Context return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpModifyIdentityIdFormat struct { +type awsEc2query_serializeOpModifyFleet struct { } -func (*awsEc2query_serializeOpModifyIdentityIdFormat) ID() string { +func (*awsEc2query_serializeOpModifyFleet) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpModifyIdentityIdFormat) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpModifyFleet) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -42317,7 +42597,7 @@ func (m *awsEc2query_serializeOpModifyIdentityIdFormat) HandleSerialize(ctx cont return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ModifyIdentityIdFormatInput) + input, ok := in.Parameters.(*ModifyFleetInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -42342,10 +42622,10 @@ func (m *awsEc2query_serializeOpModifyIdentityIdFormat) HandleSerialize(ctx cont bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("ModifyIdentityIdFormat") + body.Key("Action").String("ModifyFleet") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentModifyIdentityIdFormatInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentModifyFleetInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -42368,14 +42648,14 @@ func (m *awsEc2query_serializeOpModifyIdentityIdFormat) HandleSerialize(ctx cont return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpModifyIdFormat struct { +type awsEc2query_serializeOpModifyFpgaImageAttribute struct { } -func (*awsEc2query_serializeOpModifyIdFormat) ID() string { +func (*awsEc2query_serializeOpModifyFpgaImageAttribute) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpModifyIdFormat) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpModifyFpgaImageAttribute) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -42387,7 +42667,7 @@ func (m *awsEc2query_serializeOpModifyIdFormat) HandleSerialize(ctx context.Cont return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ModifyIdFormatInput) + input, ok := in.Parameters.(*ModifyFpgaImageAttributeInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -42412,10 +42692,10 @@ func (m *awsEc2query_serializeOpModifyIdFormat) HandleSerialize(ctx context.Cont bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("ModifyIdFormat") + body.Key("Action").String("ModifyFpgaImageAttribute") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentModifyIdFormatInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentModifyFpgaImageAttributeInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -42438,14 +42718,14 @@ func (m *awsEc2query_serializeOpModifyIdFormat) HandleSerialize(ctx context.Cont return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpModifyImageAttribute struct { +type awsEc2query_serializeOpModifyHosts struct { } -func (*awsEc2query_serializeOpModifyImageAttribute) ID() string { +func (*awsEc2query_serializeOpModifyHosts) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpModifyImageAttribute) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpModifyHosts) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -42457,7 +42737,7 @@ func (m *awsEc2query_serializeOpModifyImageAttribute) HandleSerialize(ctx contex return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ModifyImageAttributeInput) + input, ok := in.Parameters.(*ModifyHostsInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -42482,10 +42762,10 @@ func (m *awsEc2query_serializeOpModifyImageAttribute) HandleSerialize(ctx contex bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("ModifyImageAttribute") + body.Key("Action").String("ModifyHosts") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentModifyImageAttributeInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentModifyHostsInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -42508,14 +42788,14 @@ func (m *awsEc2query_serializeOpModifyImageAttribute) HandleSerialize(ctx contex return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpModifyInstanceAttribute struct { +type awsEc2query_serializeOpModifyIdentityIdFormat struct { } -func (*awsEc2query_serializeOpModifyInstanceAttribute) ID() string { +func (*awsEc2query_serializeOpModifyIdentityIdFormat) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpModifyInstanceAttribute) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpModifyIdentityIdFormat) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -42527,7 +42807,7 @@ func (m *awsEc2query_serializeOpModifyInstanceAttribute) HandleSerialize(ctx con return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ModifyInstanceAttributeInput) + input, ok := in.Parameters.(*ModifyIdentityIdFormatInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -42552,10 +42832,10 @@ func (m *awsEc2query_serializeOpModifyInstanceAttribute) HandleSerialize(ctx con bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("ModifyInstanceAttribute") + body.Key("Action").String("ModifyIdentityIdFormat") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentModifyInstanceAttributeInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentModifyIdentityIdFormatInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -42578,14 +42858,14 @@ func (m *awsEc2query_serializeOpModifyInstanceAttribute) HandleSerialize(ctx con return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpModifyInstanceCapacityReservationAttributes struct { +type awsEc2query_serializeOpModifyIdFormat struct { } -func (*awsEc2query_serializeOpModifyInstanceCapacityReservationAttributes) ID() string { +func (*awsEc2query_serializeOpModifyIdFormat) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpModifyInstanceCapacityReservationAttributes) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpModifyIdFormat) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -42597,7 +42877,7 @@ func (m *awsEc2query_serializeOpModifyInstanceCapacityReservationAttributes) Han return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ModifyInstanceCapacityReservationAttributesInput) + input, ok := in.Parameters.(*ModifyIdFormatInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -42622,10 +42902,10 @@ func (m *awsEc2query_serializeOpModifyInstanceCapacityReservationAttributes) Han bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("ModifyInstanceCapacityReservationAttributes") + body.Key("Action").String("ModifyIdFormat") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentModifyInstanceCapacityReservationAttributesInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentModifyIdFormatInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -42648,14 +42928,14 @@ func (m *awsEc2query_serializeOpModifyInstanceCapacityReservationAttributes) Han return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpModifyInstanceConnectEndpoint struct { +type awsEc2query_serializeOpModifyImageAttribute struct { } -func (*awsEc2query_serializeOpModifyInstanceConnectEndpoint) ID() string { +func (*awsEc2query_serializeOpModifyImageAttribute) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpModifyInstanceConnectEndpoint) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpModifyImageAttribute) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -42667,7 +42947,7 @@ func (m *awsEc2query_serializeOpModifyInstanceConnectEndpoint) HandleSerialize(c return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ModifyInstanceConnectEndpointInput) + input, ok := in.Parameters.(*ModifyImageAttributeInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -42692,10 +42972,10 @@ func (m *awsEc2query_serializeOpModifyInstanceConnectEndpoint) HandleSerialize(c bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("ModifyInstanceConnectEndpoint") + body.Key("Action").String("ModifyImageAttribute") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentModifyInstanceConnectEndpointInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentModifyImageAttributeInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -42718,14 +42998,14 @@ func (m *awsEc2query_serializeOpModifyInstanceConnectEndpoint) HandleSerialize(c return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpModifyInstanceCpuOptions struct { +type awsEc2query_serializeOpModifyInstanceAttribute struct { } -func (*awsEc2query_serializeOpModifyInstanceCpuOptions) ID() string { +func (*awsEc2query_serializeOpModifyInstanceAttribute) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpModifyInstanceCpuOptions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpModifyInstanceAttribute) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -42737,7 +43017,7 @@ func (m *awsEc2query_serializeOpModifyInstanceCpuOptions) HandleSerialize(ctx co return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ModifyInstanceCpuOptionsInput) + input, ok := in.Parameters.(*ModifyInstanceAttributeInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -42762,10 +43042,10 @@ func (m *awsEc2query_serializeOpModifyInstanceCpuOptions) HandleSerialize(ctx co bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("ModifyInstanceCpuOptions") + body.Key("Action").String("ModifyInstanceAttribute") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentModifyInstanceCpuOptionsInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentModifyInstanceAttributeInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -42788,14 +43068,14 @@ func (m *awsEc2query_serializeOpModifyInstanceCpuOptions) HandleSerialize(ctx co return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpModifyInstanceCreditSpecification struct { +type awsEc2query_serializeOpModifyInstanceCapacityReservationAttributes struct { } -func (*awsEc2query_serializeOpModifyInstanceCreditSpecification) ID() string { +func (*awsEc2query_serializeOpModifyInstanceCapacityReservationAttributes) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpModifyInstanceCreditSpecification) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpModifyInstanceCapacityReservationAttributes) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -42807,7 +43087,7 @@ func (m *awsEc2query_serializeOpModifyInstanceCreditSpecification) HandleSeriali return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ModifyInstanceCreditSpecificationInput) + input, ok := in.Parameters.(*ModifyInstanceCapacityReservationAttributesInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -42832,10 +43112,10 @@ func (m *awsEc2query_serializeOpModifyInstanceCreditSpecification) HandleSeriali bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("ModifyInstanceCreditSpecification") + body.Key("Action").String("ModifyInstanceCapacityReservationAttributes") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentModifyInstanceCreditSpecificationInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentModifyInstanceCapacityReservationAttributesInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -42858,14 +43138,14 @@ func (m *awsEc2query_serializeOpModifyInstanceCreditSpecification) HandleSeriali return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpModifyInstanceEventStartTime struct { +type awsEc2query_serializeOpModifyInstanceConnectEndpoint struct { } -func (*awsEc2query_serializeOpModifyInstanceEventStartTime) ID() string { +func (*awsEc2query_serializeOpModifyInstanceConnectEndpoint) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpModifyInstanceEventStartTime) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpModifyInstanceConnectEndpoint) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -42877,7 +43157,7 @@ func (m *awsEc2query_serializeOpModifyInstanceEventStartTime) HandleSerialize(ct return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ModifyInstanceEventStartTimeInput) + input, ok := in.Parameters.(*ModifyInstanceConnectEndpointInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -42902,10 +43182,10 @@ func (m *awsEc2query_serializeOpModifyInstanceEventStartTime) HandleSerialize(ct bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("ModifyInstanceEventStartTime") + body.Key("Action").String("ModifyInstanceConnectEndpoint") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentModifyInstanceEventStartTimeInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentModifyInstanceConnectEndpointInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -42928,14 +43208,14 @@ func (m *awsEc2query_serializeOpModifyInstanceEventStartTime) HandleSerialize(ct return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpModifyInstanceEventWindow struct { +type awsEc2query_serializeOpModifyInstanceCpuOptions struct { } -func (*awsEc2query_serializeOpModifyInstanceEventWindow) ID() string { +func (*awsEc2query_serializeOpModifyInstanceCpuOptions) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpModifyInstanceEventWindow) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpModifyInstanceCpuOptions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -42947,7 +43227,7 @@ func (m *awsEc2query_serializeOpModifyInstanceEventWindow) HandleSerialize(ctx c return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ModifyInstanceEventWindowInput) + input, ok := in.Parameters.(*ModifyInstanceCpuOptionsInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -42972,10 +43252,10 @@ func (m *awsEc2query_serializeOpModifyInstanceEventWindow) HandleSerialize(ctx c bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("ModifyInstanceEventWindow") + body.Key("Action").String("ModifyInstanceCpuOptions") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentModifyInstanceEventWindowInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentModifyInstanceCpuOptionsInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -42998,14 +43278,14 @@ func (m *awsEc2query_serializeOpModifyInstanceEventWindow) HandleSerialize(ctx c return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpModifyInstanceMaintenanceOptions struct { +type awsEc2query_serializeOpModifyInstanceCreditSpecification struct { } -func (*awsEc2query_serializeOpModifyInstanceMaintenanceOptions) ID() string { +func (*awsEc2query_serializeOpModifyInstanceCreditSpecification) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpModifyInstanceMaintenanceOptions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpModifyInstanceCreditSpecification) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -43017,7 +43297,7 @@ func (m *awsEc2query_serializeOpModifyInstanceMaintenanceOptions) HandleSerializ return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ModifyInstanceMaintenanceOptionsInput) + input, ok := in.Parameters.(*ModifyInstanceCreditSpecificationInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -43042,10 +43322,10 @@ func (m *awsEc2query_serializeOpModifyInstanceMaintenanceOptions) HandleSerializ bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("ModifyInstanceMaintenanceOptions") + body.Key("Action").String("ModifyInstanceCreditSpecification") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentModifyInstanceMaintenanceOptionsInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentModifyInstanceCreditSpecificationInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -43068,14 +43348,14 @@ func (m *awsEc2query_serializeOpModifyInstanceMaintenanceOptions) HandleSerializ return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpModifyInstanceMetadataDefaults struct { +type awsEc2query_serializeOpModifyInstanceEventStartTime struct { } -func (*awsEc2query_serializeOpModifyInstanceMetadataDefaults) ID() string { +func (*awsEc2query_serializeOpModifyInstanceEventStartTime) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpModifyInstanceMetadataDefaults) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpModifyInstanceEventStartTime) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -43087,7 +43367,7 @@ func (m *awsEc2query_serializeOpModifyInstanceMetadataDefaults) HandleSerialize( return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ModifyInstanceMetadataDefaultsInput) + input, ok := in.Parameters.(*ModifyInstanceEventStartTimeInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -43112,10 +43392,10 @@ func (m *awsEc2query_serializeOpModifyInstanceMetadataDefaults) HandleSerialize( bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("ModifyInstanceMetadataDefaults") + body.Key("Action").String("ModifyInstanceEventStartTime") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentModifyInstanceMetadataDefaultsInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentModifyInstanceEventStartTimeInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -43138,14 +43418,14 @@ func (m *awsEc2query_serializeOpModifyInstanceMetadataDefaults) HandleSerialize( return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpModifyInstanceMetadataOptions struct { +type awsEc2query_serializeOpModifyInstanceEventWindow struct { } -func (*awsEc2query_serializeOpModifyInstanceMetadataOptions) ID() string { +func (*awsEc2query_serializeOpModifyInstanceEventWindow) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpModifyInstanceMetadataOptions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpModifyInstanceEventWindow) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -43157,7 +43437,7 @@ func (m *awsEc2query_serializeOpModifyInstanceMetadataOptions) HandleSerialize(c return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ModifyInstanceMetadataOptionsInput) + input, ok := in.Parameters.(*ModifyInstanceEventWindowInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -43182,10 +43462,10 @@ func (m *awsEc2query_serializeOpModifyInstanceMetadataOptions) HandleSerialize(c bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("ModifyInstanceMetadataOptions") + body.Key("Action").String("ModifyInstanceEventWindow") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentModifyInstanceMetadataOptionsInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentModifyInstanceEventWindowInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -43208,14 +43488,14 @@ func (m *awsEc2query_serializeOpModifyInstanceMetadataOptions) HandleSerialize(c return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpModifyInstanceNetworkPerformanceOptions struct { +type awsEc2query_serializeOpModifyInstanceMaintenanceOptions struct { } -func (*awsEc2query_serializeOpModifyInstanceNetworkPerformanceOptions) ID() string { +func (*awsEc2query_serializeOpModifyInstanceMaintenanceOptions) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpModifyInstanceNetworkPerformanceOptions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpModifyInstanceMaintenanceOptions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -43227,7 +43507,7 @@ func (m *awsEc2query_serializeOpModifyInstanceNetworkPerformanceOptions) HandleS return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ModifyInstanceNetworkPerformanceOptionsInput) + input, ok := in.Parameters.(*ModifyInstanceMaintenanceOptionsInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -43252,10 +43532,10 @@ func (m *awsEc2query_serializeOpModifyInstanceNetworkPerformanceOptions) HandleS bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("ModifyInstanceNetworkPerformanceOptions") + body.Key("Action").String("ModifyInstanceMaintenanceOptions") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentModifyInstanceNetworkPerformanceOptionsInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentModifyInstanceMaintenanceOptionsInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -43278,14 +43558,14 @@ func (m *awsEc2query_serializeOpModifyInstanceNetworkPerformanceOptions) HandleS return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpModifyInstancePlacement struct { +type awsEc2query_serializeOpModifyInstanceMetadataDefaults struct { } -func (*awsEc2query_serializeOpModifyInstancePlacement) ID() string { +func (*awsEc2query_serializeOpModifyInstanceMetadataDefaults) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpModifyInstancePlacement) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpModifyInstanceMetadataDefaults) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -43297,7 +43577,7 @@ func (m *awsEc2query_serializeOpModifyInstancePlacement) HandleSerialize(ctx con return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ModifyInstancePlacementInput) + input, ok := in.Parameters.(*ModifyInstanceMetadataDefaultsInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -43322,10 +43602,10 @@ func (m *awsEc2query_serializeOpModifyInstancePlacement) HandleSerialize(ctx con bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("ModifyInstancePlacement") + body.Key("Action").String("ModifyInstanceMetadataDefaults") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentModifyInstancePlacementInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentModifyInstanceMetadataDefaultsInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -43348,14 +43628,14 @@ func (m *awsEc2query_serializeOpModifyInstancePlacement) HandleSerialize(ctx con return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpModifyIpam struct { +type awsEc2query_serializeOpModifyInstanceMetadataOptions struct { } -func (*awsEc2query_serializeOpModifyIpam) ID() string { +func (*awsEc2query_serializeOpModifyInstanceMetadataOptions) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpModifyIpam) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpModifyInstanceMetadataOptions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -43367,7 +43647,7 @@ func (m *awsEc2query_serializeOpModifyIpam) HandleSerialize(ctx context.Context, return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ModifyIpamInput) + input, ok := in.Parameters.(*ModifyInstanceMetadataOptionsInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -43392,10 +43672,10 @@ func (m *awsEc2query_serializeOpModifyIpam) HandleSerialize(ctx context.Context, bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("ModifyIpam") + body.Key("Action").String("ModifyInstanceMetadataOptions") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentModifyIpamInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentModifyInstanceMetadataOptionsInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -43418,14 +43698,14 @@ func (m *awsEc2query_serializeOpModifyIpam) HandleSerialize(ctx context.Context, return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpModifyIpamPolicyAllocationRules struct { +type awsEc2query_serializeOpModifyInstanceNetworkPerformanceOptions struct { } -func (*awsEc2query_serializeOpModifyIpamPolicyAllocationRules) ID() string { +func (*awsEc2query_serializeOpModifyInstanceNetworkPerformanceOptions) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpModifyIpamPolicyAllocationRules) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpModifyInstanceNetworkPerformanceOptions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -43437,7 +43717,7 @@ func (m *awsEc2query_serializeOpModifyIpamPolicyAllocationRules) HandleSerialize return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ModifyIpamPolicyAllocationRulesInput) + input, ok := in.Parameters.(*ModifyInstanceNetworkPerformanceOptionsInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -43462,10 +43742,10 @@ func (m *awsEc2query_serializeOpModifyIpamPolicyAllocationRules) HandleSerialize bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("ModifyIpamPolicyAllocationRules") + body.Key("Action").String("ModifyInstanceNetworkPerformanceOptions") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentModifyIpamPolicyAllocationRulesInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentModifyInstanceNetworkPerformanceOptionsInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -43488,14 +43768,14 @@ func (m *awsEc2query_serializeOpModifyIpamPolicyAllocationRules) HandleSerialize return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpModifyIpamPool struct { +type awsEc2query_serializeOpModifyInstancePlacement struct { } -func (*awsEc2query_serializeOpModifyIpamPool) ID() string { +func (*awsEc2query_serializeOpModifyInstancePlacement) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpModifyIpamPool) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpModifyInstancePlacement) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -43507,7 +43787,7 @@ func (m *awsEc2query_serializeOpModifyIpamPool) HandleSerialize(ctx context.Cont return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ModifyIpamPoolInput) + input, ok := in.Parameters.(*ModifyInstancePlacementInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -43532,10 +43812,10 @@ func (m *awsEc2query_serializeOpModifyIpamPool) HandleSerialize(ctx context.Cont bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("ModifyIpamPool") + body.Key("Action").String("ModifyInstancePlacement") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentModifyIpamPoolInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentModifyInstancePlacementInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -43558,14 +43838,14 @@ func (m *awsEc2query_serializeOpModifyIpamPool) HandleSerialize(ctx context.Cont return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpModifyIpamPrefixListResolver struct { +type awsEc2query_serializeOpModifyIpam struct { } -func (*awsEc2query_serializeOpModifyIpamPrefixListResolver) ID() string { +func (*awsEc2query_serializeOpModifyIpam) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpModifyIpamPrefixListResolver) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpModifyIpam) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -43577,7 +43857,7 @@ func (m *awsEc2query_serializeOpModifyIpamPrefixListResolver) HandleSerialize(ct return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ModifyIpamPrefixListResolverInput) + input, ok := in.Parameters.(*ModifyIpamInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -43602,10 +43882,10 @@ func (m *awsEc2query_serializeOpModifyIpamPrefixListResolver) HandleSerialize(ct bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("ModifyIpamPrefixListResolver") + body.Key("Action").String("ModifyIpam") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentModifyIpamPrefixListResolverInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentModifyIpamInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -43628,14 +43908,14 @@ func (m *awsEc2query_serializeOpModifyIpamPrefixListResolver) HandleSerialize(ct return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpModifyIpamPrefixListResolverTarget struct { +type awsEc2query_serializeOpModifyIpamPolicyAllocationRules struct { } -func (*awsEc2query_serializeOpModifyIpamPrefixListResolverTarget) ID() string { +func (*awsEc2query_serializeOpModifyIpamPolicyAllocationRules) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpModifyIpamPrefixListResolverTarget) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpModifyIpamPolicyAllocationRules) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -43647,7 +43927,7 @@ func (m *awsEc2query_serializeOpModifyIpamPrefixListResolverTarget) HandleSerial return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ModifyIpamPrefixListResolverTargetInput) + input, ok := in.Parameters.(*ModifyIpamPolicyAllocationRulesInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -43672,10 +43952,10 @@ func (m *awsEc2query_serializeOpModifyIpamPrefixListResolverTarget) HandleSerial bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("ModifyIpamPrefixListResolverTarget") + body.Key("Action").String("ModifyIpamPolicyAllocationRules") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentModifyIpamPrefixListResolverTargetInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentModifyIpamPolicyAllocationRulesInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -43698,14 +43978,14 @@ func (m *awsEc2query_serializeOpModifyIpamPrefixListResolverTarget) HandleSerial return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpModifyIpamResourceCidr struct { +type awsEc2query_serializeOpModifyIpamPool struct { } -func (*awsEc2query_serializeOpModifyIpamResourceCidr) ID() string { +func (*awsEc2query_serializeOpModifyIpamPool) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpModifyIpamResourceCidr) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpModifyIpamPool) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -43717,7 +43997,7 @@ func (m *awsEc2query_serializeOpModifyIpamResourceCidr) HandleSerialize(ctx cont return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ModifyIpamResourceCidrInput) + input, ok := in.Parameters.(*ModifyIpamPoolInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -43742,10 +44022,10 @@ func (m *awsEc2query_serializeOpModifyIpamResourceCidr) HandleSerialize(ctx cont bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("ModifyIpamResourceCidr") + body.Key("Action").String("ModifyIpamPool") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentModifyIpamResourceCidrInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentModifyIpamPoolInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -43768,14 +44048,14 @@ func (m *awsEc2query_serializeOpModifyIpamResourceCidr) HandleSerialize(ctx cont return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpModifyIpamResourceDiscovery struct { +type awsEc2query_serializeOpModifyIpamPrefixListResolver struct { } -func (*awsEc2query_serializeOpModifyIpamResourceDiscovery) ID() string { +func (*awsEc2query_serializeOpModifyIpamPrefixListResolver) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpModifyIpamResourceDiscovery) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpModifyIpamPrefixListResolver) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -43787,7 +44067,7 @@ func (m *awsEc2query_serializeOpModifyIpamResourceDiscovery) HandleSerialize(ctx return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ModifyIpamResourceDiscoveryInput) + input, ok := in.Parameters.(*ModifyIpamPrefixListResolverInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -43812,10 +44092,10 @@ func (m *awsEc2query_serializeOpModifyIpamResourceDiscovery) HandleSerialize(ctx bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("ModifyIpamResourceDiscovery") + body.Key("Action").String("ModifyIpamPrefixListResolver") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentModifyIpamResourceDiscoveryInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentModifyIpamPrefixListResolverInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -43838,14 +44118,14 @@ func (m *awsEc2query_serializeOpModifyIpamResourceDiscovery) HandleSerialize(ctx return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpModifyIpamScope struct { +type awsEc2query_serializeOpModifyIpamPrefixListResolverTarget struct { } -func (*awsEc2query_serializeOpModifyIpamScope) ID() string { +func (*awsEc2query_serializeOpModifyIpamPrefixListResolverTarget) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpModifyIpamScope) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpModifyIpamPrefixListResolverTarget) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -43857,7 +44137,7 @@ func (m *awsEc2query_serializeOpModifyIpamScope) HandleSerialize(ctx context.Con return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ModifyIpamScopeInput) + input, ok := in.Parameters.(*ModifyIpamPrefixListResolverTargetInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -43882,10 +44162,10 @@ func (m *awsEc2query_serializeOpModifyIpamScope) HandleSerialize(ctx context.Con bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("ModifyIpamScope") + body.Key("Action").String("ModifyIpamPrefixListResolverTarget") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentModifyIpamScopeInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentModifyIpamPrefixListResolverTargetInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -43908,14 +44188,14 @@ func (m *awsEc2query_serializeOpModifyIpamScope) HandleSerialize(ctx context.Con return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpModifyLaunchTemplate struct { +type awsEc2query_serializeOpModifyIpamResourceCidr struct { } -func (*awsEc2query_serializeOpModifyLaunchTemplate) ID() string { +func (*awsEc2query_serializeOpModifyIpamResourceCidr) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpModifyLaunchTemplate) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpModifyIpamResourceCidr) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -43927,7 +44207,7 @@ func (m *awsEc2query_serializeOpModifyLaunchTemplate) HandleSerialize(ctx contex return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ModifyLaunchTemplateInput) + input, ok := in.Parameters.(*ModifyIpamResourceCidrInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -43952,10 +44232,10 @@ func (m *awsEc2query_serializeOpModifyLaunchTemplate) HandleSerialize(ctx contex bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("ModifyLaunchTemplate") + body.Key("Action").String("ModifyIpamResourceCidr") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentModifyLaunchTemplateInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentModifyIpamResourceCidrInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -43978,14 +44258,14 @@ func (m *awsEc2query_serializeOpModifyLaunchTemplate) HandleSerialize(ctx contex return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpModifyLocalGatewayRoute struct { +type awsEc2query_serializeOpModifyIpamResourceDiscovery struct { } -func (*awsEc2query_serializeOpModifyLocalGatewayRoute) ID() string { +func (*awsEc2query_serializeOpModifyIpamResourceDiscovery) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpModifyLocalGatewayRoute) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpModifyIpamResourceDiscovery) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -43997,7 +44277,7 @@ func (m *awsEc2query_serializeOpModifyLocalGatewayRoute) HandleSerialize(ctx con return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ModifyLocalGatewayRouteInput) + input, ok := in.Parameters.(*ModifyIpamResourceDiscoveryInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -44022,10 +44302,10 @@ func (m *awsEc2query_serializeOpModifyLocalGatewayRoute) HandleSerialize(ctx con bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("ModifyLocalGatewayRoute") + body.Key("Action").String("ModifyIpamResourceDiscovery") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentModifyLocalGatewayRouteInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentModifyIpamResourceDiscoveryInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -44048,14 +44328,14 @@ func (m *awsEc2query_serializeOpModifyLocalGatewayRoute) HandleSerialize(ctx con return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpModifyManagedPrefixList struct { +type awsEc2query_serializeOpModifyIpamScope struct { } -func (*awsEc2query_serializeOpModifyManagedPrefixList) ID() string { +func (*awsEc2query_serializeOpModifyIpamScope) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpModifyManagedPrefixList) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpModifyIpamScope) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -44067,7 +44347,7 @@ func (m *awsEc2query_serializeOpModifyManagedPrefixList) HandleSerialize(ctx con return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ModifyManagedPrefixListInput) + input, ok := in.Parameters.(*ModifyIpamScopeInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -44092,10 +44372,10 @@ func (m *awsEc2query_serializeOpModifyManagedPrefixList) HandleSerialize(ctx con bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("ModifyManagedPrefixList") + body.Key("Action").String("ModifyIpamScope") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentModifyManagedPrefixListInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentModifyIpamScopeInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -44118,14 +44398,14 @@ func (m *awsEc2query_serializeOpModifyManagedPrefixList) HandleSerialize(ctx con return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpModifyNetworkInterfaceAttribute struct { +type awsEc2query_serializeOpModifyLaunchTemplate struct { } -func (*awsEc2query_serializeOpModifyNetworkInterfaceAttribute) ID() string { +func (*awsEc2query_serializeOpModifyLaunchTemplate) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpModifyNetworkInterfaceAttribute) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpModifyLaunchTemplate) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -44137,7 +44417,7 @@ func (m *awsEc2query_serializeOpModifyNetworkInterfaceAttribute) HandleSerialize return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ModifyNetworkInterfaceAttributeInput) + input, ok := in.Parameters.(*ModifyLaunchTemplateInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -44162,10 +44442,10 @@ func (m *awsEc2query_serializeOpModifyNetworkInterfaceAttribute) HandleSerialize bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("ModifyNetworkInterfaceAttribute") + body.Key("Action").String("ModifyLaunchTemplate") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentModifyNetworkInterfaceAttributeInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentModifyLaunchTemplateInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -44188,14 +44468,14 @@ func (m *awsEc2query_serializeOpModifyNetworkInterfaceAttribute) HandleSerialize return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpModifyPrivateDnsNameOptions struct { +type awsEc2query_serializeOpModifyLocalGatewayRoute struct { } -func (*awsEc2query_serializeOpModifyPrivateDnsNameOptions) ID() string { +func (*awsEc2query_serializeOpModifyLocalGatewayRoute) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpModifyPrivateDnsNameOptions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpModifyLocalGatewayRoute) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -44207,7 +44487,7 @@ func (m *awsEc2query_serializeOpModifyPrivateDnsNameOptions) HandleSerialize(ctx return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ModifyPrivateDnsNameOptionsInput) + input, ok := in.Parameters.(*ModifyLocalGatewayRouteInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -44232,10 +44512,10 @@ func (m *awsEc2query_serializeOpModifyPrivateDnsNameOptions) HandleSerialize(ctx bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("ModifyPrivateDnsNameOptions") + body.Key("Action").String("ModifyLocalGatewayRoute") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentModifyPrivateDnsNameOptionsInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentModifyLocalGatewayRouteInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -44258,14 +44538,14 @@ func (m *awsEc2query_serializeOpModifyPrivateDnsNameOptions) HandleSerialize(ctx return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpModifyPublicIpDnsNameOptions struct { +type awsEc2query_serializeOpModifyManagedPrefixList struct { } -func (*awsEc2query_serializeOpModifyPublicIpDnsNameOptions) ID() string { +func (*awsEc2query_serializeOpModifyManagedPrefixList) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpModifyPublicIpDnsNameOptions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpModifyManagedPrefixList) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -44277,7 +44557,7 @@ func (m *awsEc2query_serializeOpModifyPublicIpDnsNameOptions) HandleSerialize(ct return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ModifyPublicIpDnsNameOptionsInput) + input, ok := in.Parameters.(*ModifyManagedPrefixListInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -44302,10 +44582,10 @@ func (m *awsEc2query_serializeOpModifyPublicIpDnsNameOptions) HandleSerialize(ct bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("ModifyPublicIpDnsNameOptions") + body.Key("Action").String("ModifyManagedPrefixList") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentModifyPublicIpDnsNameOptionsInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentModifyManagedPrefixListInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -44328,14 +44608,14 @@ func (m *awsEc2query_serializeOpModifyPublicIpDnsNameOptions) HandleSerialize(ct return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpModifyReservedInstances struct { +type awsEc2query_serializeOpModifyNetworkInterfaceAttribute struct { } -func (*awsEc2query_serializeOpModifyReservedInstances) ID() string { +func (*awsEc2query_serializeOpModifyNetworkInterfaceAttribute) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpModifyReservedInstances) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpModifyNetworkInterfaceAttribute) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -44347,7 +44627,7 @@ func (m *awsEc2query_serializeOpModifyReservedInstances) HandleSerialize(ctx con return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ModifyReservedInstancesInput) + input, ok := in.Parameters.(*ModifyNetworkInterfaceAttributeInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -44372,10 +44652,10 @@ func (m *awsEc2query_serializeOpModifyReservedInstances) HandleSerialize(ctx con bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("ModifyReservedInstances") + body.Key("Action").String("ModifyNetworkInterfaceAttribute") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentModifyReservedInstancesInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentModifyNetworkInterfaceAttributeInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -44398,14 +44678,14 @@ func (m *awsEc2query_serializeOpModifyReservedInstances) HandleSerialize(ctx con return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpModifyRouteServer struct { +type awsEc2query_serializeOpModifyPrivateDnsNameOptions struct { } -func (*awsEc2query_serializeOpModifyRouteServer) ID() string { +func (*awsEc2query_serializeOpModifyPrivateDnsNameOptions) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpModifyRouteServer) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpModifyPrivateDnsNameOptions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -44417,7 +44697,7 @@ func (m *awsEc2query_serializeOpModifyRouteServer) HandleSerialize(ctx context.C return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ModifyRouteServerInput) + input, ok := in.Parameters.(*ModifyPrivateDnsNameOptionsInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -44442,10 +44722,10 @@ func (m *awsEc2query_serializeOpModifyRouteServer) HandleSerialize(ctx context.C bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("ModifyRouteServer") + body.Key("Action").String("ModifyPrivateDnsNameOptions") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentModifyRouteServerInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentModifyPrivateDnsNameOptionsInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -44468,14 +44748,14 @@ func (m *awsEc2query_serializeOpModifyRouteServer) HandleSerialize(ctx context.C return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpModifySecurityGroupRules struct { +type awsEc2query_serializeOpModifyPublicIpDnsNameOptions struct { } -func (*awsEc2query_serializeOpModifySecurityGroupRules) ID() string { +func (*awsEc2query_serializeOpModifyPublicIpDnsNameOptions) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpModifySecurityGroupRules) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpModifyPublicIpDnsNameOptions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -44487,7 +44767,7 @@ func (m *awsEc2query_serializeOpModifySecurityGroupRules) HandleSerialize(ctx co return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ModifySecurityGroupRulesInput) + input, ok := in.Parameters.(*ModifyPublicIpDnsNameOptionsInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -44512,10 +44792,10 @@ func (m *awsEc2query_serializeOpModifySecurityGroupRules) HandleSerialize(ctx co bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("ModifySecurityGroupRules") + body.Key("Action").String("ModifyPublicIpDnsNameOptions") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentModifySecurityGroupRulesInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentModifyPublicIpDnsNameOptionsInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -44538,14 +44818,14 @@ func (m *awsEc2query_serializeOpModifySecurityGroupRules) HandleSerialize(ctx co return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpModifySnapshotAttribute struct { +type awsEc2query_serializeOpModifyReservedInstances struct { } -func (*awsEc2query_serializeOpModifySnapshotAttribute) ID() string { +func (*awsEc2query_serializeOpModifyReservedInstances) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpModifySnapshotAttribute) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpModifyReservedInstances) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -44557,7 +44837,7 @@ func (m *awsEc2query_serializeOpModifySnapshotAttribute) HandleSerialize(ctx con return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ModifySnapshotAttributeInput) + input, ok := in.Parameters.(*ModifyReservedInstancesInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -44582,10 +44862,10 @@ func (m *awsEc2query_serializeOpModifySnapshotAttribute) HandleSerialize(ctx con bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("ModifySnapshotAttribute") + body.Key("Action").String("ModifyReservedInstances") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentModifySnapshotAttributeInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentModifyReservedInstancesInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -44608,14 +44888,14 @@ func (m *awsEc2query_serializeOpModifySnapshotAttribute) HandleSerialize(ctx con return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpModifySnapshotTier struct { +type awsEc2query_serializeOpModifyRouteServer struct { } -func (*awsEc2query_serializeOpModifySnapshotTier) ID() string { +func (*awsEc2query_serializeOpModifyRouteServer) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpModifySnapshotTier) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpModifyRouteServer) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -44627,7 +44907,7 @@ func (m *awsEc2query_serializeOpModifySnapshotTier) HandleSerialize(ctx context. return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ModifySnapshotTierInput) + input, ok := in.Parameters.(*ModifyRouteServerInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -44652,10 +44932,10 @@ func (m *awsEc2query_serializeOpModifySnapshotTier) HandleSerialize(ctx context. bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("ModifySnapshotTier") + body.Key("Action").String("ModifyRouteServer") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentModifySnapshotTierInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentModifyRouteServerInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -44678,14 +44958,14 @@ func (m *awsEc2query_serializeOpModifySnapshotTier) HandleSerialize(ctx context. return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpModifySpotFleetRequest struct { +type awsEc2query_serializeOpModifySecurityGroupRules struct { } -func (*awsEc2query_serializeOpModifySpotFleetRequest) ID() string { +func (*awsEc2query_serializeOpModifySecurityGroupRules) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpModifySpotFleetRequest) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpModifySecurityGroupRules) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -44697,7 +44977,7 @@ func (m *awsEc2query_serializeOpModifySpotFleetRequest) HandleSerialize(ctx cont return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ModifySpotFleetRequestInput) + input, ok := in.Parameters.(*ModifySecurityGroupRulesInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -44722,10 +45002,10 @@ func (m *awsEc2query_serializeOpModifySpotFleetRequest) HandleSerialize(ctx cont bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("ModifySpotFleetRequest") + body.Key("Action").String("ModifySecurityGroupRules") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentModifySpotFleetRequestInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentModifySecurityGroupRulesInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -44748,14 +45028,14 @@ func (m *awsEc2query_serializeOpModifySpotFleetRequest) HandleSerialize(ctx cont return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpModifySubnetAttribute struct { +type awsEc2query_serializeOpModifySnapshotAttribute struct { } -func (*awsEc2query_serializeOpModifySubnetAttribute) ID() string { +func (*awsEc2query_serializeOpModifySnapshotAttribute) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpModifySubnetAttribute) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpModifySnapshotAttribute) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -44767,7 +45047,7 @@ func (m *awsEc2query_serializeOpModifySubnetAttribute) HandleSerialize(ctx conte return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ModifySubnetAttributeInput) + input, ok := in.Parameters.(*ModifySnapshotAttributeInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -44792,10 +45072,10 @@ func (m *awsEc2query_serializeOpModifySubnetAttribute) HandleSerialize(ctx conte bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("ModifySubnetAttribute") + body.Key("Action").String("ModifySnapshotAttribute") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentModifySubnetAttributeInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentModifySnapshotAttributeInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -44818,14 +45098,14 @@ func (m *awsEc2query_serializeOpModifySubnetAttribute) HandleSerialize(ctx conte return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpModifyTrafficMirrorFilterNetworkServices struct { +type awsEc2query_serializeOpModifySnapshotTier struct { } -func (*awsEc2query_serializeOpModifyTrafficMirrorFilterNetworkServices) ID() string { +func (*awsEc2query_serializeOpModifySnapshotTier) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpModifyTrafficMirrorFilterNetworkServices) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpModifySnapshotTier) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -44837,7 +45117,7 @@ func (m *awsEc2query_serializeOpModifyTrafficMirrorFilterNetworkServices) Handle return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ModifyTrafficMirrorFilterNetworkServicesInput) + input, ok := in.Parameters.(*ModifySnapshotTierInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -44862,10 +45142,10 @@ func (m *awsEc2query_serializeOpModifyTrafficMirrorFilterNetworkServices) Handle bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("ModifyTrafficMirrorFilterNetworkServices") + body.Key("Action").String("ModifySnapshotTier") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentModifyTrafficMirrorFilterNetworkServicesInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentModifySnapshotTierInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -44888,14 +45168,14 @@ func (m *awsEc2query_serializeOpModifyTrafficMirrorFilterNetworkServices) Handle return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpModifyTrafficMirrorFilterRule struct { +type awsEc2query_serializeOpModifySpotFleetRequest struct { } -func (*awsEc2query_serializeOpModifyTrafficMirrorFilterRule) ID() string { +func (*awsEc2query_serializeOpModifySpotFleetRequest) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpModifyTrafficMirrorFilterRule) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpModifySpotFleetRequest) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -44907,7 +45187,7 @@ func (m *awsEc2query_serializeOpModifyTrafficMirrorFilterRule) HandleSerialize(c return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ModifyTrafficMirrorFilterRuleInput) + input, ok := in.Parameters.(*ModifySpotFleetRequestInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -44932,10 +45212,10 @@ func (m *awsEc2query_serializeOpModifyTrafficMirrorFilterRule) HandleSerialize(c bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("ModifyTrafficMirrorFilterRule") + body.Key("Action").String("ModifySpotFleetRequest") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentModifyTrafficMirrorFilterRuleInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentModifySpotFleetRequestInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -44958,14 +45238,14 @@ func (m *awsEc2query_serializeOpModifyTrafficMirrorFilterRule) HandleSerialize(c return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpModifyTrafficMirrorSession struct { +type awsEc2query_serializeOpModifySubnetAttribute struct { } -func (*awsEc2query_serializeOpModifyTrafficMirrorSession) ID() string { +func (*awsEc2query_serializeOpModifySubnetAttribute) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpModifyTrafficMirrorSession) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpModifySubnetAttribute) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -44977,7 +45257,7 @@ func (m *awsEc2query_serializeOpModifyTrafficMirrorSession) HandleSerialize(ctx return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ModifyTrafficMirrorSessionInput) + input, ok := in.Parameters.(*ModifySubnetAttributeInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -45002,10 +45282,10 @@ func (m *awsEc2query_serializeOpModifyTrafficMirrorSession) HandleSerialize(ctx bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("ModifyTrafficMirrorSession") + body.Key("Action").String("ModifySubnetAttribute") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentModifyTrafficMirrorSessionInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentModifySubnetAttributeInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -45028,14 +45308,14 @@ func (m *awsEc2query_serializeOpModifyTrafficMirrorSession) HandleSerialize(ctx return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpModifyTransitGateway struct { +type awsEc2query_serializeOpModifyTrafficMirrorFilterNetworkServices struct { } -func (*awsEc2query_serializeOpModifyTransitGateway) ID() string { +func (*awsEc2query_serializeOpModifyTrafficMirrorFilterNetworkServices) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpModifyTransitGateway) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpModifyTrafficMirrorFilterNetworkServices) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -45047,7 +45327,7 @@ func (m *awsEc2query_serializeOpModifyTransitGateway) HandleSerialize(ctx contex return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ModifyTransitGatewayInput) + input, ok := in.Parameters.(*ModifyTrafficMirrorFilterNetworkServicesInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -45072,10 +45352,10 @@ func (m *awsEc2query_serializeOpModifyTransitGateway) HandleSerialize(ctx contex bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("ModifyTransitGateway") + body.Key("Action").String("ModifyTrafficMirrorFilterNetworkServices") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentModifyTransitGatewayInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentModifyTrafficMirrorFilterNetworkServicesInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -45098,14 +45378,14 @@ func (m *awsEc2query_serializeOpModifyTransitGateway) HandleSerialize(ctx contex return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpModifyTransitGatewayMeteringPolicy struct { +type awsEc2query_serializeOpModifyTrafficMirrorFilterRule struct { } -func (*awsEc2query_serializeOpModifyTransitGatewayMeteringPolicy) ID() string { +func (*awsEc2query_serializeOpModifyTrafficMirrorFilterRule) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpModifyTransitGatewayMeteringPolicy) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpModifyTrafficMirrorFilterRule) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -45117,7 +45397,7 @@ func (m *awsEc2query_serializeOpModifyTransitGatewayMeteringPolicy) HandleSerial return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ModifyTransitGatewayMeteringPolicyInput) + input, ok := in.Parameters.(*ModifyTrafficMirrorFilterRuleInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -45142,10 +45422,10 @@ func (m *awsEc2query_serializeOpModifyTransitGatewayMeteringPolicy) HandleSerial bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("ModifyTransitGatewayMeteringPolicy") + body.Key("Action").String("ModifyTrafficMirrorFilterRule") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentModifyTransitGatewayMeteringPolicyInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentModifyTrafficMirrorFilterRuleInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -45168,14 +45448,14 @@ func (m *awsEc2query_serializeOpModifyTransitGatewayMeteringPolicy) HandleSerial return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpModifyTransitGatewayPrefixListReference struct { +type awsEc2query_serializeOpModifyTrafficMirrorSession struct { } -func (*awsEc2query_serializeOpModifyTransitGatewayPrefixListReference) ID() string { +func (*awsEc2query_serializeOpModifyTrafficMirrorSession) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpModifyTransitGatewayPrefixListReference) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpModifyTrafficMirrorSession) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -45187,7 +45467,7 @@ func (m *awsEc2query_serializeOpModifyTransitGatewayPrefixListReference) HandleS return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ModifyTransitGatewayPrefixListReferenceInput) + input, ok := in.Parameters.(*ModifyTrafficMirrorSessionInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -45212,10 +45492,10 @@ func (m *awsEc2query_serializeOpModifyTransitGatewayPrefixListReference) HandleS bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("ModifyTransitGatewayPrefixListReference") + body.Key("Action").String("ModifyTrafficMirrorSession") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentModifyTransitGatewayPrefixListReferenceInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentModifyTrafficMirrorSessionInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -45238,14 +45518,14 @@ func (m *awsEc2query_serializeOpModifyTransitGatewayPrefixListReference) HandleS return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpModifyTransitGatewayVpcAttachment struct { +type awsEc2query_serializeOpModifyTransitGateway struct { } -func (*awsEc2query_serializeOpModifyTransitGatewayVpcAttachment) ID() string { +func (*awsEc2query_serializeOpModifyTransitGateway) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpModifyTransitGatewayVpcAttachment) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpModifyTransitGateway) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -45257,7 +45537,7 @@ func (m *awsEc2query_serializeOpModifyTransitGatewayVpcAttachment) HandleSeriali return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ModifyTransitGatewayVpcAttachmentInput) + input, ok := in.Parameters.(*ModifyTransitGatewayInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -45282,10 +45562,10 @@ func (m *awsEc2query_serializeOpModifyTransitGatewayVpcAttachment) HandleSeriali bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("ModifyTransitGatewayVpcAttachment") + body.Key("Action").String("ModifyTransitGateway") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentModifyTransitGatewayVpcAttachmentInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentModifyTransitGatewayInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -45308,14 +45588,14 @@ func (m *awsEc2query_serializeOpModifyTransitGatewayVpcAttachment) HandleSeriali return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpModifyVerifiedAccessEndpoint struct { +type awsEc2query_serializeOpModifyTransitGatewayMeteringPolicy struct { } -func (*awsEc2query_serializeOpModifyVerifiedAccessEndpoint) ID() string { +func (*awsEc2query_serializeOpModifyTransitGatewayMeteringPolicy) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpModifyVerifiedAccessEndpoint) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpModifyTransitGatewayMeteringPolicy) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -45327,7 +45607,7 @@ func (m *awsEc2query_serializeOpModifyVerifiedAccessEndpoint) HandleSerialize(ct return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ModifyVerifiedAccessEndpointInput) + input, ok := in.Parameters.(*ModifyTransitGatewayMeteringPolicyInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -45352,10 +45632,10 @@ func (m *awsEc2query_serializeOpModifyVerifiedAccessEndpoint) HandleSerialize(ct bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("ModifyVerifiedAccessEndpoint") + body.Key("Action").String("ModifyTransitGatewayMeteringPolicy") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentModifyVerifiedAccessEndpointInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentModifyTransitGatewayMeteringPolicyInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -45378,14 +45658,14 @@ func (m *awsEc2query_serializeOpModifyVerifiedAccessEndpoint) HandleSerialize(ct return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpModifyVerifiedAccessEndpointPolicy struct { +type awsEc2query_serializeOpModifyTransitGatewayPrefixListReference struct { } -func (*awsEc2query_serializeOpModifyVerifiedAccessEndpointPolicy) ID() string { +func (*awsEc2query_serializeOpModifyTransitGatewayPrefixListReference) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpModifyVerifiedAccessEndpointPolicy) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpModifyTransitGatewayPrefixListReference) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -45397,7 +45677,7 @@ func (m *awsEc2query_serializeOpModifyVerifiedAccessEndpointPolicy) HandleSerial return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ModifyVerifiedAccessEndpointPolicyInput) + input, ok := in.Parameters.(*ModifyTransitGatewayPrefixListReferenceInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -45422,10 +45702,10 @@ func (m *awsEc2query_serializeOpModifyVerifiedAccessEndpointPolicy) HandleSerial bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("ModifyVerifiedAccessEndpointPolicy") + body.Key("Action").String("ModifyTransitGatewayPrefixListReference") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentModifyVerifiedAccessEndpointPolicyInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentModifyTransitGatewayPrefixListReferenceInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -45448,14 +45728,14 @@ func (m *awsEc2query_serializeOpModifyVerifiedAccessEndpointPolicy) HandleSerial return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpModifyVerifiedAccessGroup struct { +type awsEc2query_serializeOpModifyTransitGatewayVpcAttachment struct { } -func (*awsEc2query_serializeOpModifyVerifiedAccessGroup) ID() string { +func (*awsEc2query_serializeOpModifyTransitGatewayVpcAttachment) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpModifyVerifiedAccessGroup) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpModifyTransitGatewayVpcAttachment) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -45467,7 +45747,7 @@ func (m *awsEc2query_serializeOpModifyVerifiedAccessGroup) HandleSerialize(ctx c return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ModifyVerifiedAccessGroupInput) + input, ok := in.Parameters.(*ModifyTransitGatewayVpcAttachmentInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -45492,10 +45772,10 @@ func (m *awsEc2query_serializeOpModifyVerifiedAccessGroup) HandleSerialize(ctx c bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("ModifyVerifiedAccessGroup") + body.Key("Action").String("ModifyTransitGatewayVpcAttachment") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentModifyVerifiedAccessGroupInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentModifyTransitGatewayVpcAttachmentInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -45518,14 +45798,14 @@ func (m *awsEc2query_serializeOpModifyVerifiedAccessGroup) HandleSerialize(ctx c return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpModifyVerifiedAccessGroupPolicy struct { +type awsEc2query_serializeOpModifyVerifiedAccessEndpoint struct { } -func (*awsEc2query_serializeOpModifyVerifiedAccessGroupPolicy) ID() string { +func (*awsEc2query_serializeOpModifyVerifiedAccessEndpoint) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpModifyVerifiedAccessGroupPolicy) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpModifyVerifiedAccessEndpoint) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -45537,7 +45817,7 @@ func (m *awsEc2query_serializeOpModifyVerifiedAccessGroupPolicy) HandleSerialize return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ModifyVerifiedAccessGroupPolicyInput) + input, ok := in.Parameters.(*ModifyVerifiedAccessEndpointInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -45562,10 +45842,10 @@ func (m *awsEc2query_serializeOpModifyVerifiedAccessGroupPolicy) HandleSerialize bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("ModifyVerifiedAccessGroupPolicy") + body.Key("Action").String("ModifyVerifiedAccessEndpoint") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentModifyVerifiedAccessGroupPolicyInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentModifyVerifiedAccessEndpointInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -45588,14 +45868,14 @@ func (m *awsEc2query_serializeOpModifyVerifiedAccessGroupPolicy) HandleSerialize return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpModifyVerifiedAccessInstance struct { +type awsEc2query_serializeOpModifyVerifiedAccessEndpointPolicy struct { } -func (*awsEc2query_serializeOpModifyVerifiedAccessInstance) ID() string { +func (*awsEc2query_serializeOpModifyVerifiedAccessEndpointPolicy) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpModifyVerifiedAccessInstance) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpModifyVerifiedAccessEndpointPolicy) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -45607,7 +45887,7 @@ func (m *awsEc2query_serializeOpModifyVerifiedAccessInstance) HandleSerialize(ct return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ModifyVerifiedAccessInstanceInput) + input, ok := in.Parameters.(*ModifyVerifiedAccessEndpointPolicyInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -45632,10 +45912,10 @@ func (m *awsEc2query_serializeOpModifyVerifiedAccessInstance) HandleSerialize(ct bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("ModifyVerifiedAccessInstance") + body.Key("Action").String("ModifyVerifiedAccessEndpointPolicy") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentModifyVerifiedAccessInstanceInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentModifyVerifiedAccessEndpointPolicyInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -45658,14 +45938,14 @@ func (m *awsEc2query_serializeOpModifyVerifiedAccessInstance) HandleSerialize(ct return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpModifyVerifiedAccessInstanceLoggingConfiguration struct { +type awsEc2query_serializeOpModifyVerifiedAccessGroup struct { } -func (*awsEc2query_serializeOpModifyVerifiedAccessInstanceLoggingConfiguration) ID() string { +func (*awsEc2query_serializeOpModifyVerifiedAccessGroup) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpModifyVerifiedAccessInstanceLoggingConfiguration) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpModifyVerifiedAccessGroup) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -45677,7 +45957,7 @@ func (m *awsEc2query_serializeOpModifyVerifiedAccessInstanceLoggingConfiguration return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ModifyVerifiedAccessInstanceLoggingConfigurationInput) + input, ok := in.Parameters.(*ModifyVerifiedAccessGroupInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -45702,10 +45982,10 @@ func (m *awsEc2query_serializeOpModifyVerifiedAccessInstanceLoggingConfiguration bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("ModifyVerifiedAccessInstanceLoggingConfiguration") + body.Key("Action").String("ModifyVerifiedAccessGroup") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentModifyVerifiedAccessInstanceLoggingConfigurationInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentModifyVerifiedAccessGroupInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -45728,14 +46008,14 @@ func (m *awsEc2query_serializeOpModifyVerifiedAccessInstanceLoggingConfiguration return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpModifyVerifiedAccessTrustProvider struct { +type awsEc2query_serializeOpModifyVerifiedAccessGroupPolicy struct { } -func (*awsEc2query_serializeOpModifyVerifiedAccessTrustProvider) ID() string { +func (*awsEc2query_serializeOpModifyVerifiedAccessGroupPolicy) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpModifyVerifiedAccessTrustProvider) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpModifyVerifiedAccessGroupPolicy) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -45747,7 +46027,7 @@ func (m *awsEc2query_serializeOpModifyVerifiedAccessTrustProvider) HandleSeriali return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ModifyVerifiedAccessTrustProviderInput) + input, ok := in.Parameters.(*ModifyVerifiedAccessGroupPolicyInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -45772,10 +46052,10 @@ func (m *awsEc2query_serializeOpModifyVerifiedAccessTrustProvider) HandleSeriali bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("ModifyVerifiedAccessTrustProvider") + body.Key("Action").String("ModifyVerifiedAccessGroupPolicy") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentModifyVerifiedAccessTrustProviderInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentModifyVerifiedAccessGroupPolicyInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -45798,14 +46078,14 @@ func (m *awsEc2query_serializeOpModifyVerifiedAccessTrustProvider) HandleSeriali return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpModifyVolume struct { +type awsEc2query_serializeOpModifyVerifiedAccessInstance struct { } -func (*awsEc2query_serializeOpModifyVolume) ID() string { +func (*awsEc2query_serializeOpModifyVerifiedAccessInstance) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpModifyVolume) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpModifyVerifiedAccessInstance) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -45817,7 +46097,7 @@ func (m *awsEc2query_serializeOpModifyVolume) HandleSerialize(ctx context.Contex return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ModifyVolumeInput) + input, ok := in.Parameters.(*ModifyVerifiedAccessInstanceInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -45842,10 +46122,10 @@ func (m *awsEc2query_serializeOpModifyVolume) HandleSerialize(ctx context.Contex bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("ModifyVolume") + body.Key("Action").String("ModifyVerifiedAccessInstance") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentModifyVolumeInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentModifyVerifiedAccessInstanceInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -45868,14 +46148,14 @@ func (m *awsEc2query_serializeOpModifyVolume) HandleSerialize(ctx context.Contex return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpModifyVolumeAttribute struct { +type awsEc2query_serializeOpModifyVerifiedAccessInstanceLoggingConfiguration struct { } -func (*awsEc2query_serializeOpModifyVolumeAttribute) ID() string { +func (*awsEc2query_serializeOpModifyVerifiedAccessInstanceLoggingConfiguration) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpModifyVolumeAttribute) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpModifyVerifiedAccessInstanceLoggingConfiguration) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -45887,7 +46167,7 @@ func (m *awsEc2query_serializeOpModifyVolumeAttribute) HandleSerialize(ctx conte return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ModifyVolumeAttributeInput) + input, ok := in.Parameters.(*ModifyVerifiedAccessInstanceLoggingConfigurationInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -45912,10 +46192,10 @@ func (m *awsEc2query_serializeOpModifyVolumeAttribute) HandleSerialize(ctx conte bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("ModifyVolumeAttribute") + body.Key("Action").String("ModifyVerifiedAccessInstanceLoggingConfiguration") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentModifyVolumeAttributeInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentModifyVerifiedAccessInstanceLoggingConfigurationInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -45938,14 +46218,14 @@ func (m *awsEc2query_serializeOpModifyVolumeAttribute) HandleSerialize(ctx conte return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpModifyVpcAttribute struct { +type awsEc2query_serializeOpModifyVerifiedAccessTrustProvider struct { } -func (*awsEc2query_serializeOpModifyVpcAttribute) ID() string { +func (*awsEc2query_serializeOpModifyVerifiedAccessTrustProvider) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpModifyVpcAttribute) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpModifyVerifiedAccessTrustProvider) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -45957,7 +46237,7 @@ func (m *awsEc2query_serializeOpModifyVpcAttribute) HandleSerialize(ctx context. return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ModifyVpcAttributeInput) + input, ok := in.Parameters.(*ModifyVerifiedAccessTrustProviderInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -45982,10 +46262,10 @@ func (m *awsEc2query_serializeOpModifyVpcAttribute) HandleSerialize(ctx context. bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("ModifyVpcAttribute") + body.Key("Action").String("ModifyVerifiedAccessTrustProvider") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentModifyVpcAttributeInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentModifyVerifiedAccessTrustProviderInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -46008,14 +46288,14 @@ func (m *awsEc2query_serializeOpModifyVpcAttribute) HandleSerialize(ctx context. return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpModifyVpcBlockPublicAccessExclusion struct { +type awsEc2query_serializeOpModifyVolume struct { } -func (*awsEc2query_serializeOpModifyVpcBlockPublicAccessExclusion) ID() string { +func (*awsEc2query_serializeOpModifyVolume) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpModifyVpcBlockPublicAccessExclusion) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpModifyVolume) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -46027,7 +46307,7 @@ func (m *awsEc2query_serializeOpModifyVpcBlockPublicAccessExclusion) HandleSeria return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ModifyVpcBlockPublicAccessExclusionInput) + input, ok := in.Parameters.(*ModifyVolumeInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -46052,10 +46332,10 @@ func (m *awsEc2query_serializeOpModifyVpcBlockPublicAccessExclusion) HandleSeria bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("ModifyVpcBlockPublicAccessExclusion") + body.Key("Action").String("ModifyVolume") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentModifyVpcBlockPublicAccessExclusionInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentModifyVolumeInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -46078,14 +46358,14 @@ func (m *awsEc2query_serializeOpModifyVpcBlockPublicAccessExclusion) HandleSeria return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpModifyVpcBlockPublicAccessOptions struct { +type awsEc2query_serializeOpModifyVolumeAttribute struct { } -func (*awsEc2query_serializeOpModifyVpcBlockPublicAccessOptions) ID() string { +func (*awsEc2query_serializeOpModifyVolumeAttribute) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpModifyVpcBlockPublicAccessOptions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpModifyVolumeAttribute) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -46097,7 +46377,7 @@ func (m *awsEc2query_serializeOpModifyVpcBlockPublicAccessOptions) HandleSeriali return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ModifyVpcBlockPublicAccessOptionsInput) + input, ok := in.Parameters.(*ModifyVolumeAttributeInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -46122,10 +46402,10 @@ func (m *awsEc2query_serializeOpModifyVpcBlockPublicAccessOptions) HandleSeriali bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("ModifyVpcBlockPublicAccessOptions") + body.Key("Action").String("ModifyVolumeAttribute") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentModifyVpcBlockPublicAccessOptionsInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentModifyVolumeAttributeInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -46148,14 +46428,14 @@ func (m *awsEc2query_serializeOpModifyVpcBlockPublicAccessOptions) HandleSeriali return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpModifyVpcEncryptionControl struct { +type awsEc2query_serializeOpModifyVpcAttribute struct { } -func (*awsEc2query_serializeOpModifyVpcEncryptionControl) ID() string { +func (*awsEc2query_serializeOpModifyVpcAttribute) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpModifyVpcEncryptionControl) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpModifyVpcAttribute) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -46167,7 +46447,7 @@ func (m *awsEc2query_serializeOpModifyVpcEncryptionControl) HandleSerialize(ctx return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ModifyVpcEncryptionControlInput) + input, ok := in.Parameters.(*ModifyVpcAttributeInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -46192,10 +46472,10 @@ func (m *awsEc2query_serializeOpModifyVpcEncryptionControl) HandleSerialize(ctx bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("ModifyVpcEncryptionControl") + body.Key("Action").String("ModifyVpcAttribute") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentModifyVpcEncryptionControlInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentModifyVpcAttributeInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -46218,14 +46498,14 @@ func (m *awsEc2query_serializeOpModifyVpcEncryptionControl) HandleSerialize(ctx return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpModifyVpcEndpoint struct { +type awsEc2query_serializeOpModifyVpcBlockPublicAccessExclusion struct { } -func (*awsEc2query_serializeOpModifyVpcEndpoint) ID() string { +func (*awsEc2query_serializeOpModifyVpcBlockPublicAccessExclusion) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpModifyVpcEndpoint) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpModifyVpcBlockPublicAccessExclusion) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -46237,7 +46517,7 @@ func (m *awsEc2query_serializeOpModifyVpcEndpoint) HandleSerialize(ctx context.C return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ModifyVpcEndpointInput) + input, ok := in.Parameters.(*ModifyVpcBlockPublicAccessExclusionInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -46262,10 +46542,10 @@ func (m *awsEc2query_serializeOpModifyVpcEndpoint) HandleSerialize(ctx context.C bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("ModifyVpcEndpoint") + body.Key("Action").String("ModifyVpcBlockPublicAccessExclusion") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentModifyVpcEndpointInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentModifyVpcBlockPublicAccessExclusionInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -46288,14 +46568,14 @@ func (m *awsEc2query_serializeOpModifyVpcEndpoint) HandleSerialize(ctx context.C return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpModifyVpcEndpointConnectionNotification struct { +type awsEc2query_serializeOpModifyVpcBlockPublicAccessOptions struct { } -func (*awsEc2query_serializeOpModifyVpcEndpointConnectionNotification) ID() string { +func (*awsEc2query_serializeOpModifyVpcBlockPublicAccessOptions) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpModifyVpcEndpointConnectionNotification) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpModifyVpcBlockPublicAccessOptions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -46307,7 +46587,7 @@ func (m *awsEc2query_serializeOpModifyVpcEndpointConnectionNotification) HandleS return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ModifyVpcEndpointConnectionNotificationInput) + input, ok := in.Parameters.(*ModifyVpcBlockPublicAccessOptionsInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -46332,10 +46612,10 @@ func (m *awsEc2query_serializeOpModifyVpcEndpointConnectionNotification) HandleS bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("ModifyVpcEndpointConnectionNotification") + body.Key("Action").String("ModifyVpcBlockPublicAccessOptions") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentModifyVpcEndpointConnectionNotificationInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentModifyVpcBlockPublicAccessOptionsInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -46358,14 +46638,14 @@ func (m *awsEc2query_serializeOpModifyVpcEndpointConnectionNotification) HandleS return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpModifyVpcEndpointServiceConfiguration struct { +type awsEc2query_serializeOpModifyVpcEncryptionControl struct { } -func (*awsEc2query_serializeOpModifyVpcEndpointServiceConfiguration) ID() string { +func (*awsEc2query_serializeOpModifyVpcEncryptionControl) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpModifyVpcEndpointServiceConfiguration) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpModifyVpcEncryptionControl) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -46377,7 +46657,7 @@ func (m *awsEc2query_serializeOpModifyVpcEndpointServiceConfiguration) HandleSer return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ModifyVpcEndpointServiceConfigurationInput) + input, ok := in.Parameters.(*ModifyVpcEncryptionControlInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -46402,10 +46682,10 @@ func (m *awsEc2query_serializeOpModifyVpcEndpointServiceConfiguration) HandleSer bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("ModifyVpcEndpointServiceConfiguration") + body.Key("Action").String("ModifyVpcEncryptionControl") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentModifyVpcEndpointServiceConfigurationInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentModifyVpcEncryptionControlInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -46428,14 +46708,14 @@ func (m *awsEc2query_serializeOpModifyVpcEndpointServiceConfiguration) HandleSer return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpModifyVpcEndpointServicePayerResponsibility struct { +type awsEc2query_serializeOpModifyVpcEndpoint struct { } -func (*awsEc2query_serializeOpModifyVpcEndpointServicePayerResponsibility) ID() string { +func (*awsEc2query_serializeOpModifyVpcEndpoint) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpModifyVpcEndpointServicePayerResponsibility) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpModifyVpcEndpoint) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -46447,7 +46727,7 @@ func (m *awsEc2query_serializeOpModifyVpcEndpointServicePayerResponsibility) Han return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ModifyVpcEndpointServicePayerResponsibilityInput) + input, ok := in.Parameters.(*ModifyVpcEndpointInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -46472,10 +46752,10 @@ func (m *awsEc2query_serializeOpModifyVpcEndpointServicePayerResponsibility) Han bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("ModifyVpcEndpointServicePayerResponsibility") + body.Key("Action").String("ModifyVpcEndpoint") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentModifyVpcEndpointServicePayerResponsibilityInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentModifyVpcEndpointInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -46498,14 +46778,14 @@ func (m *awsEc2query_serializeOpModifyVpcEndpointServicePayerResponsibility) Han return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpModifyVpcEndpointServicePermissions struct { +type awsEc2query_serializeOpModifyVpcEndpointConnectionNotification struct { } -func (*awsEc2query_serializeOpModifyVpcEndpointServicePermissions) ID() string { +func (*awsEc2query_serializeOpModifyVpcEndpointConnectionNotification) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpModifyVpcEndpointServicePermissions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpModifyVpcEndpointConnectionNotification) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -46517,7 +46797,7 @@ func (m *awsEc2query_serializeOpModifyVpcEndpointServicePermissions) HandleSeria return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ModifyVpcEndpointServicePermissionsInput) + input, ok := in.Parameters.(*ModifyVpcEndpointConnectionNotificationInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -46542,10 +46822,10 @@ func (m *awsEc2query_serializeOpModifyVpcEndpointServicePermissions) HandleSeria bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("ModifyVpcEndpointServicePermissions") + body.Key("Action").String("ModifyVpcEndpointConnectionNotification") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentModifyVpcEndpointServicePermissionsInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentModifyVpcEndpointConnectionNotificationInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -46568,14 +46848,14 @@ func (m *awsEc2query_serializeOpModifyVpcEndpointServicePermissions) HandleSeria return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpModifyVpcPeeringConnectionOptions struct { +type awsEc2query_serializeOpModifyVpcEndpointServiceConfiguration struct { } -func (*awsEc2query_serializeOpModifyVpcPeeringConnectionOptions) ID() string { +func (*awsEc2query_serializeOpModifyVpcEndpointServiceConfiguration) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpModifyVpcPeeringConnectionOptions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpModifyVpcEndpointServiceConfiguration) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -46587,7 +46867,7 @@ func (m *awsEc2query_serializeOpModifyVpcPeeringConnectionOptions) HandleSeriali return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ModifyVpcPeeringConnectionOptionsInput) + input, ok := in.Parameters.(*ModifyVpcEndpointServiceConfigurationInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -46612,10 +46892,10 @@ func (m *awsEc2query_serializeOpModifyVpcPeeringConnectionOptions) HandleSeriali bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("ModifyVpcPeeringConnectionOptions") + body.Key("Action").String("ModifyVpcEndpointServiceConfiguration") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentModifyVpcPeeringConnectionOptionsInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentModifyVpcEndpointServiceConfigurationInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -46638,14 +46918,14 @@ func (m *awsEc2query_serializeOpModifyVpcPeeringConnectionOptions) HandleSeriali return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpModifyVpcTenancy struct { +type awsEc2query_serializeOpModifyVpcEndpointServicePayerResponsibility struct { } -func (*awsEc2query_serializeOpModifyVpcTenancy) ID() string { +func (*awsEc2query_serializeOpModifyVpcEndpointServicePayerResponsibility) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpModifyVpcTenancy) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpModifyVpcEndpointServicePayerResponsibility) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -46657,7 +46937,7 @@ func (m *awsEc2query_serializeOpModifyVpcTenancy) HandleSerialize(ctx context.Co return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ModifyVpcTenancyInput) + input, ok := in.Parameters.(*ModifyVpcEndpointServicePayerResponsibilityInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -46682,10 +46962,10 @@ func (m *awsEc2query_serializeOpModifyVpcTenancy) HandleSerialize(ctx context.Co bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("ModifyVpcTenancy") + body.Key("Action").String("ModifyVpcEndpointServicePayerResponsibility") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentModifyVpcTenancyInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentModifyVpcEndpointServicePayerResponsibilityInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -46708,14 +46988,14 @@ func (m *awsEc2query_serializeOpModifyVpcTenancy) HandleSerialize(ctx context.Co return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpModifyVpnConnection struct { +type awsEc2query_serializeOpModifyVpcEndpointServicePermissions struct { } -func (*awsEc2query_serializeOpModifyVpnConnection) ID() string { +func (*awsEc2query_serializeOpModifyVpcEndpointServicePermissions) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpModifyVpnConnection) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpModifyVpcEndpointServicePermissions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -46727,7 +47007,7 @@ func (m *awsEc2query_serializeOpModifyVpnConnection) HandleSerialize(ctx context return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ModifyVpnConnectionInput) + input, ok := in.Parameters.(*ModifyVpcEndpointServicePermissionsInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -46752,10 +47032,10 @@ func (m *awsEc2query_serializeOpModifyVpnConnection) HandleSerialize(ctx context bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("ModifyVpnConnection") + body.Key("Action").String("ModifyVpcEndpointServicePermissions") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentModifyVpnConnectionInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentModifyVpcEndpointServicePermissionsInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -46778,14 +47058,14 @@ func (m *awsEc2query_serializeOpModifyVpnConnection) HandleSerialize(ctx context return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpModifyVpnConnectionOptions struct { +type awsEc2query_serializeOpModifyVpcPeeringConnectionOptions struct { } -func (*awsEc2query_serializeOpModifyVpnConnectionOptions) ID() string { +func (*awsEc2query_serializeOpModifyVpcPeeringConnectionOptions) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpModifyVpnConnectionOptions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpModifyVpcPeeringConnectionOptions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -46797,7 +47077,7 @@ func (m *awsEc2query_serializeOpModifyVpnConnectionOptions) HandleSerialize(ctx return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ModifyVpnConnectionOptionsInput) + input, ok := in.Parameters.(*ModifyVpcPeeringConnectionOptionsInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -46822,10 +47102,10 @@ func (m *awsEc2query_serializeOpModifyVpnConnectionOptions) HandleSerialize(ctx bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("ModifyVpnConnectionOptions") + body.Key("Action").String("ModifyVpcPeeringConnectionOptions") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentModifyVpnConnectionOptionsInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentModifyVpcPeeringConnectionOptionsInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -46848,14 +47128,14 @@ func (m *awsEc2query_serializeOpModifyVpnConnectionOptions) HandleSerialize(ctx return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpModifyVpnTunnelCertificate struct { +type awsEc2query_serializeOpModifyVpcTenancy struct { } -func (*awsEc2query_serializeOpModifyVpnTunnelCertificate) ID() string { +func (*awsEc2query_serializeOpModifyVpcTenancy) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpModifyVpnTunnelCertificate) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpModifyVpcTenancy) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -46867,7 +47147,7 @@ func (m *awsEc2query_serializeOpModifyVpnTunnelCertificate) HandleSerialize(ctx return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ModifyVpnTunnelCertificateInput) + input, ok := in.Parameters.(*ModifyVpcTenancyInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -46892,10 +47172,10 @@ func (m *awsEc2query_serializeOpModifyVpnTunnelCertificate) HandleSerialize(ctx bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("ModifyVpnTunnelCertificate") + body.Key("Action").String("ModifyVpcTenancy") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentModifyVpnTunnelCertificateInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentModifyVpcTenancyInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -46918,14 +47198,14 @@ func (m *awsEc2query_serializeOpModifyVpnTunnelCertificate) HandleSerialize(ctx return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpModifyVpnTunnelOptions struct { +type awsEc2query_serializeOpModifyVpnConnection struct { } -func (*awsEc2query_serializeOpModifyVpnTunnelOptions) ID() string { +func (*awsEc2query_serializeOpModifyVpnConnection) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpModifyVpnTunnelOptions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpModifyVpnConnection) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -46937,7 +47217,7 @@ func (m *awsEc2query_serializeOpModifyVpnTunnelOptions) HandleSerialize(ctx cont return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ModifyVpnTunnelOptionsInput) + input, ok := in.Parameters.(*ModifyVpnConnectionInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -46962,10 +47242,10 @@ func (m *awsEc2query_serializeOpModifyVpnTunnelOptions) HandleSerialize(ctx cont bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("ModifyVpnTunnelOptions") + body.Key("Action").String("ModifyVpnConnection") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentModifyVpnTunnelOptionsInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentModifyVpnConnectionInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -46988,14 +47268,14 @@ func (m *awsEc2query_serializeOpModifyVpnTunnelOptions) HandleSerialize(ctx cont return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpMonitorInstances struct { +type awsEc2query_serializeOpModifyVpnConnectionOptions struct { } -func (*awsEc2query_serializeOpMonitorInstances) ID() string { +func (*awsEc2query_serializeOpModifyVpnConnectionOptions) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpMonitorInstances) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpModifyVpnConnectionOptions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -47007,7 +47287,7 @@ func (m *awsEc2query_serializeOpMonitorInstances) HandleSerialize(ctx context.Co return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*MonitorInstancesInput) + input, ok := in.Parameters.(*ModifyVpnConnectionOptionsInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -47032,10 +47312,10 @@ func (m *awsEc2query_serializeOpMonitorInstances) HandleSerialize(ctx context.Co bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("MonitorInstances") + body.Key("Action").String("ModifyVpnConnectionOptions") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentMonitorInstancesInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentModifyVpnConnectionOptionsInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -47058,14 +47338,14 @@ func (m *awsEc2query_serializeOpMonitorInstances) HandleSerialize(ctx context.Co return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpMoveAddressToVpc struct { +type awsEc2query_serializeOpModifyVpnTunnelCertificate struct { } -func (*awsEc2query_serializeOpMoveAddressToVpc) ID() string { +func (*awsEc2query_serializeOpModifyVpnTunnelCertificate) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpMoveAddressToVpc) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpModifyVpnTunnelCertificate) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -47077,7 +47357,7 @@ func (m *awsEc2query_serializeOpMoveAddressToVpc) HandleSerialize(ctx context.Co return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*MoveAddressToVpcInput) + input, ok := in.Parameters.(*ModifyVpnTunnelCertificateInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -47102,10 +47382,10 @@ func (m *awsEc2query_serializeOpMoveAddressToVpc) HandleSerialize(ctx context.Co bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("MoveAddressToVpc") + body.Key("Action").String("ModifyVpnTunnelCertificate") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentMoveAddressToVpcInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentModifyVpnTunnelCertificateInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -47128,14 +47408,14 @@ func (m *awsEc2query_serializeOpMoveAddressToVpc) HandleSerialize(ctx context.Co return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpMoveByoipCidrToIpam struct { +type awsEc2query_serializeOpModifyVpnTunnelOptions struct { } -func (*awsEc2query_serializeOpMoveByoipCidrToIpam) ID() string { +func (*awsEc2query_serializeOpModifyVpnTunnelOptions) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpMoveByoipCidrToIpam) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpModifyVpnTunnelOptions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -47147,7 +47427,7 @@ func (m *awsEc2query_serializeOpMoveByoipCidrToIpam) HandleSerialize(ctx context return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*MoveByoipCidrToIpamInput) + input, ok := in.Parameters.(*ModifyVpnTunnelOptionsInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -47172,10 +47452,10 @@ func (m *awsEc2query_serializeOpMoveByoipCidrToIpam) HandleSerialize(ctx context bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("MoveByoipCidrToIpam") + body.Key("Action").String("ModifyVpnTunnelOptions") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentMoveByoipCidrToIpamInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentModifyVpnTunnelOptionsInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -47198,14 +47478,14 @@ func (m *awsEc2query_serializeOpMoveByoipCidrToIpam) HandleSerialize(ctx context return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpMoveCapacityReservationInstances struct { +type awsEc2query_serializeOpMonitorInstances struct { } -func (*awsEc2query_serializeOpMoveCapacityReservationInstances) ID() string { +func (*awsEc2query_serializeOpMonitorInstances) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpMoveCapacityReservationInstances) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpMonitorInstances) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -47217,7 +47497,7 @@ func (m *awsEc2query_serializeOpMoveCapacityReservationInstances) HandleSerializ return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*MoveCapacityReservationInstancesInput) + input, ok := in.Parameters.(*MonitorInstancesInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -47242,10 +47522,10 @@ func (m *awsEc2query_serializeOpMoveCapacityReservationInstances) HandleSerializ bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("MoveCapacityReservationInstances") + body.Key("Action").String("MonitorInstances") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentMoveCapacityReservationInstancesInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentMonitorInstancesInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -47268,14 +47548,14 @@ func (m *awsEc2query_serializeOpMoveCapacityReservationInstances) HandleSerializ return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpProvisionByoipCidr struct { +type awsEc2query_serializeOpMoveAddressToVpc struct { } -func (*awsEc2query_serializeOpProvisionByoipCidr) ID() string { +func (*awsEc2query_serializeOpMoveAddressToVpc) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpProvisionByoipCidr) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpMoveAddressToVpc) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -47287,7 +47567,7 @@ func (m *awsEc2query_serializeOpProvisionByoipCidr) HandleSerialize(ctx context. return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ProvisionByoipCidrInput) + input, ok := in.Parameters.(*MoveAddressToVpcInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -47312,10 +47592,10 @@ func (m *awsEc2query_serializeOpProvisionByoipCidr) HandleSerialize(ctx context. bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("ProvisionByoipCidr") + body.Key("Action").String("MoveAddressToVpc") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentProvisionByoipCidrInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentMoveAddressToVpcInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -47338,14 +47618,14 @@ func (m *awsEc2query_serializeOpProvisionByoipCidr) HandleSerialize(ctx context. return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpProvisionIpamByoasn struct { +type awsEc2query_serializeOpMoveByoipCidrToIpam struct { } -func (*awsEc2query_serializeOpProvisionIpamByoasn) ID() string { +func (*awsEc2query_serializeOpMoveByoipCidrToIpam) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpProvisionIpamByoasn) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpMoveByoipCidrToIpam) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -47357,7 +47637,7 @@ func (m *awsEc2query_serializeOpProvisionIpamByoasn) HandleSerialize(ctx context return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ProvisionIpamByoasnInput) + input, ok := in.Parameters.(*MoveByoipCidrToIpamInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -47382,10 +47662,10 @@ func (m *awsEc2query_serializeOpProvisionIpamByoasn) HandleSerialize(ctx context bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("ProvisionIpamByoasn") + body.Key("Action").String("MoveByoipCidrToIpam") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentProvisionIpamByoasnInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentMoveByoipCidrToIpamInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -47408,14 +47688,14 @@ func (m *awsEc2query_serializeOpProvisionIpamByoasn) HandleSerialize(ctx context return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpProvisionIpamPoolCidr struct { +type awsEc2query_serializeOpMoveCapacityReservationInstances struct { } -func (*awsEc2query_serializeOpProvisionIpamPoolCidr) ID() string { +func (*awsEc2query_serializeOpMoveCapacityReservationInstances) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpProvisionIpamPoolCidr) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpMoveCapacityReservationInstances) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -47427,7 +47707,7 @@ func (m *awsEc2query_serializeOpProvisionIpamPoolCidr) HandleSerialize(ctx conte return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ProvisionIpamPoolCidrInput) + input, ok := in.Parameters.(*MoveCapacityReservationInstancesInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -47452,10 +47732,10 @@ func (m *awsEc2query_serializeOpProvisionIpamPoolCidr) HandleSerialize(ctx conte bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("ProvisionIpamPoolCidr") + body.Key("Action").String("MoveCapacityReservationInstances") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentProvisionIpamPoolCidrInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentMoveCapacityReservationInstancesInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -47478,14 +47758,14 @@ func (m *awsEc2query_serializeOpProvisionIpamPoolCidr) HandleSerialize(ctx conte return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpProvisionPublicIpv4PoolCidr struct { +type awsEc2query_serializeOpProvisionByoipCidr struct { } -func (*awsEc2query_serializeOpProvisionPublicIpv4PoolCidr) ID() string { +func (*awsEc2query_serializeOpProvisionByoipCidr) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpProvisionPublicIpv4PoolCidr) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpProvisionByoipCidr) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -47497,7 +47777,7 @@ func (m *awsEc2query_serializeOpProvisionPublicIpv4PoolCidr) HandleSerialize(ctx return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ProvisionPublicIpv4PoolCidrInput) + input, ok := in.Parameters.(*ProvisionByoipCidrInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -47522,10 +47802,10 @@ func (m *awsEc2query_serializeOpProvisionPublicIpv4PoolCidr) HandleSerialize(ctx bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("ProvisionPublicIpv4PoolCidr") + body.Key("Action").String("ProvisionByoipCidr") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentProvisionPublicIpv4PoolCidrInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentProvisionByoipCidrInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -47548,14 +47828,14 @@ func (m *awsEc2query_serializeOpProvisionPublicIpv4PoolCidr) HandleSerialize(ctx return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpPurchaseCapacityBlock struct { +type awsEc2query_serializeOpProvisionIpamByoasn struct { } -func (*awsEc2query_serializeOpPurchaseCapacityBlock) ID() string { +func (*awsEc2query_serializeOpProvisionIpamByoasn) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpPurchaseCapacityBlock) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpProvisionIpamByoasn) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -47567,7 +47847,7 @@ func (m *awsEc2query_serializeOpPurchaseCapacityBlock) HandleSerialize(ctx conte return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*PurchaseCapacityBlockInput) + input, ok := in.Parameters.(*ProvisionIpamByoasnInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -47592,10 +47872,10 @@ func (m *awsEc2query_serializeOpPurchaseCapacityBlock) HandleSerialize(ctx conte bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("PurchaseCapacityBlock") + body.Key("Action").String("ProvisionIpamByoasn") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentPurchaseCapacityBlockInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentProvisionIpamByoasnInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -47618,14 +47898,14 @@ func (m *awsEc2query_serializeOpPurchaseCapacityBlock) HandleSerialize(ctx conte return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpPurchaseCapacityBlockExtension struct { +type awsEc2query_serializeOpProvisionIpamPoolCidr struct { } -func (*awsEc2query_serializeOpPurchaseCapacityBlockExtension) ID() string { +func (*awsEc2query_serializeOpProvisionIpamPoolCidr) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpPurchaseCapacityBlockExtension) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpProvisionIpamPoolCidr) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -47637,7 +47917,7 @@ func (m *awsEc2query_serializeOpPurchaseCapacityBlockExtension) HandleSerialize( return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*PurchaseCapacityBlockExtensionInput) + input, ok := in.Parameters.(*ProvisionIpamPoolCidrInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -47662,10 +47942,10 @@ func (m *awsEc2query_serializeOpPurchaseCapacityBlockExtension) HandleSerialize( bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("PurchaseCapacityBlockExtension") + body.Key("Action").String("ProvisionIpamPoolCidr") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentPurchaseCapacityBlockExtensionInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentProvisionIpamPoolCidrInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -47688,14 +47968,14 @@ func (m *awsEc2query_serializeOpPurchaseCapacityBlockExtension) HandleSerialize( return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpPurchaseHostReservation struct { +type awsEc2query_serializeOpProvisionPublicIpv4PoolCidr struct { } -func (*awsEc2query_serializeOpPurchaseHostReservation) ID() string { +func (*awsEc2query_serializeOpProvisionPublicIpv4PoolCidr) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpPurchaseHostReservation) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpProvisionPublicIpv4PoolCidr) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -47707,7 +47987,7 @@ func (m *awsEc2query_serializeOpPurchaseHostReservation) HandleSerialize(ctx con return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*PurchaseHostReservationInput) + input, ok := in.Parameters.(*ProvisionPublicIpv4PoolCidrInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -47732,10 +48012,10 @@ func (m *awsEc2query_serializeOpPurchaseHostReservation) HandleSerialize(ctx con bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("PurchaseHostReservation") + body.Key("Action").String("ProvisionPublicIpv4PoolCidr") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentPurchaseHostReservationInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentProvisionPublicIpv4PoolCidrInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -47758,14 +48038,14 @@ func (m *awsEc2query_serializeOpPurchaseHostReservation) HandleSerialize(ctx con return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpPurchaseReservedInstancesOffering struct { +type awsEc2query_serializeOpPurchaseCapacityBlock struct { } -func (*awsEc2query_serializeOpPurchaseReservedInstancesOffering) ID() string { +func (*awsEc2query_serializeOpPurchaseCapacityBlock) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpPurchaseReservedInstancesOffering) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpPurchaseCapacityBlock) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -47777,7 +48057,7 @@ func (m *awsEc2query_serializeOpPurchaseReservedInstancesOffering) HandleSeriali return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*PurchaseReservedInstancesOfferingInput) + input, ok := in.Parameters.(*PurchaseCapacityBlockInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -47802,10 +48082,10 @@ func (m *awsEc2query_serializeOpPurchaseReservedInstancesOffering) HandleSeriali bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("PurchaseReservedInstancesOffering") + body.Key("Action").String("PurchaseCapacityBlock") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentPurchaseReservedInstancesOfferingInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentPurchaseCapacityBlockInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -47828,14 +48108,14 @@ func (m *awsEc2query_serializeOpPurchaseReservedInstancesOffering) HandleSeriali return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpPurchaseScheduledInstances struct { +type awsEc2query_serializeOpPurchaseCapacityBlockExtension struct { } -func (*awsEc2query_serializeOpPurchaseScheduledInstances) ID() string { +func (*awsEc2query_serializeOpPurchaseCapacityBlockExtension) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpPurchaseScheduledInstances) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpPurchaseCapacityBlockExtension) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -47847,7 +48127,7 @@ func (m *awsEc2query_serializeOpPurchaseScheduledInstances) HandleSerialize(ctx return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*PurchaseScheduledInstancesInput) + input, ok := in.Parameters.(*PurchaseCapacityBlockExtensionInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -47872,10 +48152,10 @@ func (m *awsEc2query_serializeOpPurchaseScheduledInstances) HandleSerialize(ctx bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("PurchaseScheduledInstances") + body.Key("Action").String("PurchaseCapacityBlockExtension") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentPurchaseScheduledInstancesInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentPurchaseCapacityBlockExtensionInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -47898,14 +48178,14 @@ func (m *awsEc2query_serializeOpPurchaseScheduledInstances) HandleSerialize(ctx return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpRebootInstances struct { +type awsEc2query_serializeOpPurchaseHostReservation struct { } -func (*awsEc2query_serializeOpRebootInstances) ID() string { +func (*awsEc2query_serializeOpPurchaseHostReservation) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpRebootInstances) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpPurchaseHostReservation) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -47917,7 +48197,7 @@ func (m *awsEc2query_serializeOpRebootInstances) HandleSerialize(ctx context.Con return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*RebootInstancesInput) + input, ok := in.Parameters.(*PurchaseHostReservationInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -47942,10 +48222,10 @@ func (m *awsEc2query_serializeOpRebootInstances) HandleSerialize(ctx context.Con bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("RebootInstances") + body.Key("Action").String("PurchaseHostReservation") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentRebootInstancesInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentPurchaseHostReservationInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -47968,14 +48248,14 @@ func (m *awsEc2query_serializeOpRebootInstances) HandleSerialize(ctx context.Con return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpRegisterImage struct { +type awsEc2query_serializeOpPurchaseReservedInstancesOffering struct { } -func (*awsEc2query_serializeOpRegisterImage) ID() string { +func (*awsEc2query_serializeOpPurchaseReservedInstancesOffering) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpRegisterImage) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpPurchaseReservedInstancesOffering) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -47987,7 +48267,7 @@ func (m *awsEc2query_serializeOpRegisterImage) HandleSerialize(ctx context.Conte return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*RegisterImageInput) + input, ok := in.Parameters.(*PurchaseReservedInstancesOfferingInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -48012,10 +48292,10 @@ func (m *awsEc2query_serializeOpRegisterImage) HandleSerialize(ctx context.Conte bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("RegisterImage") + body.Key("Action").String("PurchaseReservedInstancesOffering") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentRegisterImageInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentPurchaseReservedInstancesOfferingInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -48038,14 +48318,14 @@ func (m *awsEc2query_serializeOpRegisterImage) HandleSerialize(ctx context.Conte return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpRegisterInstanceEventNotificationAttributes struct { +type awsEc2query_serializeOpPurchaseScheduledInstances struct { } -func (*awsEc2query_serializeOpRegisterInstanceEventNotificationAttributes) ID() string { +func (*awsEc2query_serializeOpPurchaseScheduledInstances) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpRegisterInstanceEventNotificationAttributes) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpPurchaseScheduledInstances) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -48057,7 +48337,7 @@ func (m *awsEc2query_serializeOpRegisterInstanceEventNotificationAttributes) Han return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*RegisterInstanceEventNotificationAttributesInput) + input, ok := in.Parameters.(*PurchaseScheduledInstancesInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -48082,10 +48362,10 @@ func (m *awsEc2query_serializeOpRegisterInstanceEventNotificationAttributes) Han bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("RegisterInstanceEventNotificationAttributes") + body.Key("Action").String("PurchaseScheduledInstances") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentRegisterInstanceEventNotificationAttributesInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentPurchaseScheduledInstancesInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -48108,14 +48388,14 @@ func (m *awsEc2query_serializeOpRegisterInstanceEventNotificationAttributes) Han return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpRegisterTransitGatewayMulticastGroupMembers struct { +type awsEc2query_serializeOpRebootInstances struct { } -func (*awsEc2query_serializeOpRegisterTransitGatewayMulticastGroupMembers) ID() string { +func (*awsEc2query_serializeOpRebootInstances) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpRegisterTransitGatewayMulticastGroupMembers) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpRebootInstances) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -48127,7 +48407,7 @@ func (m *awsEc2query_serializeOpRegisterTransitGatewayMulticastGroupMembers) Han return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*RegisterTransitGatewayMulticastGroupMembersInput) + input, ok := in.Parameters.(*RebootInstancesInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -48152,10 +48432,10 @@ func (m *awsEc2query_serializeOpRegisterTransitGatewayMulticastGroupMembers) Han bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("RegisterTransitGatewayMulticastGroupMembers") + body.Key("Action").String("RebootInstances") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentRegisterTransitGatewayMulticastGroupMembersInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentRebootInstancesInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -48178,14 +48458,14 @@ func (m *awsEc2query_serializeOpRegisterTransitGatewayMulticastGroupMembers) Han return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpRegisterTransitGatewayMulticastGroupSources struct { +type awsEc2query_serializeOpRegisterImage struct { } -func (*awsEc2query_serializeOpRegisterTransitGatewayMulticastGroupSources) ID() string { +func (*awsEc2query_serializeOpRegisterImage) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpRegisterTransitGatewayMulticastGroupSources) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpRegisterImage) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -48197,7 +48477,7 @@ func (m *awsEc2query_serializeOpRegisterTransitGatewayMulticastGroupSources) Han return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*RegisterTransitGatewayMulticastGroupSourcesInput) + input, ok := in.Parameters.(*RegisterImageInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -48222,10 +48502,10 @@ func (m *awsEc2query_serializeOpRegisterTransitGatewayMulticastGroupSources) Han bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("RegisterTransitGatewayMulticastGroupSources") + body.Key("Action").String("RegisterImage") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentRegisterTransitGatewayMulticastGroupSourcesInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentRegisterImageInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -48248,14 +48528,14 @@ func (m *awsEc2query_serializeOpRegisterTransitGatewayMulticastGroupSources) Han return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpRejectCapacityReservationBillingOwnership struct { +type awsEc2query_serializeOpRegisterInstanceEventNotificationAttributes struct { } -func (*awsEc2query_serializeOpRejectCapacityReservationBillingOwnership) ID() string { +func (*awsEc2query_serializeOpRegisterInstanceEventNotificationAttributes) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpRejectCapacityReservationBillingOwnership) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpRegisterInstanceEventNotificationAttributes) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -48267,7 +48547,7 @@ func (m *awsEc2query_serializeOpRejectCapacityReservationBillingOwnership) Handl return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*RejectCapacityReservationBillingOwnershipInput) + input, ok := in.Parameters.(*RegisterInstanceEventNotificationAttributesInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -48292,10 +48572,10 @@ func (m *awsEc2query_serializeOpRejectCapacityReservationBillingOwnership) Handl bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("RejectCapacityReservationBillingOwnership") + body.Key("Action").String("RegisterInstanceEventNotificationAttributes") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentRejectCapacityReservationBillingOwnershipInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentRegisterInstanceEventNotificationAttributesInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -48318,14 +48598,14 @@ func (m *awsEc2query_serializeOpRejectCapacityReservationBillingOwnership) Handl return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpRejectTransitGatewayMulticastDomainAssociations struct { +type awsEc2query_serializeOpRegisterTransitGatewayMulticastGroupMembers struct { } -func (*awsEc2query_serializeOpRejectTransitGatewayMulticastDomainAssociations) ID() string { +func (*awsEc2query_serializeOpRegisterTransitGatewayMulticastGroupMembers) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpRejectTransitGatewayMulticastDomainAssociations) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpRegisterTransitGatewayMulticastGroupMembers) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -48337,7 +48617,7 @@ func (m *awsEc2query_serializeOpRejectTransitGatewayMulticastDomainAssociations) return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*RejectTransitGatewayMulticastDomainAssociationsInput) + input, ok := in.Parameters.(*RegisterTransitGatewayMulticastGroupMembersInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -48362,10 +48642,10 @@ func (m *awsEc2query_serializeOpRejectTransitGatewayMulticastDomainAssociations) bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("RejectTransitGatewayMulticastDomainAssociations") + body.Key("Action").String("RegisterTransitGatewayMulticastGroupMembers") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentRejectTransitGatewayMulticastDomainAssociationsInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentRegisterTransitGatewayMulticastGroupMembersInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -48388,14 +48668,14 @@ func (m *awsEc2query_serializeOpRejectTransitGatewayMulticastDomainAssociations) return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpRejectTransitGatewayPeeringAttachment struct { +type awsEc2query_serializeOpRegisterTransitGatewayMulticastGroupSources struct { } -func (*awsEc2query_serializeOpRejectTransitGatewayPeeringAttachment) ID() string { +func (*awsEc2query_serializeOpRegisterTransitGatewayMulticastGroupSources) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpRejectTransitGatewayPeeringAttachment) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpRegisterTransitGatewayMulticastGroupSources) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -48407,7 +48687,7 @@ func (m *awsEc2query_serializeOpRejectTransitGatewayPeeringAttachment) HandleSer return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*RejectTransitGatewayPeeringAttachmentInput) + input, ok := in.Parameters.(*RegisterTransitGatewayMulticastGroupSourcesInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -48432,10 +48712,10 @@ func (m *awsEc2query_serializeOpRejectTransitGatewayPeeringAttachment) HandleSer bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("RejectTransitGatewayPeeringAttachment") + body.Key("Action").String("RegisterTransitGatewayMulticastGroupSources") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentRejectTransitGatewayPeeringAttachmentInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentRegisterTransitGatewayMulticastGroupSourcesInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -48458,14 +48738,14 @@ func (m *awsEc2query_serializeOpRejectTransitGatewayPeeringAttachment) HandleSer return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpRejectTransitGatewayVpcAttachment struct { +type awsEc2query_serializeOpRejectCapacityReservationBillingOwnership struct { } -func (*awsEc2query_serializeOpRejectTransitGatewayVpcAttachment) ID() string { +func (*awsEc2query_serializeOpRejectCapacityReservationBillingOwnership) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpRejectTransitGatewayVpcAttachment) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpRejectCapacityReservationBillingOwnership) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -48477,7 +48757,7 @@ func (m *awsEc2query_serializeOpRejectTransitGatewayVpcAttachment) HandleSeriali return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*RejectTransitGatewayVpcAttachmentInput) + input, ok := in.Parameters.(*RejectCapacityReservationBillingOwnershipInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -48502,10 +48782,10 @@ func (m *awsEc2query_serializeOpRejectTransitGatewayVpcAttachment) HandleSeriali bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("RejectTransitGatewayVpcAttachment") + body.Key("Action").String("RejectCapacityReservationBillingOwnership") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentRejectTransitGatewayVpcAttachmentInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentRejectCapacityReservationBillingOwnershipInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -48528,14 +48808,14 @@ func (m *awsEc2query_serializeOpRejectTransitGatewayVpcAttachment) HandleSeriali return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpRejectVpcEndpointConnections struct { +type awsEc2query_serializeOpRejectTransitGatewayMulticastDomainAssociations struct { } -func (*awsEc2query_serializeOpRejectVpcEndpointConnections) ID() string { +func (*awsEc2query_serializeOpRejectTransitGatewayMulticastDomainAssociations) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpRejectVpcEndpointConnections) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpRejectTransitGatewayMulticastDomainAssociations) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -48547,7 +48827,7 @@ func (m *awsEc2query_serializeOpRejectVpcEndpointConnections) HandleSerialize(ct return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*RejectVpcEndpointConnectionsInput) + input, ok := in.Parameters.(*RejectTransitGatewayMulticastDomainAssociationsInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -48572,10 +48852,10 @@ func (m *awsEc2query_serializeOpRejectVpcEndpointConnections) HandleSerialize(ct bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("RejectVpcEndpointConnections") + body.Key("Action").String("RejectTransitGatewayMulticastDomainAssociations") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentRejectVpcEndpointConnectionsInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentRejectTransitGatewayMulticastDomainAssociationsInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -48598,14 +48878,14 @@ func (m *awsEc2query_serializeOpRejectVpcEndpointConnections) HandleSerialize(ct return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpRejectVpcPeeringConnection struct { +type awsEc2query_serializeOpRejectTransitGatewayPeeringAttachment struct { } -func (*awsEc2query_serializeOpRejectVpcPeeringConnection) ID() string { +func (*awsEc2query_serializeOpRejectTransitGatewayPeeringAttachment) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpRejectVpcPeeringConnection) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpRejectTransitGatewayPeeringAttachment) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -48617,7 +48897,7 @@ func (m *awsEc2query_serializeOpRejectVpcPeeringConnection) HandleSerialize(ctx return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*RejectVpcPeeringConnectionInput) + input, ok := in.Parameters.(*RejectTransitGatewayPeeringAttachmentInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -48642,10 +48922,10 @@ func (m *awsEc2query_serializeOpRejectVpcPeeringConnection) HandleSerialize(ctx bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("RejectVpcPeeringConnection") + body.Key("Action").String("RejectTransitGatewayPeeringAttachment") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentRejectVpcPeeringConnectionInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentRejectTransitGatewayPeeringAttachmentInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -48668,14 +48948,14 @@ func (m *awsEc2query_serializeOpRejectVpcPeeringConnection) HandleSerialize(ctx return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpReleaseAddress struct { +type awsEc2query_serializeOpRejectTransitGatewayVpcAttachment struct { } -func (*awsEc2query_serializeOpReleaseAddress) ID() string { +func (*awsEc2query_serializeOpRejectTransitGatewayVpcAttachment) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpReleaseAddress) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpRejectTransitGatewayVpcAttachment) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -48687,7 +48967,7 @@ func (m *awsEc2query_serializeOpReleaseAddress) HandleSerialize(ctx context.Cont return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ReleaseAddressInput) + input, ok := in.Parameters.(*RejectTransitGatewayVpcAttachmentInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -48712,10 +48992,10 @@ func (m *awsEc2query_serializeOpReleaseAddress) HandleSerialize(ctx context.Cont bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("ReleaseAddress") + body.Key("Action").String("RejectTransitGatewayVpcAttachment") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentReleaseAddressInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentRejectTransitGatewayVpcAttachmentInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -48738,14 +49018,14 @@ func (m *awsEc2query_serializeOpReleaseAddress) HandleSerialize(ctx context.Cont return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpReleaseHosts struct { +type awsEc2query_serializeOpRejectVpcEndpointConnections struct { } -func (*awsEc2query_serializeOpReleaseHosts) ID() string { +func (*awsEc2query_serializeOpRejectVpcEndpointConnections) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpReleaseHosts) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpRejectVpcEndpointConnections) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -48757,7 +49037,7 @@ func (m *awsEc2query_serializeOpReleaseHosts) HandleSerialize(ctx context.Contex return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ReleaseHostsInput) + input, ok := in.Parameters.(*RejectVpcEndpointConnectionsInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -48782,10 +49062,10 @@ func (m *awsEc2query_serializeOpReleaseHosts) HandleSerialize(ctx context.Contex bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("ReleaseHosts") + body.Key("Action").String("RejectVpcEndpointConnections") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentReleaseHostsInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentRejectVpcEndpointConnectionsInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -48808,14 +49088,14 @@ func (m *awsEc2query_serializeOpReleaseHosts) HandleSerialize(ctx context.Contex return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpReleaseIpamPoolAllocation struct { +type awsEc2query_serializeOpRejectVpcPeeringConnection struct { } -func (*awsEc2query_serializeOpReleaseIpamPoolAllocation) ID() string { +func (*awsEc2query_serializeOpRejectVpcPeeringConnection) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpReleaseIpamPoolAllocation) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpRejectVpcPeeringConnection) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -48827,7 +49107,7 @@ func (m *awsEc2query_serializeOpReleaseIpamPoolAllocation) HandleSerialize(ctx c return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ReleaseIpamPoolAllocationInput) + input, ok := in.Parameters.(*RejectVpcPeeringConnectionInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -48852,10 +49132,10 @@ func (m *awsEc2query_serializeOpReleaseIpamPoolAllocation) HandleSerialize(ctx c bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("ReleaseIpamPoolAllocation") + body.Key("Action").String("RejectVpcPeeringConnection") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentReleaseIpamPoolAllocationInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentRejectVpcPeeringConnectionInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -48878,14 +49158,14 @@ func (m *awsEc2query_serializeOpReleaseIpamPoolAllocation) HandleSerialize(ctx c return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpReplaceIamInstanceProfileAssociation struct { +type awsEc2query_serializeOpReleaseAddress struct { } -func (*awsEc2query_serializeOpReplaceIamInstanceProfileAssociation) ID() string { +func (*awsEc2query_serializeOpReleaseAddress) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpReplaceIamInstanceProfileAssociation) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpReleaseAddress) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -48897,7 +49177,7 @@ func (m *awsEc2query_serializeOpReplaceIamInstanceProfileAssociation) HandleSeri return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ReplaceIamInstanceProfileAssociationInput) + input, ok := in.Parameters.(*ReleaseAddressInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -48922,10 +49202,10 @@ func (m *awsEc2query_serializeOpReplaceIamInstanceProfileAssociation) HandleSeri bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("ReplaceIamInstanceProfileAssociation") + body.Key("Action").String("ReleaseAddress") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentReplaceIamInstanceProfileAssociationInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentReleaseAddressInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -48948,14 +49228,14 @@ func (m *awsEc2query_serializeOpReplaceIamInstanceProfileAssociation) HandleSeri return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpReplaceImageCriteriaInAllowedImagesSettings struct { +type awsEc2query_serializeOpReleaseHosts struct { } -func (*awsEc2query_serializeOpReplaceImageCriteriaInAllowedImagesSettings) ID() string { +func (*awsEc2query_serializeOpReleaseHosts) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpReplaceImageCriteriaInAllowedImagesSettings) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpReleaseHosts) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -48967,7 +49247,7 @@ func (m *awsEc2query_serializeOpReplaceImageCriteriaInAllowedImagesSettings) Han return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ReplaceImageCriteriaInAllowedImagesSettingsInput) + input, ok := in.Parameters.(*ReleaseHostsInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -48992,10 +49272,10 @@ func (m *awsEc2query_serializeOpReplaceImageCriteriaInAllowedImagesSettings) Han bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("ReplaceImageCriteriaInAllowedImagesSettings") + body.Key("Action").String("ReleaseHosts") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentReplaceImageCriteriaInAllowedImagesSettingsInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentReleaseHostsInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -49018,14 +49298,14 @@ func (m *awsEc2query_serializeOpReplaceImageCriteriaInAllowedImagesSettings) Han return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpReplaceNetworkAclAssociation struct { +type awsEc2query_serializeOpReleaseIpamPoolAllocation struct { } -func (*awsEc2query_serializeOpReplaceNetworkAclAssociation) ID() string { +func (*awsEc2query_serializeOpReleaseIpamPoolAllocation) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpReplaceNetworkAclAssociation) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpReleaseIpamPoolAllocation) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -49037,7 +49317,7 @@ func (m *awsEc2query_serializeOpReplaceNetworkAclAssociation) HandleSerialize(ct return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ReplaceNetworkAclAssociationInput) + input, ok := in.Parameters.(*ReleaseIpamPoolAllocationInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -49062,10 +49342,10 @@ func (m *awsEc2query_serializeOpReplaceNetworkAclAssociation) HandleSerialize(ct bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("ReplaceNetworkAclAssociation") + body.Key("Action").String("ReleaseIpamPoolAllocation") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentReplaceNetworkAclAssociationInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentReleaseIpamPoolAllocationInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -49088,14 +49368,14 @@ func (m *awsEc2query_serializeOpReplaceNetworkAclAssociation) HandleSerialize(ct return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpReplaceNetworkAclEntry struct { +type awsEc2query_serializeOpReplaceIamInstanceProfileAssociation struct { } -func (*awsEc2query_serializeOpReplaceNetworkAclEntry) ID() string { +func (*awsEc2query_serializeOpReplaceIamInstanceProfileAssociation) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpReplaceNetworkAclEntry) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpReplaceIamInstanceProfileAssociation) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -49107,7 +49387,7 @@ func (m *awsEc2query_serializeOpReplaceNetworkAclEntry) HandleSerialize(ctx cont return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ReplaceNetworkAclEntryInput) + input, ok := in.Parameters.(*ReplaceIamInstanceProfileAssociationInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -49132,10 +49412,10 @@ func (m *awsEc2query_serializeOpReplaceNetworkAclEntry) HandleSerialize(ctx cont bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("ReplaceNetworkAclEntry") + body.Key("Action").String("ReplaceIamInstanceProfileAssociation") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentReplaceNetworkAclEntryInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentReplaceIamInstanceProfileAssociationInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -49158,14 +49438,14 @@ func (m *awsEc2query_serializeOpReplaceNetworkAclEntry) HandleSerialize(ctx cont return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpReplaceRoute struct { +type awsEc2query_serializeOpReplaceImageCriteriaInAllowedImagesSettings struct { } -func (*awsEc2query_serializeOpReplaceRoute) ID() string { +func (*awsEc2query_serializeOpReplaceImageCriteriaInAllowedImagesSettings) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpReplaceRoute) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpReplaceImageCriteriaInAllowedImagesSettings) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -49177,7 +49457,7 @@ func (m *awsEc2query_serializeOpReplaceRoute) HandleSerialize(ctx context.Contex return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ReplaceRouteInput) + input, ok := in.Parameters.(*ReplaceImageCriteriaInAllowedImagesSettingsInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -49202,10 +49482,10 @@ func (m *awsEc2query_serializeOpReplaceRoute) HandleSerialize(ctx context.Contex bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("ReplaceRoute") + body.Key("Action").String("ReplaceImageCriteriaInAllowedImagesSettings") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentReplaceRouteInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentReplaceImageCriteriaInAllowedImagesSettingsInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -49228,14 +49508,14 @@ func (m *awsEc2query_serializeOpReplaceRoute) HandleSerialize(ctx context.Contex return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpReplaceRouteTableAssociation struct { +type awsEc2query_serializeOpReplaceNetworkAclAssociation struct { } -func (*awsEc2query_serializeOpReplaceRouteTableAssociation) ID() string { +func (*awsEc2query_serializeOpReplaceNetworkAclAssociation) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpReplaceRouteTableAssociation) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpReplaceNetworkAclAssociation) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -49247,7 +49527,7 @@ func (m *awsEc2query_serializeOpReplaceRouteTableAssociation) HandleSerialize(ct return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ReplaceRouteTableAssociationInput) + input, ok := in.Parameters.(*ReplaceNetworkAclAssociationInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -49272,10 +49552,10 @@ func (m *awsEc2query_serializeOpReplaceRouteTableAssociation) HandleSerialize(ct bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("ReplaceRouteTableAssociation") + body.Key("Action").String("ReplaceNetworkAclAssociation") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentReplaceRouteTableAssociationInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentReplaceNetworkAclAssociationInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -49298,14 +49578,14 @@ func (m *awsEc2query_serializeOpReplaceRouteTableAssociation) HandleSerialize(ct return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpReplaceTransitGatewayRoute struct { +type awsEc2query_serializeOpReplaceNetworkAclEntry struct { } -func (*awsEc2query_serializeOpReplaceTransitGatewayRoute) ID() string { +func (*awsEc2query_serializeOpReplaceNetworkAclEntry) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpReplaceTransitGatewayRoute) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpReplaceNetworkAclEntry) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -49317,7 +49597,7 @@ func (m *awsEc2query_serializeOpReplaceTransitGatewayRoute) HandleSerialize(ctx return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ReplaceTransitGatewayRouteInput) + input, ok := in.Parameters.(*ReplaceNetworkAclEntryInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -49342,10 +49622,10 @@ func (m *awsEc2query_serializeOpReplaceTransitGatewayRoute) HandleSerialize(ctx bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("ReplaceTransitGatewayRoute") + body.Key("Action").String("ReplaceNetworkAclEntry") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentReplaceTransitGatewayRouteInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentReplaceNetworkAclEntryInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -49368,14 +49648,14 @@ func (m *awsEc2query_serializeOpReplaceTransitGatewayRoute) HandleSerialize(ctx return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpReplaceVpnTunnel struct { +type awsEc2query_serializeOpReplaceRoute struct { } -func (*awsEc2query_serializeOpReplaceVpnTunnel) ID() string { +func (*awsEc2query_serializeOpReplaceRoute) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpReplaceVpnTunnel) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpReplaceRoute) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -49387,7 +49667,7 @@ func (m *awsEc2query_serializeOpReplaceVpnTunnel) HandleSerialize(ctx context.Co return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ReplaceVpnTunnelInput) + input, ok := in.Parameters.(*ReplaceRouteInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -49412,10 +49692,10 @@ func (m *awsEc2query_serializeOpReplaceVpnTunnel) HandleSerialize(ctx context.Co bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("ReplaceVpnTunnel") + body.Key("Action").String("ReplaceRoute") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentReplaceVpnTunnelInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentReplaceRouteInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -49438,14 +49718,14 @@ func (m *awsEc2query_serializeOpReplaceVpnTunnel) HandleSerialize(ctx context.Co return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpReportInstanceStatus struct { +type awsEc2query_serializeOpReplaceRouteTableAssociation struct { } -func (*awsEc2query_serializeOpReportInstanceStatus) ID() string { +func (*awsEc2query_serializeOpReplaceRouteTableAssociation) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpReportInstanceStatus) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpReplaceRouteTableAssociation) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -49457,7 +49737,7 @@ func (m *awsEc2query_serializeOpReportInstanceStatus) HandleSerialize(ctx contex return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ReportInstanceStatusInput) + input, ok := in.Parameters.(*ReplaceRouteTableAssociationInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -49482,10 +49762,10 @@ func (m *awsEc2query_serializeOpReportInstanceStatus) HandleSerialize(ctx contex bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("ReportInstanceStatus") + body.Key("Action").String("ReplaceRouteTableAssociation") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentReportInstanceStatusInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentReplaceRouteTableAssociationInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -49508,14 +49788,14 @@ func (m *awsEc2query_serializeOpReportInstanceStatus) HandleSerialize(ctx contex return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpRequestSpotFleet struct { +type awsEc2query_serializeOpReplaceTransitGatewayRoute struct { } -func (*awsEc2query_serializeOpRequestSpotFleet) ID() string { +func (*awsEc2query_serializeOpReplaceTransitGatewayRoute) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpRequestSpotFleet) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpReplaceTransitGatewayRoute) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -49527,7 +49807,7 @@ func (m *awsEc2query_serializeOpRequestSpotFleet) HandleSerialize(ctx context.Co return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*RequestSpotFleetInput) + input, ok := in.Parameters.(*ReplaceTransitGatewayRouteInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -49552,10 +49832,10 @@ func (m *awsEc2query_serializeOpRequestSpotFleet) HandleSerialize(ctx context.Co bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("RequestSpotFleet") + body.Key("Action").String("ReplaceTransitGatewayRoute") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentRequestSpotFleetInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentReplaceTransitGatewayRouteInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -49578,14 +49858,14 @@ func (m *awsEc2query_serializeOpRequestSpotFleet) HandleSerialize(ctx context.Co return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpRequestSpotInstances struct { +type awsEc2query_serializeOpReplaceVpnTunnel struct { } -func (*awsEc2query_serializeOpRequestSpotInstances) ID() string { +func (*awsEc2query_serializeOpReplaceVpnTunnel) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpRequestSpotInstances) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpReplaceVpnTunnel) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -49597,7 +49877,7 @@ func (m *awsEc2query_serializeOpRequestSpotInstances) HandleSerialize(ctx contex return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*RequestSpotInstancesInput) + input, ok := in.Parameters.(*ReplaceVpnTunnelInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -49622,10 +49902,10 @@ func (m *awsEc2query_serializeOpRequestSpotInstances) HandleSerialize(ctx contex bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("RequestSpotInstances") + body.Key("Action").String("ReplaceVpnTunnel") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentRequestSpotInstancesInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentReplaceVpnTunnelInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -49648,14 +49928,14 @@ func (m *awsEc2query_serializeOpRequestSpotInstances) HandleSerialize(ctx contex return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpResetAddressAttribute struct { +type awsEc2query_serializeOpReportInstanceStatus struct { } -func (*awsEc2query_serializeOpResetAddressAttribute) ID() string { +func (*awsEc2query_serializeOpReportInstanceStatus) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpResetAddressAttribute) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpReportInstanceStatus) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -49667,7 +49947,7 @@ func (m *awsEc2query_serializeOpResetAddressAttribute) HandleSerialize(ctx conte return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ResetAddressAttributeInput) + input, ok := in.Parameters.(*ReportInstanceStatusInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -49692,10 +49972,10 @@ func (m *awsEc2query_serializeOpResetAddressAttribute) HandleSerialize(ctx conte bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("ResetAddressAttribute") + body.Key("Action").String("ReportInstanceStatus") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentResetAddressAttributeInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentReportInstanceStatusInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -49718,14 +49998,14 @@ func (m *awsEc2query_serializeOpResetAddressAttribute) HandleSerialize(ctx conte return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpResetEbsDefaultKmsKeyId struct { +type awsEc2query_serializeOpRequestSpotFleet struct { } -func (*awsEc2query_serializeOpResetEbsDefaultKmsKeyId) ID() string { +func (*awsEc2query_serializeOpRequestSpotFleet) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpResetEbsDefaultKmsKeyId) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpRequestSpotFleet) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -49737,7 +50017,7 @@ func (m *awsEc2query_serializeOpResetEbsDefaultKmsKeyId) HandleSerialize(ctx con return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ResetEbsDefaultKmsKeyIdInput) + input, ok := in.Parameters.(*RequestSpotFleetInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -49762,10 +50042,10 @@ func (m *awsEc2query_serializeOpResetEbsDefaultKmsKeyId) HandleSerialize(ctx con bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("ResetEbsDefaultKmsKeyId") + body.Key("Action").String("RequestSpotFleet") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentResetEbsDefaultKmsKeyIdInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentRequestSpotFleetInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -49788,14 +50068,14 @@ func (m *awsEc2query_serializeOpResetEbsDefaultKmsKeyId) HandleSerialize(ctx con return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpResetFpgaImageAttribute struct { +type awsEc2query_serializeOpRequestSpotInstances struct { } -func (*awsEc2query_serializeOpResetFpgaImageAttribute) ID() string { +func (*awsEc2query_serializeOpRequestSpotInstances) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpResetFpgaImageAttribute) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpRequestSpotInstances) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -49807,7 +50087,7 @@ func (m *awsEc2query_serializeOpResetFpgaImageAttribute) HandleSerialize(ctx con return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ResetFpgaImageAttributeInput) + input, ok := in.Parameters.(*RequestSpotInstancesInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -49832,10 +50112,10 @@ func (m *awsEc2query_serializeOpResetFpgaImageAttribute) HandleSerialize(ctx con bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("ResetFpgaImageAttribute") + body.Key("Action").String("RequestSpotInstances") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentResetFpgaImageAttributeInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentRequestSpotInstancesInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -49858,14 +50138,14 @@ func (m *awsEc2query_serializeOpResetFpgaImageAttribute) HandleSerialize(ctx con return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpResetImageAttribute struct { +type awsEc2query_serializeOpResetAddressAttribute struct { } -func (*awsEc2query_serializeOpResetImageAttribute) ID() string { +func (*awsEc2query_serializeOpResetAddressAttribute) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpResetImageAttribute) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpResetAddressAttribute) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -49877,7 +50157,7 @@ func (m *awsEc2query_serializeOpResetImageAttribute) HandleSerialize(ctx context return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ResetImageAttributeInput) + input, ok := in.Parameters.(*ResetAddressAttributeInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -49902,10 +50182,10 @@ func (m *awsEc2query_serializeOpResetImageAttribute) HandleSerialize(ctx context bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("ResetImageAttribute") + body.Key("Action").String("ResetAddressAttribute") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentResetImageAttributeInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentResetAddressAttributeInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -49928,14 +50208,14 @@ func (m *awsEc2query_serializeOpResetImageAttribute) HandleSerialize(ctx context return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpResetInstanceAttribute struct { +type awsEc2query_serializeOpResetEbsDefaultKmsKeyId struct { } -func (*awsEc2query_serializeOpResetInstanceAttribute) ID() string { +func (*awsEc2query_serializeOpResetEbsDefaultKmsKeyId) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpResetInstanceAttribute) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpResetEbsDefaultKmsKeyId) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -49947,7 +50227,7 @@ func (m *awsEc2query_serializeOpResetInstanceAttribute) HandleSerialize(ctx cont return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ResetInstanceAttributeInput) + input, ok := in.Parameters.(*ResetEbsDefaultKmsKeyIdInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -49972,10 +50252,10 @@ func (m *awsEc2query_serializeOpResetInstanceAttribute) HandleSerialize(ctx cont bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("ResetInstanceAttribute") + body.Key("Action").String("ResetEbsDefaultKmsKeyId") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentResetInstanceAttributeInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentResetEbsDefaultKmsKeyIdInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -49998,14 +50278,14 @@ func (m *awsEc2query_serializeOpResetInstanceAttribute) HandleSerialize(ctx cont return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpResetNetworkInterfaceAttribute struct { +type awsEc2query_serializeOpResetFpgaImageAttribute struct { } -func (*awsEc2query_serializeOpResetNetworkInterfaceAttribute) ID() string { +func (*awsEc2query_serializeOpResetFpgaImageAttribute) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpResetNetworkInterfaceAttribute) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpResetFpgaImageAttribute) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -50017,7 +50297,7 @@ func (m *awsEc2query_serializeOpResetNetworkInterfaceAttribute) HandleSerialize( return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ResetNetworkInterfaceAttributeInput) + input, ok := in.Parameters.(*ResetFpgaImageAttributeInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -50042,10 +50322,10 @@ func (m *awsEc2query_serializeOpResetNetworkInterfaceAttribute) HandleSerialize( bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("ResetNetworkInterfaceAttribute") + body.Key("Action").String("ResetFpgaImageAttribute") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentResetNetworkInterfaceAttributeInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentResetFpgaImageAttributeInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -50068,14 +50348,14 @@ func (m *awsEc2query_serializeOpResetNetworkInterfaceAttribute) HandleSerialize( return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpResetSnapshotAttribute struct { +type awsEc2query_serializeOpResetImageAttribute struct { } -func (*awsEc2query_serializeOpResetSnapshotAttribute) ID() string { +func (*awsEc2query_serializeOpResetImageAttribute) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpResetSnapshotAttribute) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpResetImageAttribute) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -50087,7 +50367,7 @@ func (m *awsEc2query_serializeOpResetSnapshotAttribute) HandleSerialize(ctx cont return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*ResetSnapshotAttributeInput) + input, ok := in.Parameters.(*ResetImageAttributeInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -50112,10 +50392,10 @@ func (m *awsEc2query_serializeOpResetSnapshotAttribute) HandleSerialize(ctx cont bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("ResetSnapshotAttribute") + body.Key("Action").String("ResetImageAttribute") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentResetSnapshotAttributeInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentResetImageAttributeInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -50138,14 +50418,14 @@ func (m *awsEc2query_serializeOpResetSnapshotAttribute) HandleSerialize(ctx cont return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpRestoreAddressToClassic struct { +type awsEc2query_serializeOpResetInstanceAttribute struct { } -func (*awsEc2query_serializeOpRestoreAddressToClassic) ID() string { +func (*awsEc2query_serializeOpResetInstanceAttribute) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpRestoreAddressToClassic) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpResetInstanceAttribute) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -50157,7 +50437,7 @@ func (m *awsEc2query_serializeOpRestoreAddressToClassic) HandleSerialize(ctx con return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*RestoreAddressToClassicInput) + input, ok := in.Parameters.(*ResetInstanceAttributeInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -50182,10 +50462,10 @@ func (m *awsEc2query_serializeOpRestoreAddressToClassic) HandleSerialize(ctx con bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("RestoreAddressToClassic") + body.Key("Action").String("ResetInstanceAttribute") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentRestoreAddressToClassicInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentResetInstanceAttributeInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -50208,14 +50488,14 @@ func (m *awsEc2query_serializeOpRestoreAddressToClassic) HandleSerialize(ctx con return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpRestoreImageFromRecycleBin struct { +type awsEc2query_serializeOpResetNetworkInterfaceAttribute struct { } -func (*awsEc2query_serializeOpRestoreImageFromRecycleBin) ID() string { +func (*awsEc2query_serializeOpResetNetworkInterfaceAttribute) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpRestoreImageFromRecycleBin) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpResetNetworkInterfaceAttribute) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -50227,7 +50507,7 @@ func (m *awsEc2query_serializeOpRestoreImageFromRecycleBin) HandleSerialize(ctx return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*RestoreImageFromRecycleBinInput) + input, ok := in.Parameters.(*ResetNetworkInterfaceAttributeInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -50252,10 +50532,10 @@ func (m *awsEc2query_serializeOpRestoreImageFromRecycleBin) HandleSerialize(ctx bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("RestoreImageFromRecycleBin") + body.Key("Action").String("ResetNetworkInterfaceAttribute") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentRestoreImageFromRecycleBinInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentResetNetworkInterfaceAttributeInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -50278,14 +50558,14 @@ func (m *awsEc2query_serializeOpRestoreImageFromRecycleBin) HandleSerialize(ctx return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpRestoreManagedPrefixListVersion struct { +type awsEc2query_serializeOpResetSnapshotAttribute struct { } -func (*awsEc2query_serializeOpRestoreManagedPrefixListVersion) ID() string { +func (*awsEc2query_serializeOpResetSnapshotAttribute) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpRestoreManagedPrefixListVersion) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpResetSnapshotAttribute) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -50297,7 +50577,7 @@ func (m *awsEc2query_serializeOpRestoreManagedPrefixListVersion) HandleSerialize return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*RestoreManagedPrefixListVersionInput) + input, ok := in.Parameters.(*ResetSnapshotAttributeInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -50322,10 +50602,10 @@ func (m *awsEc2query_serializeOpRestoreManagedPrefixListVersion) HandleSerialize bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("RestoreManagedPrefixListVersion") + body.Key("Action").String("ResetSnapshotAttribute") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentRestoreManagedPrefixListVersionInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentResetSnapshotAttributeInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -50348,14 +50628,14 @@ func (m *awsEc2query_serializeOpRestoreManagedPrefixListVersion) HandleSerialize return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpRestoreSnapshotFromRecycleBin struct { +type awsEc2query_serializeOpRestoreAddressToClassic struct { } -func (*awsEc2query_serializeOpRestoreSnapshotFromRecycleBin) ID() string { +func (*awsEc2query_serializeOpRestoreAddressToClassic) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpRestoreSnapshotFromRecycleBin) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpRestoreAddressToClassic) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -50367,7 +50647,7 @@ func (m *awsEc2query_serializeOpRestoreSnapshotFromRecycleBin) HandleSerialize(c return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*RestoreSnapshotFromRecycleBinInput) + input, ok := in.Parameters.(*RestoreAddressToClassicInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -50392,10 +50672,10 @@ func (m *awsEc2query_serializeOpRestoreSnapshotFromRecycleBin) HandleSerialize(c bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("RestoreSnapshotFromRecycleBin") + body.Key("Action").String("RestoreAddressToClassic") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentRestoreSnapshotFromRecycleBinInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentRestoreAddressToClassicInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -50418,14 +50698,14 @@ func (m *awsEc2query_serializeOpRestoreSnapshotFromRecycleBin) HandleSerialize(c return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpRestoreSnapshotTier struct { +type awsEc2query_serializeOpRestoreImageFromRecycleBin struct { } -func (*awsEc2query_serializeOpRestoreSnapshotTier) ID() string { +func (*awsEc2query_serializeOpRestoreImageFromRecycleBin) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpRestoreSnapshotTier) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpRestoreImageFromRecycleBin) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -50437,7 +50717,7 @@ func (m *awsEc2query_serializeOpRestoreSnapshotTier) HandleSerialize(ctx context return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*RestoreSnapshotTierInput) + input, ok := in.Parameters.(*RestoreImageFromRecycleBinInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -50462,10 +50742,10 @@ func (m *awsEc2query_serializeOpRestoreSnapshotTier) HandleSerialize(ctx context bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("RestoreSnapshotTier") + body.Key("Action").String("RestoreImageFromRecycleBin") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentRestoreSnapshotTierInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentRestoreImageFromRecycleBinInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -50488,14 +50768,14 @@ func (m *awsEc2query_serializeOpRestoreSnapshotTier) HandleSerialize(ctx context return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpRestoreVolumeFromRecycleBin struct { +type awsEc2query_serializeOpRestoreManagedPrefixListVersion struct { } -func (*awsEc2query_serializeOpRestoreVolumeFromRecycleBin) ID() string { +func (*awsEc2query_serializeOpRestoreManagedPrefixListVersion) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpRestoreVolumeFromRecycleBin) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpRestoreManagedPrefixListVersion) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -50507,7 +50787,7 @@ func (m *awsEc2query_serializeOpRestoreVolumeFromRecycleBin) HandleSerialize(ctx return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*RestoreVolumeFromRecycleBinInput) + input, ok := in.Parameters.(*RestoreManagedPrefixListVersionInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -50532,10 +50812,10 @@ func (m *awsEc2query_serializeOpRestoreVolumeFromRecycleBin) HandleSerialize(ctx bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("RestoreVolumeFromRecycleBin") + body.Key("Action").String("RestoreManagedPrefixListVersion") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentRestoreVolumeFromRecycleBinInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentRestoreManagedPrefixListVersionInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -50558,14 +50838,14 @@ func (m *awsEc2query_serializeOpRestoreVolumeFromRecycleBin) HandleSerialize(ctx return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpRevokeClientVpnIngress struct { +type awsEc2query_serializeOpRestoreSnapshotFromRecycleBin struct { } -func (*awsEc2query_serializeOpRevokeClientVpnIngress) ID() string { +func (*awsEc2query_serializeOpRestoreSnapshotFromRecycleBin) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpRevokeClientVpnIngress) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpRestoreSnapshotFromRecycleBin) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -50577,7 +50857,7 @@ func (m *awsEc2query_serializeOpRevokeClientVpnIngress) HandleSerialize(ctx cont return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*RevokeClientVpnIngressInput) + input, ok := in.Parameters.(*RestoreSnapshotFromRecycleBinInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -50602,10 +50882,10 @@ func (m *awsEc2query_serializeOpRevokeClientVpnIngress) HandleSerialize(ctx cont bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("RevokeClientVpnIngress") + body.Key("Action").String("RestoreSnapshotFromRecycleBin") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentRevokeClientVpnIngressInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentRestoreSnapshotFromRecycleBinInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -50628,14 +50908,14 @@ func (m *awsEc2query_serializeOpRevokeClientVpnIngress) HandleSerialize(ctx cont return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpRevokeSecurityGroupEgress struct { +type awsEc2query_serializeOpRestoreSnapshotTier struct { } -func (*awsEc2query_serializeOpRevokeSecurityGroupEgress) ID() string { +func (*awsEc2query_serializeOpRestoreSnapshotTier) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpRevokeSecurityGroupEgress) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpRestoreSnapshotTier) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -50647,7 +50927,7 @@ func (m *awsEc2query_serializeOpRevokeSecurityGroupEgress) HandleSerialize(ctx c return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*RevokeSecurityGroupEgressInput) + input, ok := in.Parameters.(*RestoreSnapshotTierInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -50672,10 +50952,10 @@ func (m *awsEc2query_serializeOpRevokeSecurityGroupEgress) HandleSerialize(ctx c bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("RevokeSecurityGroupEgress") + body.Key("Action").String("RestoreSnapshotTier") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentRevokeSecurityGroupEgressInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentRestoreSnapshotTierInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -50698,14 +50978,14 @@ func (m *awsEc2query_serializeOpRevokeSecurityGroupEgress) HandleSerialize(ctx c return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpRevokeSecurityGroupIngress struct { +type awsEc2query_serializeOpRestoreVolumeFromRecycleBin struct { } -func (*awsEc2query_serializeOpRevokeSecurityGroupIngress) ID() string { +func (*awsEc2query_serializeOpRestoreVolumeFromRecycleBin) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpRevokeSecurityGroupIngress) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpRestoreVolumeFromRecycleBin) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -50717,7 +50997,7 @@ func (m *awsEc2query_serializeOpRevokeSecurityGroupIngress) HandleSerialize(ctx return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*RevokeSecurityGroupIngressInput) + input, ok := in.Parameters.(*RestoreVolumeFromRecycleBinInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -50742,10 +51022,10 @@ func (m *awsEc2query_serializeOpRevokeSecurityGroupIngress) HandleSerialize(ctx bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("RevokeSecurityGroupIngress") + body.Key("Action").String("RestoreVolumeFromRecycleBin") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentRevokeSecurityGroupIngressInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentRestoreVolumeFromRecycleBinInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -50768,14 +51048,14 @@ func (m *awsEc2query_serializeOpRevokeSecurityGroupIngress) HandleSerialize(ctx return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpRunInstances struct { +type awsEc2query_serializeOpRevokeClientVpnIngress struct { } -func (*awsEc2query_serializeOpRunInstances) ID() string { +func (*awsEc2query_serializeOpRevokeClientVpnIngress) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpRunInstances) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpRevokeClientVpnIngress) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -50787,7 +51067,7 @@ func (m *awsEc2query_serializeOpRunInstances) HandleSerialize(ctx context.Contex return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*RunInstancesInput) + input, ok := in.Parameters.(*RevokeClientVpnIngressInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -50812,10 +51092,10 @@ func (m *awsEc2query_serializeOpRunInstances) HandleSerialize(ctx context.Contex bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("RunInstances") + body.Key("Action").String("RevokeClientVpnIngress") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentRunInstancesInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentRevokeClientVpnIngressInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -50838,14 +51118,14 @@ func (m *awsEc2query_serializeOpRunInstances) HandleSerialize(ctx context.Contex return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpRunScheduledInstances struct { +type awsEc2query_serializeOpRevokeSecurityGroupEgress struct { } -func (*awsEc2query_serializeOpRunScheduledInstances) ID() string { +func (*awsEc2query_serializeOpRevokeSecurityGroupEgress) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpRunScheduledInstances) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpRevokeSecurityGroupEgress) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -50857,7 +51137,7 @@ func (m *awsEc2query_serializeOpRunScheduledInstances) HandleSerialize(ctx conte return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*RunScheduledInstancesInput) + input, ok := in.Parameters.(*RevokeSecurityGroupEgressInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -50882,10 +51162,10 @@ func (m *awsEc2query_serializeOpRunScheduledInstances) HandleSerialize(ctx conte bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("RunScheduledInstances") + body.Key("Action").String("RevokeSecurityGroupEgress") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentRunScheduledInstancesInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentRevokeSecurityGroupEgressInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -50908,14 +51188,14 @@ func (m *awsEc2query_serializeOpRunScheduledInstances) HandleSerialize(ctx conte return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpSearchLocalGatewayRoutes struct { +type awsEc2query_serializeOpRevokeSecurityGroupIngress struct { } -func (*awsEc2query_serializeOpSearchLocalGatewayRoutes) ID() string { +func (*awsEc2query_serializeOpRevokeSecurityGroupIngress) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpSearchLocalGatewayRoutes) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpRevokeSecurityGroupIngress) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -50927,7 +51207,7 @@ func (m *awsEc2query_serializeOpSearchLocalGatewayRoutes) HandleSerialize(ctx co return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*SearchLocalGatewayRoutesInput) + input, ok := in.Parameters.(*RevokeSecurityGroupIngressInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -50952,10 +51232,10 @@ func (m *awsEc2query_serializeOpSearchLocalGatewayRoutes) HandleSerialize(ctx co bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("SearchLocalGatewayRoutes") + body.Key("Action").String("RevokeSecurityGroupIngress") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentSearchLocalGatewayRoutesInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentRevokeSecurityGroupIngressInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -50978,14 +51258,14 @@ func (m *awsEc2query_serializeOpSearchLocalGatewayRoutes) HandleSerialize(ctx co return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpSearchTransitGatewayMulticastGroups struct { +type awsEc2query_serializeOpRunInstances struct { } -func (*awsEc2query_serializeOpSearchTransitGatewayMulticastGroups) ID() string { +func (*awsEc2query_serializeOpRunInstances) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpSearchTransitGatewayMulticastGroups) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpRunInstances) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -50997,7 +51277,7 @@ func (m *awsEc2query_serializeOpSearchTransitGatewayMulticastGroups) HandleSeria return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*SearchTransitGatewayMulticastGroupsInput) + input, ok := in.Parameters.(*RunInstancesInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -51022,10 +51302,10 @@ func (m *awsEc2query_serializeOpSearchTransitGatewayMulticastGroups) HandleSeria bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("SearchTransitGatewayMulticastGroups") + body.Key("Action").String("RunInstances") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentSearchTransitGatewayMulticastGroupsInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentRunInstancesInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -51048,14 +51328,14 @@ func (m *awsEc2query_serializeOpSearchTransitGatewayMulticastGroups) HandleSeria return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpSearchTransitGatewayRoutes struct { +type awsEc2query_serializeOpRunScheduledInstances struct { } -func (*awsEc2query_serializeOpSearchTransitGatewayRoutes) ID() string { +func (*awsEc2query_serializeOpRunScheduledInstances) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpSearchTransitGatewayRoutes) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpRunScheduledInstances) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -51067,7 +51347,7 @@ func (m *awsEc2query_serializeOpSearchTransitGatewayRoutes) HandleSerialize(ctx return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*SearchTransitGatewayRoutesInput) + input, ok := in.Parameters.(*RunScheduledInstancesInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -51092,10 +51372,10 @@ func (m *awsEc2query_serializeOpSearchTransitGatewayRoutes) HandleSerialize(ctx bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("SearchTransitGatewayRoutes") + body.Key("Action").String("RunScheduledInstances") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentSearchTransitGatewayRoutesInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentRunScheduledInstancesInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -51118,14 +51398,14 @@ func (m *awsEc2query_serializeOpSearchTransitGatewayRoutes) HandleSerialize(ctx return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpSendDiagnosticInterrupt struct { +type awsEc2query_serializeOpSearchLocalGatewayRoutes struct { } -func (*awsEc2query_serializeOpSendDiagnosticInterrupt) ID() string { +func (*awsEc2query_serializeOpSearchLocalGatewayRoutes) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpSendDiagnosticInterrupt) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpSearchLocalGatewayRoutes) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -51137,7 +51417,7 @@ func (m *awsEc2query_serializeOpSendDiagnosticInterrupt) HandleSerialize(ctx con return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*SendDiagnosticInterruptInput) + input, ok := in.Parameters.(*SearchLocalGatewayRoutesInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -51162,10 +51442,10 @@ func (m *awsEc2query_serializeOpSendDiagnosticInterrupt) HandleSerialize(ctx con bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("SendDiagnosticInterrupt") + body.Key("Action").String("SearchLocalGatewayRoutes") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentSendDiagnosticInterruptInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentSearchLocalGatewayRoutesInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -51188,14 +51468,14 @@ func (m *awsEc2query_serializeOpSendDiagnosticInterrupt) HandleSerialize(ctx con return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpStartDeclarativePoliciesReport struct { +type awsEc2query_serializeOpSearchTransitGatewayMulticastGroups struct { } -func (*awsEc2query_serializeOpStartDeclarativePoliciesReport) ID() string { +func (*awsEc2query_serializeOpSearchTransitGatewayMulticastGroups) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpStartDeclarativePoliciesReport) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpSearchTransitGatewayMulticastGroups) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -51207,7 +51487,7 @@ func (m *awsEc2query_serializeOpStartDeclarativePoliciesReport) HandleSerialize( return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*StartDeclarativePoliciesReportInput) + input, ok := in.Parameters.(*SearchTransitGatewayMulticastGroupsInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -51232,10 +51512,10 @@ func (m *awsEc2query_serializeOpStartDeclarativePoliciesReport) HandleSerialize( bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("StartDeclarativePoliciesReport") + body.Key("Action").String("SearchTransitGatewayMulticastGroups") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentStartDeclarativePoliciesReportInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentSearchTransitGatewayMulticastGroupsInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -51258,14 +51538,14 @@ func (m *awsEc2query_serializeOpStartDeclarativePoliciesReport) HandleSerialize( return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpStartInstances struct { +type awsEc2query_serializeOpSearchTransitGatewayRoutes struct { } -func (*awsEc2query_serializeOpStartInstances) ID() string { +func (*awsEc2query_serializeOpSearchTransitGatewayRoutes) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpStartInstances) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpSearchTransitGatewayRoutes) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -51277,7 +51557,7 @@ func (m *awsEc2query_serializeOpStartInstances) HandleSerialize(ctx context.Cont return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*StartInstancesInput) + input, ok := in.Parameters.(*SearchTransitGatewayRoutesInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -51302,10 +51582,10 @@ func (m *awsEc2query_serializeOpStartInstances) HandleSerialize(ctx context.Cont bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("StartInstances") + body.Key("Action").String("SearchTransitGatewayRoutes") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentStartInstancesInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentSearchTransitGatewayRoutesInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -51328,14 +51608,14 @@ func (m *awsEc2query_serializeOpStartInstances) HandleSerialize(ctx context.Cont return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpStartNetworkInsightsAccessScopeAnalysis struct { +type awsEc2query_serializeOpSendDiagnosticInterrupt struct { } -func (*awsEc2query_serializeOpStartNetworkInsightsAccessScopeAnalysis) ID() string { +func (*awsEc2query_serializeOpSendDiagnosticInterrupt) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpStartNetworkInsightsAccessScopeAnalysis) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpSendDiagnosticInterrupt) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -51347,7 +51627,7 @@ func (m *awsEc2query_serializeOpStartNetworkInsightsAccessScopeAnalysis) HandleS return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*StartNetworkInsightsAccessScopeAnalysisInput) + input, ok := in.Parameters.(*SendDiagnosticInterruptInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -51372,10 +51652,10 @@ func (m *awsEc2query_serializeOpStartNetworkInsightsAccessScopeAnalysis) HandleS bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("StartNetworkInsightsAccessScopeAnalysis") + body.Key("Action").String("SendDiagnosticInterrupt") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentStartNetworkInsightsAccessScopeAnalysisInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentSendDiagnosticInterruptInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -51398,14 +51678,14 @@ func (m *awsEc2query_serializeOpStartNetworkInsightsAccessScopeAnalysis) HandleS return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpStartNetworkInsightsAnalysis struct { +type awsEc2query_serializeOpStartDeclarativePoliciesReport struct { } -func (*awsEc2query_serializeOpStartNetworkInsightsAnalysis) ID() string { +func (*awsEc2query_serializeOpStartDeclarativePoliciesReport) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpStartNetworkInsightsAnalysis) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpStartDeclarativePoliciesReport) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -51417,7 +51697,7 @@ func (m *awsEc2query_serializeOpStartNetworkInsightsAnalysis) HandleSerialize(ct return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*StartNetworkInsightsAnalysisInput) + input, ok := in.Parameters.(*StartDeclarativePoliciesReportInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -51442,10 +51722,10 @@ func (m *awsEc2query_serializeOpStartNetworkInsightsAnalysis) HandleSerialize(ct bodyWriter := bytes.NewBuffer(nil) bodyEncoder := query.NewEncoder(bodyWriter) body := bodyEncoder.Object() - body.Key("Action").String("StartNetworkInsightsAnalysis") + body.Key("Action").String("StartDeclarativePoliciesReport") body.Key("Version").String("2016-11-15") - if err := awsEc2query_serializeOpDocumentStartNetworkInsightsAnalysisInput(input, bodyEncoder.Value); err != nil { + if err := awsEc2query_serializeOpDocumentStartDeclarativePoliciesReportInput(input, bodyEncoder.Value); err != nil { return out, metadata, &smithy.SerializationError{Err: err} } @@ -51468,14 +51748,14 @@ func (m *awsEc2query_serializeOpStartNetworkInsightsAnalysis) HandleSerialize(ct return next.HandleSerialize(ctx, in) } -type awsEc2query_serializeOpStartVpcEndpointServicePrivateDnsVerification struct { +type awsEc2query_serializeOpStartInstances struct { } -func (*awsEc2query_serializeOpStartVpcEndpointServicePrivateDnsVerification) ID() string { +func (*awsEc2query_serializeOpStartInstances) ID() string { return "OperationSerializer" } -func (m *awsEc2query_serializeOpStartVpcEndpointServicePrivateDnsVerification) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( +func (m *awsEc2query_serializeOpStartInstances) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( out middleware.SerializeOutput, metadata middleware.Metadata, err error, ) { _, span := tracing.StartSpan(ctx, "OperationSerializer") @@ -51487,7 +51767,217 @@ func (m *awsEc2query_serializeOpStartVpcEndpointServicePrivateDnsVerification) H return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} } - input, ok := in.Parameters.(*StartVpcEndpointServicePrivateDnsVerificationInput) + input, ok := in.Parameters.(*StartInstancesInput) + _ = 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("StartInstances") + body.Key("Version").String("2016-11-15") + + if err := awsEc2query_serializeOpDocumentStartInstancesInput(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 + + endTimer() + span.End() + return next.HandleSerialize(ctx, in) +} + +type awsEc2query_serializeOpStartNetworkInsightsAccessScopeAnalysis struct { +} + +func (*awsEc2query_serializeOpStartNetworkInsightsAccessScopeAnalysis) ID() string { + return "OperationSerializer" +} + +func (m *awsEc2query_serializeOpStartNetworkInsightsAccessScopeAnalysis) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( + out middleware.SerializeOutput, metadata middleware.Metadata, err error, +) { + _, span := tracing.StartSpan(ctx, "OperationSerializer") + endTimer := startMetricTimer(ctx, "client.call.serialization_duration") + defer endTimer() + defer span.End() + 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.(*StartNetworkInsightsAccessScopeAnalysisInput) + _ = 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("StartNetworkInsightsAccessScopeAnalysis") + body.Key("Version").String("2016-11-15") + + if err := awsEc2query_serializeOpDocumentStartNetworkInsightsAccessScopeAnalysisInput(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 + + endTimer() + span.End() + return next.HandleSerialize(ctx, in) +} + +type awsEc2query_serializeOpStartNetworkInsightsAnalysis struct { +} + +func (*awsEc2query_serializeOpStartNetworkInsightsAnalysis) ID() string { + return "OperationSerializer" +} + +func (m *awsEc2query_serializeOpStartNetworkInsightsAnalysis) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( + out middleware.SerializeOutput, metadata middleware.Metadata, err error, +) { + _, span := tracing.StartSpan(ctx, "OperationSerializer") + endTimer := startMetricTimer(ctx, "client.call.serialization_duration") + defer endTimer() + defer span.End() + 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.(*StartNetworkInsightsAnalysisInput) + _ = 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("StartNetworkInsightsAnalysis") + body.Key("Version").String("2016-11-15") + + if err := awsEc2query_serializeOpDocumentStartNetworkInsightsAnalysisInput(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 + + endTimer() + span.End() + return next.HandleSerialize(ctx, in) +} + +type awsEc2query_serializeOpStartVpcEndpointServicePrivateDnsVerification struct { +} + +func (*awsEc2query_serializeOpStartVpcEndpointServicePrivateDnsVerification) ID() string { + return "OperationSerializer" +} + +func (m *awsEc2query_serializeOpStartVpcEndpointServicePrivateDnsVerification) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( + out middleware.SerializeOutput, metadata middleware.Metadata, err error, +) { + _, span := tracing.StartSpan(ctx, "OperationSerializer") + endTimer := startMetricTimer(ctx, "client.call.serialization_duration") + defer endTimer() + defer span.End() + 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.(*StartVpcEndpointServicePrivateDnsVerificationInput) _ = input if !ok { return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} @@ -53626,6 +54116,11 @@ func awsEc2query_serializeDocumentCpuOptionsRequest(v *types.CpuOptionsRequest, objectKey.Integer(*v.CoreCount) } + if len(v.NestedVirtualization) > 0 { + objectKey := object.Key("NestedVirtualization") + objectKey.String(string(v.NestedVirtualization)) + } + if v.ThreadsPerCore != nil { objectKey := object.Key("ThreadsPerCore") objectKey.Integer(*v.ThreadsPerCore) @@ -56783,6 +57278,92 @@ func awsEc2query_serializeDocumentInstanceRequirementsWithMetadataRequest(v *typ return nil } +func awsEc2query_serializeDocumentInstanceSecondaryInterfacePrivateIpAddressListRequest(v []types.InstanceSecondaryInterfacePrivateIpAddressRequest, value query.Value) error { + if len(v) == 0 { + return nil + } + array := value.Array("Item") + + for i := range v { + av := array.Value() + if err := awsEc2query_serializeDocumentInstanceSecondaryInterfacePrivateIpAddressRequest(&v[i], av); err != nil { + return err + } + } + return nil +} + +func awsEc2query_serializeDocumentInstanceSecondaryInterfacePrivateIpAddressRequest(v *types.InstanceSecondaryInterfacePrivateIpAddressRequest, value query.Value) error { + object := value.Object() + _ = object + + if v.PrivateIpAddress != nil { + objectKey := object.Key("PrivateIpAddress") + objectKey.String(*v.PrivateIpAddress) + } + + return nil +} + +func awsEc2query_serializeDocumentInstanceSecondaryInterfaceSpecificationListRequest(v []types.InstanceSecondaryInterfaceSpecificationRequest, value query.Value) error { + if len(v) == 0 { + return nil + } + array := value.Array("Item") + + for i := range v { + av := array.Value() + if err := awsEc2query_serializeDocumentInstanceSecondaryInterfaceSpecificationRequest(&v[i], av); err != nil { + return err + } + } + return nil +} + +func awsEc2query_serializeDocumentInstanceSecondaryInterfaceSpecificationRequest(v *types.InstanceSecondaryInterfaceSpecificationRequest, value query.Value) error { + object := value.Object() + _ = object + + if v.DeleteOnTermination != nil { + objectKey := object.Key("DeleteOnTermination") + objectKey.Boolean(*v.DeleteOnTermination) + } + + if v.DeviceIndex != nil { + objectKey := object.Key("DeviceIndex") + objectKey.Integer(*v.DeviceIndex) + } + + if len(v.InterfaceType) > 0 { + objectKey := object.Key("InterfaceType") + objectKey.String(string(v.InterfaceType)) + } + + if v.NetworkCardIndex != nil { + objectKey := object.Key("NetworkCardIndex") + objectKey.Integer(*v.NetworkCardIndex) + } + + if v.PrivateIpAddressCount != nil { + objectKey := object.Key("PrivateIpAddressCount") + objectKey.Integer(*v.PrivateIpAddressCount) + } + + if v.PrivateIpAddresses != nil { + objectKey := object.FlatKey("PrivateIpAddress") + if err := awsEc2query_serializeDocumentInstanceSecondaryInterfacePrivateIpAddressListRequest(v.PrivateIpAddresses, objectKey); err != nil { + return err + } + } + + if v.SecondarySubnetId != nil { + objectKey := object.Key("SecondarySubnetId") + objectKey.String(*v.SecondarySubnetId) + } + + return nil +} + func awsEc2query_serializeDocumentInstanceSpecification(v *types.InstanceSpecification, value query.Value) error { object := value.Object() _ = object @@ -57543,6 +58124,11 @@ func awsEc2query_serializeDocumentLaunchTemplateCpuOptionsRequest(v *types.Launc objectKey.Integer(*v.CoreCount) } + if len(v.NestedVirtualization) > 0 { + objectKey := object.Key("NestedVirtualization") + objectKey.String(string(v.NestedVirtualization)) + } + if v.ThreadsPerCore != nil { objectKey := object.Key("ThreadsPerCore") objectKey.Integer(*v.ThreadsPerCore) @@ -57908,6 +58494,65 @@ func awsEc2query_serializeDocumentLaunchTemplateInstanceNetworkInterfaceSpecific return nil } +func awsEc2query_serializeDocumentLaunchTemplateInstanceSecondaryInterfaceSpecificationRequest(v *types.LaunchTemplateInstanceSecondaryInterfaceSpecificationRequest, value query.Value) error { + object := value.Object() + _ = object + + if v.DeleteOnTermination != nil { + objectKey := object.Key("DeleteOnTermination") + objectKey.Boolean(*v.DeleteOnTermination) + } + + if v.DeviceIndex != nil { + objectKey := object.Key("DeviceIndex") + objectKey.Integer(*v.DeviceIndex) + } + + if len(v.InterfaceType) > 0 { + objectKey := object.Key("InterfaceType") + objectKey.String(string(v.InterfaceType)) + } + + if v.NetworkCardIndex != nil { + objectKey := object.Key("NetworkCardIndex") + objectKey.Integer(*v.NetworkCardIndex) + } + + if v.PrivateIpAddressCount != nil { + objectKey := object.Key("PrivateIpAddressCount") + objectKey.Integer(*v.PrivateIpAddressCount) + } + + if v.PrivateIpAddresses != nil { + objectKey := object.FlatKey("PrivateIpAddress") + if err := awsEc2query_serializeDocumentSecondaryInterfacePrivateIpAddressSpecificationListRequest(v.PrivateIpAddresses, objectKey); err != nil { + return err + } + } + + if v.SecondarySubnetId != nil { + objectKey := object.Key("SecondarySubnetId") + objectKey.String(*v.SecondarySubnetId) + } + + return nil +} + +func awsEc2query_serializeDocumentLaunchTemplateInstanceSecondaryInterfaceSpecificationRequestList(v []types.LaunchTemplateInstanceSecondaryInterfaceSpecificationRequest, value query.Value) error { + if len(v) == 0 { + return nil + } + array := value.Array("InstanceSecondaryInterfaceSpecification") + + for i := range v { + av := array.Value() + if err := awsEc2query_serializeDocumentLaunchTemplateInstanceSecondaryInterfaceSpecificationRequest(&v[i], av); err != nil { + return err + } + } + return nil +} + func awsEc2query_serializeDocumentLaunchTemplateLicenseConfigurationRequest(v *types.LaunchTemplateLicenseConfigurationRequest, value query.Value) error { object := value.Object() _ = object @@ -60645,6 +61290,13 @@ func awsEc2query_serializeDocumentRequestLaunchTemplateData(v *types.RequestLaun objectKey.String(*v.RamDiskId) } + if v.SecondaryInterfaces != nil { + objectKey := object.FlatKey("SecondaryInterface") + if err := awsEc2query_serializeDocumentLaunchTemplateInstanceSecondaryInterfaceSpecificationRequestList(v.SecondaryInterfaces, objectKey); err != nil { + return err + } + } + if v.SecurityGroupIds != nil { objectKey := object.FlatKey("SecurityGroupId") if err := awsEc2query_serializeDocumentSecurityGroupIdStringList(v.SecurityGroupIds, objectKey); err != nil { @@ -61699,6 +62351,72 @@ func awsEc2query_serializeDocumentScheduledInstancesSecurityGroupIdSet(v []strin return nil } +func awsEc2query_serializeDocumentSecondaryInterfaceIdList(v []string, value query.Value) error { + if len(v) == 0 { + return nil + } + array := value.Array("Item") + + for i := range v { + av := array.Value() + av.String(v[i]) + } + return nil +} + +func awsEc2query_serializeDocumentSecondaryInterfacePrivateIpAddressSpecificationListRequest(v []types.SecondaryInterfacePrivateIpAddressSpecificationRequest, value query.Value) error { + if len(v) == 0 { + return nil + } + array := value.Array("SecondaryInterfacePrivateIpAddressSpecification") + + for i := range v { + av := array.Value() + if err := awsEc2query_serializeDocumentSecondaryInterfacePrivateIpAddressSpecificationRequest(&v[i], av); err != nil { + return err + } + } + return nil +} + +func awsEc2query_serializeDocumentSecondaryInterfacePrivateIpAddressSpecificationRequest(v *types.SecondaryInterfacePrivateIpAddressSpecificationRequest, value query.Value) error { + object := value.Object() + _ = object + + if v.PrivateIpAddress != nil { + objectKey := object.Key("PrivateIpAddress") + objectKey.String(*v.PrivateIpAddress) + } + + return nil +} + +func awsEc2query_serializeDocumentSecondaryNetworkIdList(v []string, value query.Value) error { + if len(v) == 0 { + return nil + } + array := value.Array("Item") + + for i := range v { + av := array.Value() + av.String(v[i]) + } + return nil +} + +func awsEc2query_serializeDocumentSecondarySubnetIdList(v []string, value query.Value) error { + if len(v) == 0 { + return nil + } + array := value.Array("Item") + + for i := range v { + av := array.Value() + av.String(v[i]) + } + return nil +} + func awsEc2query_serializeDocumentSecurityGroupIdList(v []string, value query.Value) error { if len(v) == 0 { return nil @@ -68321,6 +69039,13 @@ func awsEc2query_serializeOpDocumentCreatePlacementGroupInput(v *CreatePlacement objectKey.String(*v.LinkedGroupId) } + if v.Operator != nil { + objectKey := object.Key("Operator") + if err := awsEc2query_serializeDocumentOperatorRequest(v.Operator, objectKey); err != nil { + return err + } + } + if v.PartitionCount != nil { objectKey := object.Key("PartitionCount") objectKey.Integer(*v.PartitionCount) @@ -68717,6 +69442,84 @@ func awsEc2query_serializeOpDocumentCreateRouteTableInput(v *CreateRouteTableInp return nil } +func awsEc2query_serializeOpDocumentCreateSecondaryNetworkInput(v *CreateSecondaryNetworkInput, 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.Ipv4CidrBlock != nil { + objectKey := object.Key("Ipv4CidrBlock") + objectKey.String(*v.Ipv4CidrBlock) + } + + if len(v.NetworkType) > 0 { + objectKey := object.Key("NetworkType") + objectKey.String(string(v.NetworkType)) + } + + if v.TagSpecifications != nil { + objectKey := object.FlatKey("TagSpecification") + if err := awsEc2query_serializeDocumentTagSpecificationList(v.TagSpecifications, objectKey); err != nil { + return err + } + } + + return nil +} + +func awsEc2query_serializeOpDocumentCreateSecondarySubnetInput(v *CreateSecondarySubnetInput, value query.Value) error { + object := value.Object() + _ = object + + if v.AvailabilityZone != nil { + objectKey := object.Key("AvailabilityZone") + objectKey.String(*v.AvailabilityZone) + } + + if v.AvailabilityZoneId != nil { + objectKey := object.Key("AvailabilityZoneId") + objectKey.String(*v.AvailabilityZoneId) + } + + 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.Ipv4CidrBlock != nil { + objectKey := object.Key("Ipv4CidrBlock") + objectKey.String(*v.Ipv4CidrBlock) + } + + if v.SecondaryNetworkId != nil { + objectKey := object.Key("SecondaryNetworkId") + objectKey.String(*v.SecondaryNetworkId) + } + + if v.TagSpecifications != nil { + objectKey := object.FlatKey("TagSpecification") + if err := awsEc2query_serializeDocumentTagSpecificationList(v.TagSpecifications, objectKey); err != nil { + return err + } + } + + return nil +} + func awsEc2query_serializeOpDocumentCreateSecurityGroupInput(v *CreateSecurityGroupInput, value query.Value) error { object := value.Object() _ = object @@ -71558,6 +72361,50 @@ func awsEc2query_serializeOpDocumentDeleteRouteTableInput(v *DeleteRouteTableInp return nil } +func awsEc2query_serializeOpDocumentDeleteSecondaryNetworkInput(v *DeleteSecondaryNetworkInput, 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.SecondaryNetworkId != nil { + objectKey := object.Key("SecondaryNetworkId") + objectKey.String(*v.SecondaryNetworkId) + } + + return nil +} + +func awsEc2query_serializeOpDocumentDeleteSecondarySubnetInput(v *DeleteSecondarySubnetInput, 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.SecondarySubnetId != nil { + objectKey := object.Key("SecondarySubnetId") + objectKey.String(*v.SecondarySubnetId) + } + + return nil +} + func awsEc2query_serializeOpDocumentDeleteSecurityGroupInput(v *DeleteSecurityGroupInput, value query.Value) error { object := value.Object() _ = object @@ -72767,6 +73614,11 @@ func awsEc2query_serializeOpDocumentDescribeCapacityBlockOfferingsInput(v *Descr object := value.Object() _ = object + if v.AllAvailabilityZones != nil { + objectKey := object.Key("AllAvailabilityZones") + objectKey.Boolean(*v.AllAvailabilityZones) + } + if v.CapacityDurationHours != nil { objectKey := object.Key("CapacityDurationHours") objectKey.Integer(*v.CapacityDurationHours) @@ -76281,9 +77133,294 @@ func awsEc2query_serializeOpDocumentDescribeReplaceRootVolumeTasksInput(v *Descr objectKey.String(*v.NextToken) } - if v.ReplaceRootVolumeTaskIds != nil { - objectKey := object.FlatKey("ReplaceRootVolumeTaskId") - if err := awsEc2query_serializeDocumentReplaceRootVolumeTaskIds(v.ReplaceRootVolumeTaskIds, objectKey); err != nil { + if v.ReplaceRootVolumeTaskIds != nil { + objectKey := object.FlatKey("ReplaceRootVolumeTaskId") + if err := awsEc2query_serializeDocumentReplaceRootVolumeTaskIds(v.ReplaceRootVolumeTaskIds, objectKey); err != nil { + return err + } + } + + return nil +} + +func awsEc2query_serializeOpDocumentDescribeReservedInstancesInput(v *DescribeReservedInstancesInput, 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 len(v.OfferingClass) > 0 { + objectKey := object.Key("OfferingClass") + objectKey.String(string(v.OfferingClass)) + } + + if len(v.OfferingType) > 0 { + objectKey := object.Key("OfferingType") + objectKey.String(string(v.OfferingType)) + } + + if v.ReservedInstancesIds != nil { + objectKey := object.FlatKey("ReservedInstancesId") + if err := awsEc2query_serializeDocumentReservedInstancesIdStringList(v.ReservedInstancesIds, objectKey); err != nil { + return err + } + } + + return nil +} + +func awsEc2query_serializeOpDocumentDescribeReservedInstancesListingsInput(v *DescribeReservedInstancesListingsInput, value query.Value) error { + object := value.Object() + _ = object + + if v.Filters != nil { + objectKey := object.FlatKey("Filter") + if err := awsEc2query_serializeDocumentFilterList(v.Filters, objectKey); err != nil { + return err + } + } + + if v.ReservedInstancesId != nil { + objectKey := object.Key("ReservedInstancesId") + objectKey.String(*v.ReservedInstancesId) + } + + if v.ReservedInstancesListingId != nil { + objectKey := object.Key("ReservedInstancesListingId") + objectKey.String(*v.ReservedInstancesListingId) + } + + return nil +} + +func awsEc2query_serializeOpDocumentDescribeReservedInstancesModificationsInput(v *DescribeReservedInstancesModificationsInput, value query.Value) error { + object := value.Object() + _ = object + + if v.Filters != nil { + objectKey := object.FlatKey("Filter") + if err := awsEc2query_serializeDocumentFilterList(v.Filters, objectKey); err != nil { + return err + } + } + + if v.NextToken != nil { + objectKey := object.Key("NextToken") + objectKey.String(*v.NextToken) + } + + if v.ReservedInstancesModificationIds != nil { + objectKey := object.FlatKey("ReservedInstancesModificationId") + if err := awsEc2query_serializeDocumentReservedInstancesModificationIdStringList(v.ReservedInstancesModificationIds, objectKey); err != nil { + return err + } + } + + return nil +} + +func awsEc2query_serializeOpDocumentDescribeReservedInstancesOfferingsInput(v *DescribeReservedInstancesOfferingsInput, value query.Value) error { + object := value.Object() + _ = object + + if v.AvailabilityZone != nil { + objectKey := object.Key("AvailabilityZone") + objectKey.String(*v.AvailabilityZone) + } + + if v.AvailabilityZoneId != nil { + objectKey := object.Key("AvailabilityZoneId") + objectKey.String(*v.AvailabilityZoneId) + } + + 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.IncludeMarketplace != nil { + objectKey := object.Key("IncludeMarketplace") + objectKey.Boolean(*v.IncludeMarketplace) + } + + if len(v.InstanceTenancy) > 0 { + objectKey := object.Key("InstanceTenancy") + objectKey.String(string(v.InstanceTenancy)) + } + + if len(v.InstanceType) > 0 { + objectKey := object.Key("InstanceType") + objectKey.String(string(v.InstanceType)) + } + + if v.MaxDuration != nil { + objectKey := object.Key("MaxDuration") + objectKey.Long(*v.MaxDuration) + } + + if v.MaxInstanceCount != nil { + objectKey := object.Key("MaxInstanceCount") + objectKey.Integer(*v.MaxInstanceCount) + } + + if v.MaxResults != nil { + objectKey := object.Key("MaxResults") + objectKey.Integer(*v.MaxResults) + } + + if v.MinDuration != nil { + objectKey := object.Key("MinDuration") + objectKey.Long(*v.MinDuration) + } + + if v.NextToken != nil { + objectKey := object.Key("NextToken") + objectKey.String(*v.NextToken) + } + + if len(v.OfferingClass) > 0 { + objectKey := object.Key("OfferingClass") + objectKey.String(string(v.OfferingClass)) + } + + if len(v.OfferingType) > 0 { + objectKey := object.Key("OfferingType") + objectKey.String(string(v.OfferingType)) + } + + if len(v.ProductDescription) > 0 { + objectKey := object.Key("ProductDescription") + objectKey.String(string(v.ProductDescription)) + } + + if v.ReservedInstancesOfferingIds != nil { + objectKey := object.FlatKey("ReservedInstancesOfferingId") + if err := awsEc2query_serializeDocumentReservedInstancesOfferingIdStringList(v.ReservedInstancesOfferingIds, objectKey); err != nil { + return err + } + } + + return nil +} + +func awsEc2query_serializeOpDocumentDescribeRouteServerEndpointsInput(v *DescribeRouteServerEndpointsInput, 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.MaxResults != nil { + objectKey := object.Key("MaxResults") + objectKey.Integer(*v.MaxResults) + } + + if v.NextToken != nil { + objectKey := object.Key("NextToken") + objectKey.String(*v.NextToken) + } + + if v.RouteServerEndpointIds != nil { + objectKey := object.FlatKey("RouteServerEndpointId") + if err := awsEc2query_serializeDocumentRouteServerEndpointIdsList(v.RouteServerEndpointIds, objectKey); err != nil { + return err + } + } + + return nil +} + +func awsEc2query_serializeOpDocumentDescribeRouteServerPeersInput(v *DescribeRouteServerPeersInput, 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.MaxResults != nil { + objectKey := object.Key("MaxResults") + objectKey.Integer(*v.MaxResults) + } + + if v.NextToken != nil { + objectKey := object.Key("NextToken") + objectKey.String(*v.NextToken) + } + + if v.RouteServerPeerIds != nil { + objectKey := object.FlatKey("RouteServerPeerId") + if err := awsEc2query_serializeDocumentRouteServerPeerIdsList(v.RouteServerPeerIds, objectKey); err != nil { + return err + } + } + + return nil +} + +func awsEc2query_serializeOpDocumentDescribeRouteServersInput(v *DescribeRouteServersInput, 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.MaxResults != nil { + objectKey := object.Key("MaxResults") + objectKey.Integer(*v.MaxResults) + } + + if v.NextToken != nil { + objectKey := object.Key("NextToken") + objectKey.String(*v.NextToken) + } + + if v.RouteServerIds != nil { + objectKey := object.FlatKey("RouteServerId") + if err := awsEc2query_serializeDocumentRouteServerIdsList(v.RouteServerIds, objectKey); err != nil { return err } } @@ -76291,7 +77428,7 @@ func awsEc2query_serializeOpDocumentDescribeReplaceRootVolumeTasksInput(v *Descr return nil } -func awsEc2query_serializeOpDocumentDescribeReservedInstancesInput(v *DescribeReservedInstancesInput, value query.Value) error { +func awsEc2query_serializeOpDocumentDescribeRouteTablesInput(v *DescribeRouteTablesInput, value query.Value) error { object := value.Object() _ = object @@ -76307,59 +77444,9 @@ func awsEc2query_serializeOpDocumentDescribeReservedInstancesInput(v *DescribeRe } } - if len(v.OfferingClass) > 0 { - objectKey := object.Key("OfferingClass") - objectKey.String(string(v.OfferingClass)) - } - - if len(v.OfferingType) > 0 { - objectKey := object.Key("OfferingType") - objectKey.String(string(v.OfferingType)) - } - - if v.ReservedInstancesIds != nil { - objectKey := object.FlatKey("ReservedInstancesId") - if err := awsEc2query_serializeDocumentReservedInstancesIdStringList(v.ReservedInstancesIds, objectKey); err != nil { - return err - } - } - - return nil -} - -func awsEc2query_serializeOpDocumentDescribeReservedInstancesListingsInput(v *DescribeReservedInstancesListingsInput, value query.Value) error { - object := value.Object() - _ = object - - if v.Filters != nil { - objectKey := object.FlatKey("Filter") - if err := awsEc2query_serializeDocumentFilterList(v.Filters, objectKey); err != nil { - return err - } - } - - if v.ReservedInstancesId != nil { - objectKey := object.Key("ReservedInstancesId") - objectKey.String(*v.ReservedInstancesId) - } - - if v.ReservedInstancesListingId != nil { - objectKey := object.Key("ReservedInstancesListingId") - objectKey.String(*v.ReservedInstancesListingId) - } - - return nil -} - -func awsEc2query_serializeOpDocumentDescribeReservedInstancesModificationsInput(v *DescribeReservedInstancesModificationsInput, value query.Value) error { - object := value.Object() - _ = object - - if v.Filters != nil { - objectKey := object.FlatKey("Filter") - if err := awsEc2query_serializeDocumentFilterList(v.Filters, objectKey); err != nil { - return err - } + if v.MaxResults != nil { + objectKey := object.Key("MaxResults") + objectKey.Integer(*v.MaxResults) } if v.NextToken != nil { @@ -76367,9 +77454,9 @@ func awsEc2query_serializeOpDocumentDescribeReservedInstancesModificationsInput( objectKey.String(*v.NextToken) } - if v.ReservedInstancesModificationIds != nil { - objectKey := object.FlatKey("ReservedInstancesModificationId") - if err := awsEc2query_serializeDocumentReservedInstancesModificationIdStringList(v.ReservedInstancesModificationIds, objectKey); err != nil { + if v.RouteTableIds != nil { + objectKey := object.FlatKey("RouteTableId") + if err := awsEc2query_serializeDocumentRouteTableIdStringList(v.RouteTableIds, objectKey); err != nil { return err } } @@ -76377,20 +77464,10 @@ func awsEc2query_serializeOpDocumentDescribeReservedInstancesModificationsInput( return nil } -func awsEc2query_serializeOpDocumentDescribeReservedInstancesOfferingsInput(v *DescribeReservedInstancesOfferingsInput, value query.Value) error { +func awsEc2query_serializeOpDocumentDescribeScheduledInstanceAvailabilityInput(v *DescribeScheduledInstanceAvailabilityInput, value query.Value) error { object := value.Object() _ = object - if v.AvailabilityZone != nil { - objectKey := object.Key("AvailabilityZone") - objectKey.String(*v.AvailabilityZone) - } - - if v.AvailabilityZoneId != nil { - objectKey := object.Key("AvailabilityZoneId") - objectKey.String(*v.AvailabilityZoneId) - } - if v.DryRun != nil { objectKey := object.Key("DryRun") objectKey.Boolean(*v.DryRun) @@ -76403,29 +77480,11 @@ func awsEc2query_serializeOpDocumentDescribeReservedInstancesOfferingsInput(v *D } } - if v.IncludeMarketplace != nil { - objectKey := object.Key("IncludeMarketplace") - objectKey.Boolean(*v.IncludeMarketplace) - } - - if len(v.InstanceTenancy) > 0 { - objectKey := object.Key("InstanceTenancy") - objectKey.String(string(v.InstanceTenancy)) - } - - if len(v.InstanceType) > 0 { - objectKey := object.Key("InstanceType") - objectKey.String(string(v.InstanceType)) - } - - if v.MaxDuration != nil { - objectKey := object.Key("MaxDuration") - objectKey.Long(*v.MaxDuration) - } - - if v.MaxInstanceCount != nil { - objectKey := object.Key("MaxInstanceCount") - objectKey.Integer(*v.MaxInstanceCount) + if v.FirstSlotStartTimeRange != nil { + objectKey := object.Key("FirstSlotStartTimeRange") + if err := awsEc2query_serializeDocumentSlotDateTimeRangeRequest(v.FirstSlotStartTimeRange, objectKey); err != nil { + return err + } } if v.MaxResults != nil { @@ -76433,60 +77492,14 @@ func awsEc2query_serializeOpDocumentDescribeReservedInstancesOfferingsInput(v *D objectKey.Integer(*v.MaxResults) } - if v.MinDuration != nil { - objectKey := object.Key("MinDuration") - objectKey.Long(*v.MinDuration) - } - - if v.NextToken != nil { - objectKey := object.Key("NextToken") - objectKey.String(*v.NextToken) - } - - if len(v.OfferingClass) > 0 { - objectKey := object.Key("OfferingClass") - objectKey.String(string(v.OfferingClass)) - } - - if len(v.OfferingType) > 0 { - objectKey := object.Key("OfferingType") - objectKey.String(string(v.OfferingType)) - } - - if len(v.ProductDescription) > 0 { - objectKey := object.Key("ProductDescription") - objectKey.String(string(v.ProductDescription)) - } - - if v.ReservedInstancesOfferingIds != nil { - objectKey := object.FlatKey("ReservedInstancesOfferingId") - if err := awsEc2query_serializeDocumentReservedInstancesOfferingIdStringList(v.ReservedInstancesOfferingIds, objectKey); err != nil { - return err - } - } - - return nil -} - -func awsEc2query_serializeOpDocumentDescribeRouteServerEndpointsInput(v *DescribeRouteServerEndpointsInput, 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.MaxSlotDurationInHours != nil { + objectKey := object.Key("MaxSlotDurationInHours") + objectKey.Integer(*v.MaxSlotDurationInHours) } - if v.MaxResults != nil { - objectKey := object.Key("MaxResults") - objectKey.Integer(*v.MaxResults) + if v.MinSlotDurationInHours != nil { + objectKey := object.Key("MinSlotDurationInHours") + objectKey.Integer(*v.MinSlotDurationInHours) } if v.NextToken != nil { @@ -76494,9 +77507,9 @@ func awsEc2query_serializeOpDocumentDescribeRouteServerEndpointsInput(v *Describ objectKey.String(*v.NextToken) } - if v.RouteServerEndpointIds != nil { - objectKey := object.FlatKey("RouteServerEndpointId") - if err := awsEc2query_serializeDocumentRouteServerEndpointIdsList(v.RouteServerEndpointIds, objectKey); err != nil { + if v.Recurrence != nil { + objectKey := object.Key("Recurrence") + if err := awsEc2query_serializeDocumentScheduledInstanceRecurrenceRequest(v.Recurrence, objectKey); err != nil { return err } } @@ -76504,7 +77517,7 @@ func awsEc2query_serializeOpDocumentDescribeRouteServerEndpointsInput(v *Describ return nil } -func awsEc2query_serializeOpDocumentDescribeRouteServerPeersInput(v *DescribeRouteServerPeersInput, value query.Value) error { +func awsEc2query_serializeOpDocumentDescribeScheduledInstancesInput(v *DescribeScheduledInstancesInput, value query.Value) error { object := value.Object() _ = object @@ -76530,45 +77543,16 @@ func awsEc2query_serializeOpDocumentDescribeRouteServerPeersInput(v *DescribeRou objectKey.String(*v.NextToken) } - if v.RouteServerPeerIds != nil { - objectKey := object.FlatKey("RouteServerPeerId") - if err := awsEc2query_serializeDocumentRouteServerPeerIdsList(v.RouteServerPeerIds, objectKey); err != nil { - return err - } - } - - return nil -} - -func awsEc2query_serializeOpDocumentDescribeRouteServersInput(v *DescribeRouteServersInput, 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 { + if v.ScheduledInstanceIds != nil { + objectKey := object.FlatKey("ScheduledInstanceId") + if err := awsEc2query_serializeDocumentScheduledInstanceIdRequestSet(v.ScheduledInstanceIds, 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) - } - - if v.RouteServerIds != nil { - objectKey := object.FlatKey("RouteServerId") - if err := awsEc2query_serializeDocumentRouteServerIdsList(v.RouteServerIds, objectKey); err != nil { + if v.SlotStartTimeRange != nil { + objectKey := object.Key("SlotStartTimeRange") + if err := awsEc2query_serializeDocumentSlotStartTimeRangeRequest(v.SlotStartTimeRange, objectKey); err != nil { return err } } @@ -76576,7 +77560,7 @@ func awsEc2query_serializeOpDocumentDescribeRouteServersInput(v *DescribeRouteSe return nil } -func awsEc2query_serializeOpDocumentDescribeRouteTablesInput(v *DescribeRouteTablesInput, value query.Value) error { +func awsEc2query_serializeOpDocumentDescribeSecondaryInterfacesInput(v *DescribeSecondaryInterfacesInput, value query.Value) error { object := value.Object() _ = object @@ -76602,9 +77586,9 @@ func awsEc2query_serializeOpDocumentDescribeRouteTablesInput(v *DescribeRouteTab objectKey.String(*v.NextToken) } - if v.RouteTableIds != nil { - objectKey := object.FlatKey("RouteTableId") - if err := awsEc2query_serializeDocumentRouteTableIdStringList(v.RouteTableIds, objectKey); err != nil { + if v.SecondaryInterfaceIds != nil { + objectKey := object.FlatKey("SecondaryInterfaceId") + if err := awsEc2query_serializeDocumentSecondaryInterfaceIdList(v.SecondaryInterfaceIds, objectKey); err != nil { return err } } @@ -76612,7 +77596,7 @@ func awsEc2query_serializeOpDocumentDescribeRouteTablesInput(v *DescribeRouteTab return nil } -func awsEc2query_serializeOpDocumentDescribeScheduledInstanceAvailabilityInput(v *DescribeScheduledInstanceAvailabilityInput, value query.Value) error { +func awsEc2query_serializeOpDocumentDescribeSecondaryNetworksInput(v *DescribeSecondaryNetworksInput, value query.Value) error { object := value.Object() _ = object @@ -76628,36 +77612,19 @@ func awsEc2query_serializeOpDocumentDescribeScheduledInstanceAvailabilityInput(v } } - if v.FirstSlotStartTimeRange != nil { - objectKey := object.Key("FirstSlotStartTimeRange") - if err := awsEc2query_serializeDocumentSlotDateTimeRangeRequest(v.FirstSlotStartTimeRange, objectKey); err != nil { - return err - } - } - if v.MaxResults != nil { objectKey := object.Key("MaxResults") objectKey.Integer(*v.MaxResults) } - if v.MaxSlotDurationInHours != nil { - objectKey := object.Key("MaxSlotDurationInHours") - objectKey.Integer(*v.MaxSlotDurationInHours) - } - - if v.MinSlotDurationInHours != nil { - objectKey := object.Key("MinSlotDurationInHours") - objectKey.Integer(*v.MinSlotDurationInHours) - } - if v.NextToken != nil { objectKey := object.Key("NextToken") objectKey.String(*v.NextToken) } - if v.Recurrence != nil { - objectKey := object.Key("Recurrence") - if err := awsEc2query_serializeDocumentScheduledInstanceRecurrenceRequest(v.Recurrence, objectKey); err != nil { + if v.SecondaryNetworkIds != nil { + objectKey := object.FlatKey("SecondaryNetworkId") + if err := awsEc2query_serializeDocumentSecondaryNetworkIdList(v.SecondaryNetworkIds, objectKey); err != nil { return err } } @@ -76665,7 +77632,7 @@ func awsEc2query_serializeOpDocumentDescribeScheduledInstanceAvailabilityInput(v return nil } -func awsEc2query_serializeOpDocumentDescribeScheduledInstancesInput(v *DescribeScheduledInstancesInput, value query.Value) error { +func awsEc2query_serializeOpDocumentDescribeSecondarySubnetsInput(v *DescribeSecondarySubnetsInput, value query.Value) error { object := value.Object() _ = object @@ -76691,16 +77658,9 @@ func awsEc2query_serializeOpDocumentDescribeScheduledInstancesInput(v *DescribeS objectKey.String(*v.NextToken) } - if v.ScheduledInstanceIds != nil { - objectKey := object.FlatKey("ScheduledInstanceId") - if err := awsEc2query_serializeDocumentScheduledInstanceIdRequestSet(v.ScheduledInstanceIds, objectKey); err != nil { - return err - } - } - - if v.SlotStartTimeRange != nil { - objectKey := object.Key("SlotStartTimeRange") - if err := awsEc2query_serializeDocumentSlotStartTimeRangeRequest(v.SlotStartTimeRange, objectKey); err != nil { + if v.SecondarySubnetIds != nil { + objectKey := object.FlatKey("SecondarySubnetId") + if err := awsEc2query_serializeDocumentSecondarySubnetIdList(v.SecondarySubnetIds, objectKey); err != nil { return err } } @@ -83360,6 +84320,11 @@ func awsEc2query_serializeOpDocumentModifyInstanceCpuOptionsInput(v *ModifyInsta objectKey.String(*v.InstanceId) } + if len(v.NestedVirtualization) > 0 { + objectKey := object.Key("NestedVirtualization") + objectKey.String(string(v.NestedVirtualization)) + } + if v.ThreadsPerCore != nil { objectKey := object.Key("ThreadsPerCore") objectKey.Integer(*v.ThreadsPerCore) @@ -83504,6 +84469,11 @@ func awsEc2query_serializeOpDocumentModifyInstanceMetadataDefaultsInput(v *Modif objectKey.String(string(v.HttpTokens)) } + if len(v.HttpTokensEnforced) > 0 { + objectKey := object.Key("HttpTokensEnforced") + objectKey.String(string(v.HttpTokensEnforced)) + } + if len(v.InstanceMetadataTags) > 0 { objectKey := object.Key("InstanceMetadataTags") objectKey.String(string(v.InstanceMetadataTags)) @@ -87588,6 +88558,13 @@ func awsEc2query_serializeOpDocumentRunInstancesInput(v *RunInstancesInput, valu objectKey.String(*v.RamdiskId) } + if v.SecondaryInterfaces != nil { + objectKey := object.FlatKey("SecondaryInterface") + if err := awsEc2query_serializeDocumentInstanceSecondaryInterfaceSpecificationListRequest(v.SecondaryInterfaces, objectKey); err != nil { + return err + } + } + if v.SecurityGroupIds != nil { objectKey := object.FlatKey("SecurityGroupId") if err := awsEc2query_serializeDocumentSecurityGroupIdStringList(v.SecurityGroupIds, objectKey); err != nil { diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/types/enums.go b/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/types/enums.go index 2cf81f96a..6d0ff724f 100644 --- a/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/types/enums.go +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/types/enums.go @@ -1800,6 +1800,28 @@ func (DatafeedSubscriptionState) Values() []DatafeedSubscriptionState { } } +type DefaultHttpTokensEnforcedState string + +// Enum values for DefaultHttpTokensEnforcedState +const ( + DefaultHttpTokensEnforcedStateDisabled DefaultHttpTokensEnforcedState = "disabled" + DefaultHttpTokensEnforcedStateEnabled DefaultHttpTokensEnforcedState = "enabled" + DefaultHttpTokensEnforcedStateNoPreference DefaultHttpTokensEnforcedState = "no-preference" +) + +// Values returns all known values for DefaultHttpTokensEnforcedState. 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 (DefaultHttpTokensEnforcedState) Values() []DefaultHttpTokensEnforcedState { + return []DefaultHttpTokensEnforcedState{ + "disabled", + "enabled", + "no-preference", + } +} + type DefaultInstanceMetadataEndpointState string // Enum values for DefaultInstanceMetadataEndpointState @@ -3184,6 +3206,25 @@ func (HostTenancy) Values() []HostTenancy { } } +type HttpTokensEnforcedState string + +// Enum values for HttpTokensEnforcedState +const ( + HttpTokensEnforcedStateDisabled HttpTokensEnforcedState = "disabled" + HttpTokensEnforcedStateEnabled HttpTokensEnforcedState = "enabled" +) + +// Values returns all known values for HttpTokensEnforcedState. 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 (HttpTokensEnforcedState) Values() []HttpTokensEnforcedState { + return []HttpTokensEnforcedState{ + "disabled", + "enabled", + } +} + type HttpTokensState string // Enum values for HttpTokensState @@ -5069,6 +5110,46 @@ const ( InstanceTypeG7e12xlarge InstanceType = "g7e.12xlarge" InstanceTypeG7e24xlarge InstanceType = "g7e.24xlarge" InstanceTypeG7e48xlarge InstanceType = "g7e.48xlarge" + InstanceTypeR8idLarge InstanceType = "r8id.large" + InstanceTypeR8idXlarge InstanceType = "r8id.xlarge" + InstanceTypeR8id2xlarge InstanceType = "r8id.2xlarge" + InstanceTypeR8id4xlarge InstanceType = "r8id.4xlarge" + InstanceTypeR8id8xlarge InstanceType = "r8id.8xlarge" + InstanceTypeR8id12xlarge InstanceType = "r8id.12xlarge" + InstanceTypeR8id16xlarge InstanceType = "r8id.16xlarge" + InstanceTypeR8id24xlarge InstanceType = "r8id.24xlarge" + InstanceTypeR8id32xlarge InstanceType = "r8id.32xlarge" + InstanceTypeR8id48xlarge InstanceType = "r8id.48xlarge" + InstanceTypeR8id96xlarge InstanceType = "r8id.96xlarge" + InstanceTypeR8idMetal48xl InstanceType = "r8id.metal-48xl" + InstanceTypeR8idMetal96xl InstanceType = "r8id.metal-96xl" + InstanceTypeC8idLarge InstanceType = "c8id.large" + InstanceTypeC8idXlarge InstanceType = "c8id.xlarge" + InstanceTypeC8id2xlarge InstanceType = "c8id.2xlarge" + InstanceTypeC8id4xlarge InstanceType = "c8id.4xlarge" + InstanceTypeC8id8xlarge InstanceType = "c8id.8xlarge" + InstanceTypeC8id12xlarge InstanceType = "c8id.12xlarge" + InstanceTypeC8id16xlarge InstanceType = "c8id.16xlarge" + InstanceTypeC8id24xlarge InstanceType = "c8id.24xlarge" + InstanceTypeC8id32xlarge InstanceType = "c8id.32xlarge" + InstanceTypeC8id48xlarge InstanceType = "c8id.48xlarge" + InstanceTypeC8id96xlarge InstanceType = "c8id.96xlarge" + InstanceTypeC8idMetal48xl InstanceType = "c8id.metal-48xl" + InstanceTypeC8idMetal96xl InstanceType = "c8id.metal-96xl" + InstanceTypeM8idLarge InstanceType = "m8id.large" + InstanceTypeM8idXlarge InstanceType = "m8id.xlarge" + InstanceTypeM8id2xlarge InstanceType = "m8id.2xlarge" + InstanceTypeM8id4xlarge InstanceType = "m8id.4xlarge" + InstanceTypeM8id8xlarge InstanceType = "m8id.8xlarge" + InstanceTypeM8id12xlarge InstanceType = "m8id.12xlarge" + InstanceTypeM8id16xlarge InstanceType = "m8id.16xlarge" + InstanceTypeM8id24xlarge InstanceType = "m8id.24xlarge" + InstanceTypeM8id32xlarge InstanceType = "m8id.32xlarge" + InstanceTypeM8id48xlarge InstanceType = "m8id.48xlarge" + InstanceTypeM8id96xlarge InstanceType = "m8id.96xlarge" + InstanceTypeM8idMetal48xl InstanceType = "m8id.metal-48xl" + InstanceTypeM8idMetal96xl InstanceType = "m8id.metal-96xl" + InstanceTypeHpc8a96xlarge InstanceType = "hpc8a.96xlarge" ) // Values returns all known values for InstanceType. Note that this can be @@ -6249,6 +6330,46 @@ func (InstanceType) Values() []InstanceType { "g7e.12xlarge", "g7e.24xlarge", "g7e.48xlarge", + "r8id.large", + "r8id.xlarge", + "r8id.2xlarge", + "r8id.4xlarge", + "r8id.8xlarge", + "r8id.12xlarge", + "r8id.16xlarge", + "r8id.24xlarge", + "r8id.32xlarge", + "r8id.48xlarge", + "r8id.96xlarge", + "r8id.metal-48xl", + "r8id.metal-96xl", + "c8id.large", + "c8id.xlarge", + "c8id.2xlarge", + "c8id.4xlarge", + "c8id.8xlarge", + "c8id.12xlarge", + "c8id.16xlarge", + "c8id.24xlarge", + "c8id.32xlarge", + "c8id.48xlarge", + "c8id.96xlarge", + "c8id.metal-48xl", + "c8id.metal-96xl", + "m8id.large", + "m8id.xlarge", + "m8id.2xlarge", + "m8id.4xlarge", + "m8id.8xlarge", + "m8id.12xlarge", + "m8id.16xlarge", + "m8id.24xlarge", + "m8id.32xlarge", + "m8id.48xlarge", + "m8id.96xlarge", + "m8id.metal-48xl", + "m8id.metal-96xl", + "hpc8a.96xlarge", } } @@ -8363,6 +8484,26 @@ func (NatGatewayState) Values() []NatGatewayState { } } +type NestedVirtualizationSpecification string + +// Enum values for NestedVirtualizationSpecification +const ( + NestedVirtualizationSpecificationEnabled NestedVirtualizationSpecification = "enabled" + NestedVirtualizationSpecificationDisabled NestedVirtualizationSpecification = "disabled" +) + +// Values returns all known values for NestedVirtualizationSpecification. 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 (NestedVirtualizationSpecification) Values() []NestedVirtualizationSpecification { + return []NestedVirtualizationSpecification{ + "enabled", + "disabled", + } +} + type NetworkInterfaceAttribute string // Enum values for NetworkInterfaceAttribute @@ -9400,6 +9541,9 @@ const ( ResourceTypeIpamPrefixListResolver ResourceType = "ipam-prefix-list-resolver" ResourceTypeIpamPolicy ResourceType = "ipam-policy" ResourceTypeIpamPrefixListResolverTarget ResourceType = "ipam-prefix-list-resolver-target" + ResourceTypeSecondaryInterface ResourceType = "secondary-interface" + ResourceTypeSecondaryNetwork ResourceType = "secondary-network" + ResourceTypeSecondarySubnet ResourceType = "secondary-subnet" ResourceTypeCapacityManagerDataExport ResourceType = "capacity-manager-data-export" ResourceTypeVpnConcentrator ResourceType = "vpn-concentrator" ) @@ -9512,6 +9656,9 @@ func (ResourceType) Values() []ResourceType { "ipam-prefix-list-resolver", "ipam-policy", "ipam-prefix-list-resolver-target", + "secondary-interface", + "secondary-network", + "secondary-subnet", "capacity-manager-data-export", "vpn-concentrator", } @@ -9953,6 +10100,169 @@ func (Scope) Values() []Scope { } } +type SecondaryInterfaceStatus string + +// Enum values for SecondaryInterfaceStatus +const ( + SecondaryInterfaceStatusAvailable SecondaryInterfaceStatus = "available" + SecondaryInterfaceStatusInUse SecondaryInterfaceStatus = "in-use" +) + +// Values returns all known values for SecondaryInterfaceStatus. 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 (SecondaryInterfaceStatus) Values() []SecondaryInterfaceStatus { + return []SecondaryInterfaceStatus{ + "available", + "in-use", + } +} + +type SecondaryInterfaceType string + +// Enum values for SecondaryInterfaceType +const ( + SecondaryInterfaceTypeSecondary SecondaryInterfaceType = "secondary" +) + +// Values returns all known values for SecondaryInterfaceType. 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 (SecondaryInterfaceType) Values() []SecondaryInterfaceType { + return []SecondaryInterfaceType{ + "secondary", + } +} + +type SecondaryNetworkCidrBlockAssociationState string + +// Enum values for SecondaryNetworkCidrBlockAssociationState +const ( + SecondaryNetworkCidrBlockAssociationStateAssociating SecondaryNetworkCidrBlockAssociationState = "associating" + SecondaryNetworkCidrBlockAssociationStateAssociated SecondaryNetworkCidrBlockAssociationState = "associated" + SecondaryNetworkCidrBlockAssociationStateAssociationFailed SecondaryNetworkCidrBlockAssociationState = "association-failed" + SecondaryNetworkCidrBlockAssociationStateDisassociating SecondaryNetworkCidrBlockAssociationState = "disassociating" + SecondaryNetworkCidrBlockAssociationStateDisassociated SecondaryNetworkCidrBlockAssociationState = "disassociated" + SecondaryNetworkCidrBlockAssociationStateDisassociationFailed SecondaryNetworkCidrBlockAssociationState = "disassociation-failed" +) + +// Values returns all known values for SecondaryNetworkCidrBlockAssociationState. +// 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 (SecondaryNetworkCidrBlockAssociationState) Values() []SecondaryNetworkCidrBlockAssociationState { + return []SecondaryNetworkCidrBlockAssociationState{ + "associating", + "associated", + "association-failed", + "disassociating", + "disassociated", + "disassociation-failed", + } +} + +type SecondaryNetworkState string + +// Enum values for SecondaryNetworkState +const ( + SecondaryNetworkStateCreateInProgress SecondaryNetworkState = "create-in-progress" + SecondaryNetworkStateCreateComplete SecondaryNetworkState = "create-complete" + SecondaryNetworkStateCreateFailed SecondaryNetworkState = "create-failed" + SecondaryNetworkStateDeleteInProgress SecondaryNetworkState = "delete-in-progress" + SecondaryNetworkStateDeleteComplete SecondaryNetworkState = "delete-complete" + SecondaryNetworkStateDeleteFailed SecondaryNetworkState = "delete-failed" +) + +// Values returns all known values for SecondaryNetworkState. 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 (SecondaryNetworkState) Values() []SecondaryNetworkState { + return []SecondaryNetworkState{ + "create-in-progress", + "create-complete", + "create-failed", + "delete-in-progress", + "delete-complete", + "delete-failed", + } +} + +type SecondaryNetworkType string + +// Enum values for SecondaryNetworkType +const ( + SecondaryNetworkTypeRdma SecondaryNetworkType = "rdma" +) + +// Values returns all known values for SecondaryNetworkType. 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 (SecondaryNetworkType) Values() []SecondaryNetworkType { + return []SecondaryNetworkType{ + "rdma", + } +} + +type SecondarySubnetCidrBlockAssociationState string + +// Enum values for SecondarySubnetCidrBlockAssociationState +const ( + SecondarySubnetCidrBlockAssociationStateAssociating SecondarySubnetCidrBlockAssociationState = "associating" + SecondarySubnetCidrBlockAssociationStateAssociated SecondarySubnetCidrBlockAssociationState = "associated" + SecondarySubnetCidrBlockAssociationStateAssociationFailed SecondarySubnetCidrBlockAssociationState = "association-failed" + SecondarySubnetCidrBlockAssociationStateDisassociating SecondarySubnetCidrBlockAssociationState = "disassociating" + SecondarySubnetCidrBlockAssociationStateDisassociated SecondarySubnetCidrBlockAssociationState = "disassociated" + SecondarySubnetCidrBlockAssociationStateDisassociationFailed SecondarySubnetCidrBlockAssociationState = "disassociation-failed" +) + +// Values returns all known values for SecondarySubnetCidrBlockAssociationState. +// 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 (SecondarySubnetCidrBlockAssociationState) Values() []SecondarySubnetCidrBlockAssociationState { + return []SecondarySubnetCidrBlockAssociationState{ + "associating", + "associated", + "association-failed", + "disassociating", + "disassociated", + "disassociation-failed", + } +} + +type SecondarySubnetState string + +// Enum values for SecondarySubnetState +const ( + SecondarySubnetStateCreateInProgress SecondarySubnetState = "create-in-progress" + SecondarySubnetStateCreateComplete SecondarySubnetState = "create-complete" + SecondarySubnetStateCreateFailed SecondarySubnetState = "create-failed" + SecondarySubnetStateDeleteInProgress SecondarySubnetState = "delete-in-progress" + SecondarySubnetStateDeleteComplete SecondarySubnetState = "delete-complete" + SecondarySubnetStateDeleteFailed SecondarySubnetState = "delete-failed" +) + +// Values returns all known values for SecondarySubnetState. 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 (SecondarySubnetState) Values() []SecondarySubnetState { + return []SecondarySubnetState{ + "create-in-progress", + "create-complete", + "create-failed", + "delete-in-progress", + "delete-complete", + "delete-failed", + } +} + type SecurityGroupReferencingSupportValue string // Enum values for SecurityGroupReferencingSupportValue @@ -10662,7 +10972,8 @@ type SupportedAdditionalProcessorFeature string // Enum values for SupportedAdditionalProcessorFeature const ( - SupportedAdditionalProcessorFeatureAmdSevSnp SupportedAdditionalProcessorFeature = "amd-sev-snp" + SupportedAdditionalProcessorFeatureAmdSevSnp SupportedAdditionalProcessorFeature = "amd-sev-snp" + SupportedAdditionalProcessorFeatureNestedVirtualization SupportedAdditionalProcessorFeature = "nested-virtualization" ) // Values returns all known values for SupportedAdditionalProcessorFeature. Note @@ -10673,6 +10984,7 @@ const ( func (SupportedAdditionalProcessorFeature) Values() []SupportedAdditionalProcessorFeature { return []SupportedAdditionalProcessorFeature{ "amd-sev-snp", + "nested-virtualization", } } diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/types/types.go b/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/types/types.go index c16e338ed..023936c7b 100644 --- a/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/types/types.go +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/types/types.go @@ -859,6 +859,10 @@ type AuthorizationRule struct { // Describes Availability Zones, Local Zones, and Wavelength Zones. type AvailabilityZone struct { + // The geography information for the Availability Zone or Local Zone. The + // geography is returned as a list. + Geography []AvailabilityZoneGeography + // The long name of the Availability Zone group, Local Zone group, or Wavelength // Zone group. GroupLongName *string @@ -900,6 +904,10 @@ type AvailabilityZone struct { // possible values are available , unavailable , and constrained . State AvailabilityZoneState + // The sub-geography information for the Availability Zone or Local Zone. The + // sub-geography is returned as a list. + SubGeography []AvailabilityZoneSubGeography + // The ID of the Availability Zone, Local Zone, or Wavelength Zone. ZoneId *string @@ -954,6 +962,15 @@ type AvailabilityZoneAddress struct { noSmithyDocumentSerde } +// Describes the geography information for an Availability Zone or Local Zone. +type AvailabilityZoneGeography struct { + + // The name of the geography, for example, United States of America . + Name *string + + noSmithyDocumentSerde +} + // Describes a message about an Availability Zone, Local Zone, or Wavelength Zone. type AvailabilityZoneMessage struct { @@ -963,6 +980,15 @@ type AvailabilityZoneMessage struct { noSmithyDocumentSerde } +// Describes the sub-geography information for an Availability Zone or Local Zone. +type AvailabilityZoneSubGeography struct { + + // The name of the sub-geography, for example, Oregon. + Name *string + + noSmithyDocumentSerde +} + // The capacity information for instances that can be launched onto the Dedicated // Host. type AvailableCapacity struct { @@ -1337,6 +1363,10 @@ type CancelSpotFleetRequestsSuccessItem struct { // Information about instance capacity usage for a Capacity Reservation. type CapacityAllocation struct { + // Additional metadata associated with the capacity allocation. Each entry + // contains a key-value pair providing context about the allocation. + AllocationMetadata []CapacityAllocationMetadataEntry + // The usage type. used indicates that the instance capacity is in use by // instances that are running in the Capacity Reservation. AllocationType AllocationType @@ -1348,6 +1378,18 @@ type CapacityAllocation struct { noSmithyDocumentSerde } +// A key-value pair that provides additional metadata about a capacity allocation. +type CapacityAllocationMetadataEntry struct { + + // The key of the metadata entry. + Key *string + + // The value of the metadata entry. + Value *string + + noSmithyDocumentSerde +} + // Reserve powerful GPU instances on a future date to support your short duration // machine learning (ML) workloads. Instances that run inside a Capacity Block are // automatically placed close together inside [Amazon EC2 UltraClusters], for low-latency, petabit-scale, @@ -1452,6 +1494,9 @@ type CapacityBlockExtension struct { // The total price to be paid up front. UpfrontFee *string + // The type of zone where the Capacity Block extension is located. + ZoneType *string + noSmithyDocumentSerde } @@ -1505,6 +1550,9 @@ type CapacityBlockExtensionOffering struct { // The total price of the Capacity Block extension offering, to be paid up front. UpfrontFee *string + // The type of zone where the Capacity Block extension offering is available. + ZoneType *string + noSmithyDocumentSerde } @@ -1554,6 +1602,9 @@ type CapacityBlockOffering struct { // The total price to be paid up front. UpfrontFee *string + // The type of zone where the Capacity Block offering is available. + ZoneType *string + noSmithyDocumentSerde } @@ -3219,6 +3270,9 @@ type CpuOptions struct { // The number of CPU cores for the instance. CoreCount *int32 + // Indicates whether the instance is enabled for nested virtualization. + NestedVirtualization NestedVirtualizationSpecification + // The number of threads per CPU core. ThreadsPerCore *int32 @@ -3239,6 +3293,12 @@ type CpuOptionsRequest struct { // The number of CPU cores for the instance. CoreCount *int32 + // Indicates whether to enable the instance for nested virtualization. Nested + // virtualization is supported only on 8th generation Intel-based instance types + // (c8i, m8i, r8i, and their flex variants). When nested virtualization is enabled, + // Virtual Secure Mode (VSM) is automatically disabled for the instance. + NestedVirtualization NestedVirtualizationSpecification + // The number of threads per CPU core. To disable multithreading for the instance, // specify a value of 1 . Otherwise, specify the default value of 2 . ThreadsPerCore *int32 @@ -8381,6 +8441,9 @@ type Instance struct { // instance store volume. RootDeviceType DeviceType + // The secondary interfaces for the instance. + SecondaryInterfaces []InstanceSecondaryInterface + // The security groups for the instance. SecurityGroups []GroupIdentifier @@ -8905,10 +8968,15 @@ type InstanceMetadataDefaultsResponse struct { // must use IMDSv2. HttpTokens HttpTokensState + // Indicates whether to enforce the requirement of IMDSv2 on an instance at the + // time of launch. When enforcement is enabled, the instance can't launch unless + // IMDSv2 ( HttpTokens ) is set to required . + HttpTokensEnforced HttpTokensEnforcedState + // Indicates whether access to instance tags from the instance metadata is enabled - // or disabled. For more information, see [Work with instance tags using the instance metadata]in the Amazon EC2 User Guide. + // or disabled. For more information, see [View tags for your EC2 instances using instance metadata]in the Amazon EC2 User Guide. // - // [Work with instance tags using the instance metadata]: https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Using_Tags.html#work-with-tags-in-IMDS + // [View tags for your EC2 instances using instance metadata]: https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/work-with-tags-in-IMDS.html InstanceMetadataTags InstanceMetadataTagsState // The entity that manages the IMDS default settings. Possible values include: @@ -8971,11 +9039,11 @@ type InstanceMetadataOptionsRequest struct { // Set to enabled to allow access to instance tags from the instance metadata. Set // to disabled to turn off access to instance tags from the instance metadata. For - // more information, see [Work with instance tags using the instance metadata]. + // more information, see [View tags for your EC2 instances using instance metadata]. // // Default: disabled // - // [Work with instance tags using the instance metadata]: https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Using_Tags.html#work-with-tags-in-IMDS + // [View tags for your EC2 instances using instance metadata]: https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/work-with-tags-in-IMDS.html InstanceMetadataTags InstanceMetadataTagsState noSmithyDocumentSerde @@ -9011,9 +9079,9 @@ type InstanceMetadataOptionsResponse struct { HttpTokens HttpTokensState // Indicates whether access to instance tags from the instance metadata is enabled - // or disabled. For more information, see [Work with instance tags using the instance metadata]. + // or disabled. For more information, see [View tags for your EC2 instances using instance metadata]. // - // [Work with instance tags using the instance metadata]: https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Using_Tags.html#work-with-tags-in-IMDS + // [View tags for your EC2 instances using instance metadata]: https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/work-with-tags-in-IMDS.html InstanceMetadataTags InstanceMetadataTagsState // The state of the metadata option changes. @@ -10171,6 +10239,120 @@ type InstanceRequirementsWithMetadataRequest struct { noSmithyDocumentSerde } +// Describes a secondary interface attached to an instance. +type InstanceSecondaryInterface struct { + + // The attachment information for the secondary interface. + Attachment *InstanceSecondaryInterfaceAttachment + + // The type of secondary interface. + InterfaceType SecondaryInterfaceType + + // The MAC address of the secondary interface. + MacAddress *string + + // The Amazon Web Services account ID of the owner of the secondary interface. + OwnerId *string + + // The private IPv4 addresses associated with the secondary interface. + PrivateIpAddresses []InstanceSecondaryInterfacePrivateIpAddress + + // The ID of the secondary interface. + SecondaryInterfaceId *string + + // The ID of the secondary network. + SecondaryNetworkId *string + + // The ID of the secondary subnet. + SecondarySubnetId *string + + // Indicates whether source/destination checking is enabled. + SourceDestCheck *bool + + // The status of the secondary interface. + Status SecondaryInterfaceStatus + + noSmithyDocumentSerde +} + +// Describes the attachment of a secondary interface to an instance. +type InstanceSecondaryInterfaceAttachment struct { + + // The timestamp when the attachment was created. + AttachTime *time.Time + + // The ID of the attachment. + AttachmentId *string + + // Indicates whether the secondary interface is deleted when the instance is + // terminated. + // + // The only supported value for this field is true . + DeleteOnTermination *bool + + // The device index of the secondary interface. + DeviceIndex *int32 + + // The index of the network card. + NetworkCardIndex *int32 + + // The attachment state. + Status AttachmentStatus + + noSmithyDocumentSerde +} + +// Describes a private IPv4 address for a secondary interface. +type InstanceSecondaryInterfacePrivateIpAddress struct { + + // The private IPv4 address. + PrivateIpAddress *string + + noSmithyDocumentSerde +} + +// Describes a private IPv4 address for a secondary interface request. +type InstanceSecondaryInterfacePrivateIpAddressRequest struct { + + // The private IPv4 address. + // + // This member is required. + PrivateIpAddress *string + + noSmithyDocumentSerde +} + +// Describes a secondary interface specification for launching an instance. +type InstanceSecondaryInterfaceSpecificationRequest struct { + + // Indicates whether the secondary interface is deleted when the instance is + // terminated. + // + // The only supported value for this field is true . + DeleteOnTermination *bool + + // The device index for the secondary interface attachment. + DeviceIndex *int32 + + // The type of secondary interface. + InterfaceType SecondaryInterfaceType + + // The index of the network card. The network card must support secondary + // interfaces. + NetworkCardIndex *int32 + + // The number of private IPv4 addresses to assign to the secondary interface. + PrivateIpAddressCount *int32 + + // The private IPv4 addresses to assign to the secondary interface. + PrivateIpAddresses []InstanceSecondaryInterfacePrivateIpAddressRequest + + // The ID of the secondary subnet. + SecondarySubnetId *string + + noSmithyDocumentSerde +} + // The instance details to specify which volumes should be snapshotted. type InstanceSpecification struct { @@ -12775,6 +12957,9 @@ type LaunchTemplateCpuOptions struct { // The number of CPU cores for the instance. CoreCount *int32 + // Indicates whether the instance is enabled for nested virtualization. + NestedVirtualization NestedVirtualizationSpecification + // The number of threads per CPU core. ThreadsPerCore *int32 @@ -12795,6 +12980,12 @@ type LaunchTemplateCpuOptionsRequest struct { // The number of CPU cores for the instance. CoreCount *int32 + // Indicates whether to enable the instance for nested virtualization. Nested + // virtualization is supported only on 8th generation Intel-based instance types + // (c8i, m8i, r8i, and their flex variants). When nested virtualization is enabled, + // Virtual Secure Mode (VSM) is automatically disabled for the instance. + NestedVirtualization NestedVirtualizationSpecification + // The number of threads per CPU core. To disable multithreading for the instance, // specify a value of 1 . Otherwise, specify the default value of 2 . ThreadsPerCore *int32 @@ -13466,6 +13657,70 @@ type LaunchTemplateInstanceNetworkInterfaceSpecificationRequest struct { noSmithyDocumentSerde } +// Describes a secondary interface specification in a launch template. +type LaunchTemplateInstanceSecondaryInterfaceSpecification struct { + + // Indicates whether the secondary interface is deleted when the instance is + // terminated. + // + // The only supported value for this field is true . + DeleteOnTermination *bool + + // The device index for the secondary interface attachment. + DeviceIndex *int32 + + // The type of secondary interface. + InterfaceType SecondaryInterfaceType + + // The index of the network card. + NetworkCardIndex *int32 + + // The number of private IPv4 addresses to assign to the secondary interface. + // + // If you specify privateIpAddressCount you cannot specify privateIpAddresses + PrivateIpAddressCount *int32 + + // The private IPv4 addresses to assign to the secondary interface. + // + // If you specify privateIpAddresses you cannot specify privateIpAddressCount + PrivateIpAddresses []SecondaryInterfacePrivateIpAddressSpecification + + // The ID of the secondary subnet. + SecondarySubnetId *string + + noSmithyDocumentSerde +} + +// Describes a secondary interface specification for a launch template request. +type LaunchTemplateInstanceSecondaryInterfaceSpecificationRequest struct { + + // Indicates whether the secondary interface is deleted when the instance is + // terminated. + // + // The only supported value for this field is true . + DeleteOnTermination *bool + + // The device index for the secondary interface attachment. + DeviceIndex *int32 + + // The type of secondary interface. + InterfaceType SecondaryInterfaceType + + // The index of the network card. + NetworkCardIndex *int32 + + // The number of private IPv4 addresses to assign to the secondary interface. + PrivateIpAddressCount *int32 + + // The private IPv4 addresses to assign to the secondary interface. + PrivateIpAddresses []SecondaryInterfacePrivateIpAddressSpecificationRequest + + // The ID of the secondary subnet. + SecondarySubnetId *string + + noSmithyDocumentSerde +} + // Describes a license configuration. type LaunchTemplateLicenseConfiguration struct { @@ -15434,6 +15689,9 @@ type NetworkInfo struct { // The maximum number of IPv4 addresses per network interface. Ipv4AddressesPerInterface *int32 + // The maximum number of IPv4 addresses per secondary interface. + Ipv4AddressesPerSecondaryInterface *int32 + // The maximum number of IPv6 addresses per network interface. Ipv6AddressesPerInterface *int32 @@ -15447,12 +15705,19 @@ type NetworkInfo struct { // The maximum number of network interfaces for the instance type. MaximumNetworkInterfaces *int32 + // The maximum number of secondary interfaces for the instance type. + MaximumSecondaryNetworkInterfaces *int32 + // Describes the network cards for the instance type. NetworkCards []NetworkCardInfo // The network performance. NetworkPerformance *string + // Indicates whether secondary interface attachments from secondary network are + // supported. + SecondaryNetworkSupported *bool + noSmithyDocumentSerde } @@ -16802,6 +17067,9 @@ type PlacementGroup struct { // Reserved for future use. LinkedGroupId *string + // The service provider that manages the Placement Group. + Operator *OperatorResponse + // The number of partitions. Valid only if strategy is set to partition . PartitionCount *int32 @@ -17333,6 +17601,9 @@ type Region struct { // The Region service endpoint. Endpoint *string + // The geography information for the Region. The geography is returned as a list. + Geography []RegionGeography + // The Region opt-in status. The possible values are opt-in-not-required , opted-in // , and not-opted-in . OptInStatus *string @@ -17360,6 +17631,15 @@ type RegionalSummary struct { noSmithyDocumentSerde } +// Describes the geography information for a Region. +type RegionGeography struct { + + // The name of the geography, for example, United States of America . + Name *string + + noSmithyDocumentSerde +} + // Describes an Amazon EC2 instance that is enabled for SQL Server High // Availability standby detection monitoring. type RegisteredInstance struct { @@ -17810,6 +18090,9 @@ type RequestLaunchTemplateData struct { // [User provided kernels]: https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/UserProvidedkernels.html RamDiskId *string + // The secondary interfaces to associate with instances launched from the template. + SecondaryInterfaces []LaunchTemplateInstanceSecondaryInterfaceSpecificationRequest + // The IDs of the security groups. // // If you specify a network interface, you must specify any security groups as @@ -18495,6 +18778,9 @@ type ResponseLaunchTemplateData struct { // The ID of the RAM disk, if applicable. RamDiskId *string + // The secondary interfaces associated with the launch template. + SecondaryInterfaces []LaunchTemplateInstanceSecondaryInterfaceSpecification + // The security group IDs. SecurityGroupIds []string @@ -19504,6 +19790,223 @@ type ScheduledInstancesPrivateIpAddressConfig struct { noSmithyDocumentSerde } +// Describes a secondary interface. +type SecondaryInterface struct { + + // The attachment information for the secondary interface. + Attachment *SecondaryInterfaceAttachment + + // The Availability Zone of the secondary interface. + AvailabilityZone *string + + // The ID of the Availability Zone of the secondary interface. + AvailabilityZoneId *string + + // The MAC address of the secondary interface. + MacAddress *string + + // The ID of the Amazon Web Services account that owns the secondary interface. + OwnerId *string + + // The private IPv4 addresses associated with the secondary interface. + PrivateIpv4Addresses []SecondaryInterfaceIpv4Address + + // The Amazon Resource Name (ARN) of the secondary interface. + SecondaryInterfaceArn *string + + // The ID of the secondary interface. + SecondaryInterfaceId *string + + // The type of secondary interface. + SecondaryInterfaceType SecondaryInterfaceType + + // The ID of the secondary network. + SecondaryNetworkId *string + + // The type of the secondary network. + SecondaryNetworkType SecondaryNetworkType + + // The ID of the secondary subnet. + SecondarySubnetId *string + + // Indicates whether source/destination checking is enabled. + SourceDestCheck *bool + + // The status of the secondary interface. + Status SecondaryInterfaceStatus + + // The tags assigned to the secondary interface. + Tags []Tag + + noSmithyDocumentSerde +} + +// Describes the attachment of a secondary interface to an instance. +type SecondaryInterfaceAttachment struct { + + // The timestamp when the attachment was created. + AttachTime *time.Time + + // The ID of the attachment. + AttachmentId *string + + // Indicates whether the secondary interface is deleted when the instance is + // terminated. + // + // The only supported value for this field is true . + DeleteOnTermination *bool + + // The device index of the secondary interface. + DeviceIndex *int32 + + // The ID of the instance to which the secondary interface is attached. + InstanceId *string + + // The Amazon Web Services account ID of the owner of the instance. + InstanceOwnerId *string + + // The index of the network card. + NetworkCardIndex *int32 + + // The attachment state. + Status AttachmentStatus + + noSmithyDocumentSerde +} + +// Describes a private IPv4 address for a secondary interface. +type SecondaryInterfaceIpv4Address struct { + + // The private IPv4 address. + PrivateIpAddress *string + + noSmithyDocumentSerde +} + +// Describes a private IPv4 address specification for a secondary interface. +type SecondaryInterfacePrivateIpAddressSpecification struct { + + // The private IPv4 address. + PrivateIpAddress *string + + noSmithyDocumentSerde +} + +// Describes a private IPv4 address specification for a secondary interface +// request. +type SecondaryInterfacePrivateIpAddressSpecificationRequest struct { + + // The private IPv4 address. + PrivateIpAddress *string + + noSmithyDocumentSerde +} + +// Describes a secondary network. +type SecondaryNetwork struct { + + // Information about the IPv4 CIDR blocks associated with the secondary network. + Ipv4CidrBlockAssociations []SecondaryNetworkIpv4CidrBlockAssociation + + // The ID of the Amazon Web Services account that owns the secondary network. + OwnerId *string + + // The Amazon Resource Name (ARN) of the secondary network. + SecondaryNetworkArn *string + + // The ID of the secondary network. + SecondaryNetworkId *string + + // The state of the secondary network. + State SecondaryNetworkState + + // The reason for the current state of the secondary network. + StateReason *string + + // The tags assigned to the secondary network. + Tags []Tag + + // The type of the secondary network. + Type SecondaryNetworkType + + noSmithyDocumentSerde +} + +// Describes an IPv4 CIDR block associated with a secondary network. +type SecondaryNetworkIpv4CidrBlockAssociation struct { + + // The association ID for the IPv4 CIDR block. + AssociationId *string + + // The IPv4 CIDR block. + CidrBlock *string + + // The state of the CIDR block association. + State SecondaryNetworkCidrBlockAssociationState + + // The reason for the current state of the CIDR block association. + StateReason *string + + noSmithyDocumentSerde +} + +// Describes a secondary subnet. +type SecondarySubnet struct { + + // The Availability Zone of the secondary subnet. + AvailabilityZone *string + + // The ID of the Availability Zone of the secondary subnet. + AvailabilityZoneId *string + + // Information about the IPv4 CIDR blocks associated with the secondary subnet. + Ipv4CidrBlockAssociations []SecondarySubnetIpv4CidrBlockAssociation + + // The ID of the Amazon Web Services account that owns the secondary subnet. + OwnerId *string + + // The ID of the secondary network. + SecondaryNetworkId *string + + // The type of the secondary network. + SecondaryNetworkType SecondaryNetworkType + + // The Amazon Resource Name (ARN) of the secondary subnet. + SecondarySubnetArn *string + + // The ID of the secondary subnet. + SecondarySubnetId *string + + // The state of the secondary subnet. + State SecondarySubnetState + + // The reason for the current state of the secondary subnet. + StateReason *string + + // The tags assigned to the secondary subnet. + Tags []Tag + + noSmithyDocumentSerde +} + +// Describes an IPv4 CIDR block associated with a secondary subnet. +type SecondarySubnetIpv4CidrBlockAssociation struct { + + // The association ID for the IPv4 CIDR block. + AssociationId *string + + // The IPv4 CIDR block. + CidrBlock *string + + // The state of the CIDR block association. + State SecondarySubnetCidrBlockAssociationState + + // The reason for the current state of the CIDR block association. + StateReason *string + + noSmithyDocumentSerde +} + // Describes a security group. type SecurityGroup struct { diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/validators.go b/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/validators.go index d433db82c..dbca17cae 100644 --- a/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/validators.go +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/validators.go @@ -2150,6 +2150,46 @@ func (m *validateOpCreateRouteTable) HandleInitialize(ctx context.Context, in mi return next.HandleInitialize(ctx, in) } +type validateOpCreateSecondaryNetwork struct { +} + +func (*validateOpCreateSecondaryNetwork) ID() string { + return "OperationInputValidation" +} + +func (m *validateOpCreateSecondaryNetwork) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + input, ok := in.Parameters.(*CreateSecondaryNetworkInput) + if !ok { + return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) + } + if err := validateOpCreateSecondaryNetworkInput(input); err != nil { + return out, metadata, err + } + return next.HandleInitialize(ctx, in) +} + +type validateOpCreateSecondarySubnet struct { +} + +func (*validateOpCreateSecondarySubnet) ID() string { + return "OperationInputValidation" +} + +func (m *validateOpCreateSecondarySubnet) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + input, ok := in.Parameters.(*CreateSecondarySubnetInput) + if !ok { + return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) + } + if err := validateOpCreateSecondarySubnetInput(input); err != nil { + return out, metadata, err + } + return next.HandleInitialize(ctx, in) +} + type validateOpCreateSecurityGroup struct { } @@ -3830,6 +3870,46 @@ func (m *validateOpDeleteRouteTable) HandleInitialize(ctx context.Context, in mi return next.HandleInitialize(ctx, in) } +type validateOpDeleteSecondaryNetwork struct { +} + +func (*validateOpDeleteSecondaryNetwork) ID() string { + return "OperationInputValidation" +} + +func (m *validateOpDeleteSecondaryNetwork) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + input, ok := in.Parameters.(*DeleteSecondaryNetworkInput) + if !ok { + return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) + } + if err := validateOpDeleteSecondaryNetworkInput(input); err != nil { + return out, metadata, err + } + return next.HandleInitialize(ctx, in) +} + +type validateOpDeleteSecondarySubnet struct { +} + +func (*validateOpDeleteSecondarySubnet) ID() string { + return "OperationInputValidation" +} + +func (m *validateOpDeleteSecondarySubnet) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + input, ok := in.Parameters.(*DeleteSecondarySubnetInput) + if !ok { + return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) + } + if err := validateOpDeleteSecondarySubnetInput(input); err != nil { + return out, metadata, err + } + return next.HandleInitialize(ctx, in) +} + type validateOpDeleteSnapshot struct { } @@ -10938,6 +11018,14 @@ func addOpCreateRouteTableValidationMiddleware(stack *middleware.Stack) error { return stack.Initialize.Add(&validateOpCreateRouteTable{}, middleware.After) } +func addOpCreateSecondaryNetworkValidationMiddleware(stack *middleware.Stack) error { + return stack.Initialize.Add(&validateOpCreateSecondaryNetwork{}, middleware.After) +} + +func addOpCreateSecondarySubnetValidationMiddleware(stack *middleware.Stack) error { + return stack.Initialize.Add(&validateOpCreateSecondarySubnet{}, middleware.After) +} + func addOpCreateSecurityGroupValidationMiddleware(stack *middleware.Stack) error { return stack.Initialize.Add(&validateOpCreateSecurityGroup{}, middleware.After) } @@ -11274,6 +11362,14 @@ func addOpDeleteRouteTableValidationMiddleware(stack *middleware.Stack) error { return stack.Initialize.Add(&validateOpDeleteRouteTable{}, middleware.After) } +func addOpDeleteSecondaryNetworkValidationMiddleware(stack *middleware.Stack) error { + return stack.Initialize.Add(&validateOpDeleteSecondaryNetwork{}, middleware.After) +} + +func addOpDeleteSecondarySubnetValidationMiddleware(stack *middleware.Stack) error { + return stack.Initialize.Add(&validateOpDeleteSecondarySubnet{}, middleware.After) +} + func addOpDeleteSnapshotValidationMiddleware(stack *middleware.Stack) error { return stack.Initialize.Add(&validateOpDeleteSnapshot{}, middleware.After) } @@ -13057,6 +13153,72 @@ func validateInstanceRequirementsWithMetadataRequest(v *types.InstanceRequiremen } } +func validateInstanceSecondaryInterfacePrivateIpAddressListRequest(v []types.InstanceSecondaryInterfacePrivateIpAddressRequest) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "InstanceSecondaryInterfacePrivateIpAddressListRequest"} + for i := range v { + if err := validateInstanceSecondaryInterfacePrivateIpAddressRequest(&v[i]); err != nil { + invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) + } + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + +func validateInstanceSecondaryInterfacePrivateIpAddressRequest(v *types.InstanceSecondaryInterfacePrivateIpAddressRequest) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "InstanceSecondaryInterfacePrivateIpAddressRequest"} + if v.PrivateIpAddress == nil { + invalidParams.Add(smithy.NewErrParamRequired("PrivateIpAddress")) + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + +func validateInstanceSecondaryInterfaceSpecificationListRequest(v []types.InstanceSecondaryInterfaceSpecificationRequest) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "InstanceSecondaryInterfaceSpecificationListRequest"} + for i := range v { + if err := validateInstanceSecondaryInterfaceSpecificationRequest(&v[i]); err != nil { + invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) + } + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + +func validateInstanceSecondaryInterfaceSpecificationRequest(v *types.InstanceSecondaryInterfaceSpecificationRequest) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "InstanceSecondaryInterfaceSpecificationRequest"} + if v.PrivateIpAddresses != nil { + if err := validateInstanceSecondaryInterfacePrivateIpAddressListRequest(v.PrivateIpAddresses); err != nil { + invalidParams.AddNested("PrivateIpAddresses", err.(smithy.InvalidParamsError)) + } + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + func validateInstanceSpecification(v *types.InstanceSpecification) error { if v == nil { return nil @@ -15490,6 +15652,42 @@ func validateOpCreateRouteTableInput(v *CreateRouteTableInput) error { } } +func validateOpCreateSecondaryNetworkInput(v *CreateSecondaryNetworkInput) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "CreateSecondaryNetworkInput"} + if v.Ipv4CidrBlock == nil { + invalidParams.Add(smithy.NewErrParamRequired("Ipv4CidrBlock")) + } + if len(v.NetworkType) == 0 { + invalidParams.Add(smithy.NewErrParamRequired("NetworkType")) + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + +func validateOpCreateSecondarySubnetInput(v *CreateSecondarySubnetInput) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "CreateSecondarySubnetInput"} + if v.Ipv4CidrBlock == nil { + invalidParams.Add(smithy.NewErrParamRequired("Ipv4CidrBlock")) + } + if v.SecondaryNetworkId == nil { + invalidParams.Add(smithy.NewErrParamRequired("SecondaryNetworkId")) + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + func validateOpCreateSecurityGroupInput(v *CreateSecurityGroupInput) error { if v == nil { return nil @@ -16871,6 +17069,36 @@ func validateOpDeleteRouteTableInput(v *DeleteRouteTableInput) error { } } +func validateOpDeleteSecondaryNetworkInput(v *DeleteSecondaryNetworkInput) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "DeleteSecondaryNetworkInput"} + if v.SecondaryNetworkId == nil { + invalidParams.Add(smithy.NewErrParamRequired("SecondaryNetworkId")) + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + +func validateOpDeleteSecondarySubnetInput(v *DeleteSecondarySubnetInput) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "DeleteSecondarySubnetInput"} + if v.SecondarySubnetId == nil { + invalidParams.Add(smithy.NewErrParamRequired("SecondarySubnetId")) + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + func validateOpDeleteSnapshotInput(v *DeleteSnapshotInput) error { if v == nil { return nil @@ -20209,12 +20437,6 @@ func validateOpModifyInstanceCpuOptionsInput(v *ModifyInstanceCpuOptionsInput) e if v.InstanceId == nil { invalidParams.Add(smithy.NewErrParamRequired("InstanceId")) } - if v.CoreCount == nil { - invalidParams.Add(smithy.NewErrParamRequired("CoreCount")) - } - if v.ThreadsPerCore == nil { - invalidParams.Add(smithy.NewErrParamRequired("ThreadsPerCore")) - } if invalidParams.Len() > 0 { return invalidParams } else { @@ -22069,6 +22291,11 @@ func validateOpRunInstancesInput(v *RunInstancesInput) error { invalidParams.AddNested("CreditSpecification", err.(smithy.InvalidParamsError)) } } + if v.SecondaryInterfaces != nil { + if err := validateInstanceSecondaryInterfaceSpecificationListRequest(v.SecondaryInterfaces); err != nil { + invalidParams.AddNested("SecondaryInterfaces", err.(smithy.InvalidParamsError)) + } + } if invalidParams.Len() > 0 { return invalidParams } else { diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding/CHANGELOG.md b/vendor/github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding/CHANGELOG.md index 6ffbf3fe4..b594dddaa 100644 --- a/vendor/github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding/CHANGELOG.md +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding/CHANGELOG.md @@ -1,3 +1,11 @@ +# v1.13.6 (2026-03-03) + +* **Dependency Update**: Bump minimum Go version to 1.24 + +# v1.13.5 (2026-02-23) + +* No change notes available for this release. + # v1.13.4 (2025-12-02) * **Dependency Update**: Upgrade to smithy-go v1.24.0. Notably this version of the library reduces the allocation footprint of the middleware system. We observe a ~10% reduction in allocations per SDK call with this change. diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding/go_module_metadata.go b/vendor/github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding/go_module_metadata.go index 970bb210e..0ece341c6 100644 --- a/vendor/github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding/go_module_metadata.go +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding/go_module_metadata.go @@ -3,4 +3,4 @@ package acceptencoding // goModuleVersion is the tagged release for this module -const goModuleVersion = "1.13.4" +const goModuleVersion = "1.13.6" diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/internal/presigned-url/CHANGELOG.md b/vendor/github.com/aws/aws-sdk-go-v2/service/internal/presigned-url/CHANGELOG.md index 81fbac09c..6be7fa536 100644 --- a/vendor/github.com/aws/aws-sdk-go-v2/service/internal/presigned-url/CHANGELOG.md +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/internal/presigned-url/CHANGELOG.md @@ -1,3 +1,13 @@ +# v1.13.19 (2026-03-03) + +* **Bug Fix**: Modernize non codegen files with go fix +* **Dependency Update**: Bump minimum Go version to 1.24 +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.13.18 (2026-02-23) + +* **Dependency Update**: Updated to the latest SDK module versions + # v1.13.17 (2026-01-09) * **Dependency Update**: Updated to the latest SDK module versions diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/internal/presigned-url/go_module_metadata.go b/vendor/github.com/aws/aws-sdk-go-v2/service/internal/presigned-url/go_module_metadata.go index d7c886c13..983aaa4b6 100644 --- a/vendor/github.com/aws/aws-sdk-go-v2/service/internal/presigned-url/go_module_metadata.go +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/internal/presigned-url/go_module_metadata.go @@ -3,4 +3,4 @@ package presignedurl // goModuleVersion is the tagged release for this module -const goModuleVersion = "1.13.17" +const goModuleVersion = "1.13.19" diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/internal/presigned-url/middleware.go b/vendor/github.com/aws/aws-sdk-go-v2/service/internal/presigned-url/middleware.go index 1e2f5c812..8b25d0387 100644 --- a/vendor/github.com/aws/aws-sdk-go-v2/service/internal/presigned-url/middleware.go +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/internal/presigned-url/middleware.go @@ -14,26 +14,26 @@ import ( // presigned URL. type URLPresigner interface { // PresignURL presigns a URL. - PresignURL(ctx context.Context, srcRegion string, params interface{}) (*v4.PresignedHTTPRequest, error) + PresignURL(ctx context.Context, srcRegion string, params any) (*v4.PresignedHTTPRequest, error) } // ParameterAccessor provides an collection of accessor to for retrieving and // setting the values needed to PresignedURL generation type ParameterAccessor struct { // GetPresignedURL accessor points to a function that retrieves a presigned url if present - GetPresignedURL func(interface{}) (string, bool, error) + GetPresignedURL func(any) (string, bool, error) // GetSourceRegion accessor points to a function that retrieves source region for presigned url - GetSourceRegion func(interface{}) (string, bool, error) + GetSourceRegion func(any) (string, bool, error) // CopyInput accessor points to a function that takes in an input, and returns a copy. - CopyInput func(interface{}) (interface{}, error) + CopyInput func(any) (any, error) // SetDestinationRegion accessor points to a function that sets destination region on api input struct - SetDestinationRegion func(interface{}, string) error + SetDestinationRegion func(any, string) error // SetPresignedURL accessor points to a function that sets presigned url on api input struct - SetPresignedURL func(interface{}, string) error + SetPresignedURL func(any, string) error } // Options provides the set of options needed by the presigned URL middleware. diff --git a/vendor/github.com/aws/smithy-go/CHANGELOG.md b/vendor/github.com/aws/smithy-go/CHANGELOG.md index 3f1612c5b..27fc88123 100644 --- a/vendor/github.com/aws/smithy-go/CHANGELOG.md +++ b/vendor/github.com/aws/smithy-go/CHANGELOG.md @@ -1,8 +1,17 @@ +# Release (2026-02-27) + +## General Highlights +* **Dependency Update**: Updated to the latest SDK module versions + # Release (2026-02-20) ## General Highlights * **Dependency Update**: Updated to the latest SDK module versions +## Module Highlights +* `github.com/aws/smithy-go`: v1.24.1 + * **Feature**: Add new middleware functions to get event stream output from middleware + # Release (2025-12-01) ## General Highlights diff --git a/vendor/github.com/aws/smithy-go/README.md b/vendor/github.com/aws/smithy-go/README.md index ddce37b99..a413ff3d8 100644 --- a/vendor/github.com/aws/smithy-go/README.md +++ b/vendor/github.com/aws/smithy-go/README.md @@ -4,7 +4,7 @@ [Smithy](https://smithy.io/) code generators for Go and the accompanying smithy-go runtime. -The smithy-go runtime requires a minimum version of Go 1.23. +The smithy-go runtime requires a minimum version of Go 1.24. **WARNING: All interfaces are subject to change.** @@ -80,7 +80,7 @@ example created from `smithy init`: "service": "example.weather#Weather", "module": "github.com/example/weather", "generateGoMod": true, - "goDirective": "1.23" + "goDirective": "1.24" } } } diff --git a/vendor/github.com/aws/smithy-go/go_module_metadata.go b/vendor/github.com/aws/smithy-go/go_module_metadata.go index 87b3b9e3f..dc9dfd0d8 100644 --- a/vendor/github.com/aws/smithy-go/go_module_metadata.go +++ b/vendor/github.com/aws/smithy-go/go_module_metadata.go @@ -3,4 +3,4 @@ package smithy // goModuleVersion is the tagged release for this module -const goModuleVersion = "1.24.1" +const goModuleVersion = "1.24.2" diff --git a/vendor/modules.txt b/vendor/modules.txt index 6b233b184..8f6db3b47 100644 --- a/vendor/modules.txt +++ b/vendor/modules.txt @@ -165,8 +165,8 @@ github.com/ashanbrown/forbidigo/forbidigo # github.com/ashanbrown/makezero v1.2.0 ## explicit; go 1.12 github.com/ashanbrown/makezero/makezero -# github.com/aws/aws-sdk-go-v2 v1.41.1 -## explicit; go 1.23 +# github.com/aws/aws-sdk-go-v2 v1.41.3 +## explicit; go 1.24 github.com/aws/aws-sdk-go-v2/aws github.com/aws/aws-sdk-go-v2/aws/arn github.com/aws/aws-sdk-go-v2/aws/defaults @@ -214,11 +214,11 @@ github.com/aws/aws-sdk-go-v2/credentials/stscreds ## explicit; go 1.23 github.com/aws/aws-sdk-go-v2/feature/ec2/imds github.com/aws/aws-sdk-go-v2/feature/ec2/imds/internal/config -# github.com/aws/aws-sdk-go-v2/internal/configsources v1.4.17 -## explicit; go 1.23 +# github.com/aws/aws-sdk-go-v2/internal/configsources v1.4.19 +## explicit; go 1.24 github.com/aws/aws-sdk-go-v2/internal/configsources -# github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.7.17 -## explicit; go 1.23 +# github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.7.19 +## explicit; go 1.24 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 # github.com/aws/aws-sdk-go-v2/internal/ini v1.8.4 ## explicit; go 1.23 @@ -228,8 +228,8 @@ github.com/aws/aws-sdk-go-v2/internal/ini github.com/aws/aws-sdk-go-v2/internal/v4a github.com/aws/aws-sdk-go-v2/internal/v4a/internal/crypto github.com/aws/aws-sdk-go-v2/internal/v4a/internal/v4 -# github.com/aws/aws-sdk-go-v2/service/ec2 v1.285.0 -## explicit; go 1.23 +# github.com/aws/aws-sdk-go-v2/service/ec2 v1.294.0 +## explicit; go 1.24 github.com/aws/aws-sdk-go-v2/service/ec2 github.com/aws/aws-sdk-go-v2/service/ec2/internal/endpoints github.com/aws/aws-sdk-go-v2/service/ec2/types @@ -238,14 +238,14 @@ github.com/aws/aws-sdk-go-v2/service/ec2/types github.com/aws/aws-sdk-go-v2/service/eks github.com/aws/aws-sdk-go-v2/service/eks/internal/endpoints github.com/aws/aws-sdk-go-v2/service/eks/types -# github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.4 -## explicit; go 1.23 +# github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.6 +## explicit; go 1.24 github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding # github.com/aws/aws-sdk-go-v2/service/internal/checksum v1.9.7 ## explicit; go 1.23 github.com/aws/aws-sdk-go-v2/service/internal/checksum -# github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.13.17 -## explicit; go 1.23 +# github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.13.19 +## explicit; go 1.24 github.com/aws/aws-sdk-go-v2/service/internal/presigned-url # github.com/aws/aws-sdk-go-v2/service/internal/s3shared v1.19.16 ## explicit; go 1.23 @@ -279,8 +279,8 @@ github.com/aws/aws-sdk-go-v2/service/ssooidc/types github.com/aws/aws-sdk-go-v2/service/sts github.com/aws/aws-sdk-go-v2/service/sts/internal/endpoints github.com/aws/aws-sdk-go-v2/service/sts/types -# github.com/aws/smithy-go v1.24.1 -## explicit; go 1.23 +# github.com/aws/smithy-go v1.24.2 +## explicit; go 1.24 github.com/aws/smithy-go github.com/aws/smithy-go/auth github.com/aws/smithy-go/auth/bearer